From: dirk Date: Mon, 4 Aug 2014 19:44:34 +0000 (+0000) Subject: Newline fix. X-Git-Tag: 7.0.1-0~2125 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=832becc728afe1d3fd7387fe1ccb658b163ca8a1;p=imagemagick Newline fix. Replaced call to DestroySemaphoreInfo with RelinquishSemaphoreInfo. --- diff --git a/MagickCore/accelerate.c b/MagickCore/accelerate.c index a17727ce3..246386278 100644 --- a/MagickCore/accelerate.c +++ b/MagickCore/accelerate.c @@ -91,106 +91,106 @@ Include declarations. /* pad the global workgroup size to the next multiple of the local workgroup size */ -inline static unsigned int padGlobalWorkgroupSizeToLocalWorkgroupSize( - const unsigned int orgGlobalSize,const unsigned int localGroupSize) -{ - return ((orgGlobalSize+(localGroupSize-1))/localGroupSize*localGroupSize); -} - -static MagickBooleanType checkOpenCLEnvironment(ExceptionInfo* exception) -{ - MagickBooleanType - flag; - - MagickCLEnv - clEnv; - - clEnv=GetDefaultOpenCLEnv(); - - GetMagickOpenCLEnvParam(clEnv,MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED, - sizeof(MagickBooleanType),&flag,exception); - if (flag != MagickFalse) - return(MagickFalse); - - GetMagickOpenCLEnvParam(clEnv,MAGICK_OPENCL_ENV_PARAM_OPENCL_INITIALIZED, - sizeof(MagickBooleanType),&flag,exception); - if (flag == MagickFalse) - { - if (InitOpenCLEnv(clEnv,exception) == MagickFalse) - return(MagickFalse); - - GetMagickOpenCLEnvParam(clEnv,MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED, - sizeof(MagickBooleanType),&flag,exception); - if (flag != MagickFalse) - return(MagickFalse); - } - - return(MagickTrue); -} - -static MagickBooleanType checkAccelerateCondition(const Image* image, - const ChannelType channel) -{ - /* check if the image's colorspace is supported */ - if (image->colorspace != RGBColorspace && - image->colorspace != sRGBColorspace && - image->colorspace != GRAYColorspace) - return(MagickFalse); - - /* check if the channel is supported */ - if (((channel & RedChannel) == 0) || - ((channel & GreenChannel) == 0) || - ((channel & BlueChannel) == 0)) - return(MagickFalse); - - /* check if the virtual pixel method is compatible with the OpenCL implementation */ - if ((GetImageVirtualPixelMethod(image) != UndefinedVirtualPixelMethod) && - (GetImageVirtualPixelMethod(image) != EdgeVirtualPixelMethod)) - return(MagickFalse); - - /* check if the image has read / write mask */ - if (image->read_mask != MagickFalse || image->write_mask != MagickFalse) - return(MagickFalse); - - return(MagickTrue); -} - -static MagickBooleanType checkHistogramCondition(Image *image, - const ChannelType channel) -{ - /* ensure this is the only pass get in for now. */ - if ((channel & SyncChannels) == 0) - return MagickFalse; - - if (image->intensity == Rec601LuminancePixelIntensityMethod || - image->intensity == Rec709LuminancePixelIntensityMethod) - return MagickFalse; - - if (image->colorspace != sRGBColorspace) - return MagickFalse; - - return MagickTrue; -} - -static MagickBooleanType splitImage(const Image* image) -{ - MagickBooleanType - split; - - MagickCLEnv - clEnv; - - unsigned long - allocSize, - tempSize; - - clEnv=GetDefaultOpenCLEnv(); - - allocSize=GetOpenCLDeviceMaxMemAllocSize(clEnv); - tempSize=image->columns * image->rows * 4 * 4; - - split = ((tempSize > allocSize) ? MagickTrue : MagickFalse); - return(split); +inline static unsigned int padGlobalWorkgroupSizeToLocalWorkgroupSize( + const unsigned int orgGlobalSize,const unsigned int localGroupSize) +{ + return ((orgGlobalSize+(localGroupSize-1))/localGroupSize*localGroupSize); +} + +static MagickBooleanType checkOpenCLEnvironment(ExceptionInfo* exception) +{ + MagickBooleanType + flag; + + MagickCLEnv + clEnv; + + clEnv=GetDefaultOpenCLEnv(); + + GetMagickOpenCLEnvParam(clEnv,MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED, + sizeof(MagickBooleanType),&flag,exception); + if (flag != MagickFalse) + return(MagickFalse); + + GetMagickOpenCLEnvParam(clEnv,MAGICK_OPENCL_ENV_PARAM_OPENCL_INITIALIZED, + sizeof(MagickBooleanType),&flag,exception); + if (flag == MagickFalse) + { + if (InitOpenCLEnv(clEnv,exception) == MagickFalse) + return(MagickFalse); + + GetMagickOpenCLEnvParam(clEnv,MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED, + sizeof(MagickBooleanType),&flag,exception); + if (flag != MagickFalse) + return(MagickFalse); + } + + return(MagickTrue); +} + +static MagickBooleanType checkAccelerateCondition(const Image* image, + const ChannelType channel) +{ + /* check if the image's colorspace is supported */ + if (image->colorspace != RGBColorspace && + image->colorspace != sRGBColorspace && + image->colorspace != GRAYColorspace) + return(MagickFalse); + + /* check if the channel is supported */ + if (((channel & RedChannel) == 0) || + ((channel & GreenChannel) == 0) || + ((channel & BlueChannel) == 0)) + return(MagickFalse); + + /* check if the virtual pixel method is compatible with the OpenCL implementation */ + if ((GetImageVirtualPixelMethod(image) != UndefinedVirtualPixelMethod) && + (GetImageVirtualPixelMethod(image) != EdgeVirtualPixelMethod)) + return(MagickFalse); + + /* check if the image has read / write mask */ + if (image->read_mask != MagickFalse || image->write_mask != MagickFalse) + return(MagickFalse); + + return(MagickTrue); +} + +static MagickBooleanType checkHistogramCondition(Image *image, + const ChannelType channel) +{ + /* ensure this is the only pass get in for now. */ + if ((channel & SyncChannels) == 0) + return MagickFalse; + + if (image->intensity == Rec601LuminancePixelIntensityMethod || + image->intensity == Rec709LuminancePixelIntensityMethod) + return MagickFalse; + + if (image->colorspace != sRGBColorspace) + return MagickFalse; + + return MagickTrue; +} + +static MagickBooleanType splitImage(const Image* image) +{ + MagickBooleanType + split; + + MagickCLEnv + clEnv; + + unsigned long + allocSize, + tempSize; + + clEnv=GetDefaultOpenCLEnv(); + + allocSize=GetOpenCLDeviceMaxMemAllocSize(clEnv); + tempSize=image->columns * image->rows * 4 * 4; + + split = ((tempSize > allocSize) ? MagickTrue : MagickFalse); + return(split); } /* @@ -225,90 +225,90 @@ static MagickBooleanType splitImage(const Image* image) % */ -static Image *ComputeConvolveImage(const Image* image, - const ChannelType channel,const KernelInfo *kernel,ExceptionInfo *exception) -{ - CacheView - *filteredImage_view, - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_kernel - clkernel; - - cl_int - clStatus; - - cl_mem - convolutionKernel, - filteredImageBuffer, - imageBuffer; - - cl_mem_flags - mem_flags; - - cl_ulong - deviceLocalMemorySize; - - const void - *inputPixels; - - float - *kernelBufferPtr; - - Image - *filteredImage; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - size_t - global_work_size[3], - localGroupSize[3], - localMemoryRequirement; - - unsigned - kernelSize; - - unsigned int - filterHeight, - filterWidth, - i, - imageHeight, - imageWidth, - matte; - - void - *filteredPixels, - *hostPtr; - - /* intialize all CL objects to NULL */ - context = NULL; - imageBuffer = NULL; - filteredImageBuffer = NULL; - convolutionKernel = NULL; - clkernel = NULL; - queue = NULL; - - filteredImage = NULL; - filteredImage_view = NULL; +static Image *ComputeConvolveImage(const Image* image, + const ChannelType channel,const KernelInfo *kernel,ExceptionInfo *exception) +{ + CacheView + *filteredImage_view, + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_kernel + clkernel; + + cl_int + clStatus; + + cl_mem + convolutionKernel, + filteredImageBuffer, + imageBuffer; + + cl_mem_flags + mem_flags; + + cl_ulong + deviceLocalMemorySize; + + const void + *inputPixels; + + float + *kernelBufferPtr; + + Image + *filteredImage; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + size_t + global_work_size[3], + localGroupSize[3], + localMemoryRequirement; + + unsigned + kernelSize; + + unsigned int + filterHeight, + filterWidth, + i, + imageHeight, + imageWidth, + matte; + + void + *filteredPixels, + *hostPtr; + + /* intialize all CL objects to NULL */ + context = NULL; + imageBuffer = NULL; + filteredImageBuffer = NULL; + convolutionKernel = NULL; + clkernel = NULL; + queue = NULL; + + filteredImage = NULL; + filteredImage_view = NULL; outputReady = MagickFalse; clEnv = GetDefaultOpenCLEnv(); context = GetOpenCLContext(clEnv); - image_view=AcquireVirtualCacheView(image,exception); + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (const void *) NULL) { @@ -330,7 +330,7 @@ static Image *ComputeConvolveImage(const Image* image, mem_flags = CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR; } /* create a CL buffer from image pixel buffer */ - length = image->columns * image->rows; + length = image->columns * image->rows; imageBuffer = clEnv->library->clCreateBuffer(context, mem_flags, length * sizeof(CLPixelPacket), (void*)inputPixels, &clStatus); if (clStatus != CL_SUCCESS) { @@ -345,7 +345,7 @@ static Image *ComputeConvolveImage(const Image* image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -525,13 +525,13 @@ static Image *ComputeConvolveImage(const Image* image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) filteredImage_view=DestroyCacheView(filteredImage_view); if (imageBuffer != NULL) @@ -561,84 +561,84 @@ cleanup: return(filteredImage); } -MagickExport Image *AccelerateConvolveImageChannel(const Image *image, - const ChannelType channel,const KernelInfo *kernel,ExceptionInfo *exception) -{ - Image - *filteredImage; - - assert(image != NULL); - assert(kernel != (KernelInfo *) NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse)) - return NULL; - - filteredImage=ComputeConvolveImage(image, channel, kernel, exception); - return(filteredImage); +MagickExport Image *AccelerateConvolveImageChannel(const Image *image, + const ChannelType channel,const KernelInfo *kernel,ExceptionInfo *exception) +{ + Image + *filteredImage; + + assert(image != NULL); + assert(kernel != (KernelInfo *) NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse)) + return NULL; + + filteredImage=ComputeConvolveImage(image, channel, kernel, exception); + return(filteredImage); } -static MagickBooleanType ComputeFunctionImage(Image *image, - const ChannelType channel,const MagickFunction function, - const size_t number_parameters,const double *parameters, - ExceptionInfo *exception) -{ - CacheView - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_kernel - clkernel; - - cl_mem - imageBuffer, - parametersBuffer; - - cl_mem_flags - mem_flags; - - float - *parametersBufferPtr; - - MagickBooleanType - status; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - size_t - globalWorkSize[2]; - - unsigned int - i; - - void - *pixels; - - status = MagickFalse; - - context = NULL; - clkernel = NULL; - queue = NULL; - imageBuffer = NULL; - parametersBuffer = NULL; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - - image_view=AcquireAuthenticCacheView(image,exception); +static MagickBooleanType ComputeFunctionImage(Image *image, + const ChannelType channel,const MagickFunction function, + const size_t number_parameters,const double *parameters, + ExceptionInfo *exception) +{ + CacheView + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_kernel + clkernel; + + cl_mem + imageBuffer, + parametersBuffer; + + cl_mem_flags + mem_flags; + + float + *parametersBufferPtr; + + MagickBooleanType + status; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + size_t + globalWorkSize[2]; + + unsigned int + i; + + void + *pixels; + + status = MagickFalse; + + context = NULL; + clkernel = NULL; + queue = NULL; + imageBuffer = NULL; + parametersBuffer = NULL; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + + image_view=AcquireAuthenticCacheView(image,exception); pixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception); if (pixels == (void *) NULL) { @@ -741,11 +741,11 @@ static MagickBooleanType ComputeFunctionImage(Image *image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", "."); goto cleanup; } - status=SyncCacheViewAuthenticPixels(image_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - + status=SyncCacheViewAuthenticPixels(image_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + image_view=DestroyCacheView(image_view); if (clkernel != NULL) RelinquishOpenCLKernel(clEnv, clkernel); @@ -756,23 +756,23 @@ cleanup: return(status); } -MagickExport MagickBooleanType AccelerateFunctionImage(Image *image, - const ChannelType channel,const MagickFunction function, - const size_t number_parameters,const double *parameters, - ExceptionInfo *exception) -{ - MagickBooleanType - status; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse)) - return(MagickFalse); - - status=ComputeFunctionImage(image, channel, function, number_parameters, parameters, exception); - return(status); +MagickExport MagickBooleanType AccelerateFunctionImage(Image *image, + const ChannelType channel,const MagickFunction function, + const size_t number_parameters,const double *parameters, + ExceptionInfo *exception) +{ + MagickBooleanType + status; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse)) + return(MagickFalse); + + status=ComputeFunctionImage(image, channel, function, number_parameters, parameters, exception); + return(status); } /* @@ -813,90 +813,90 @@ MagickExport MagickBooleanType AccelerateFunctionImage(Image *image, % */ -static Image *ComputeBlurImage(const Image* image,const ChannelType channel, - const double radius,const double sigma,ExceptionInfo *exception) -{ - CacheView - *filteredImage_view, - *image_view; - - char - geometry[MaxTextExtent]; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_kernel - blurColumnKernel, - blurRowKernel; - - cl_mem - filteredImageBuffer, - imageBuffer, - imageKernelBuffer, - tempImageBuffer; - - cl_mem_flags - mem_flags; - - const void - *inputPixels; - - float - *kernelBufferPtr; - - Image - *filteredImage; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - KernelInfo - *kernel; - - unsigned int - i, - imageColumns, - imageRows, - kernelWidth; - - void - *filteredPixels, - *hostPtr; - - context = NULL; - filteredImage = NULL; - filteredImage_view = NULL; - imageBuffer = NULL; - tempImageBuffer = NULL; - filteredImageBuffer = NULL; - imageKernelBuffer = NULL; - blurRowKernel = NULL; - blurColumnKernel = NULL; - queue = NULL; - kernel = NULL; - - outputReady = MagickFalse; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - /* Create and initialize OpenCL buffers. */ - { - image_view=AcquireVirtualCacheView(image,exception); +static Image *ComputeBlurImage(const Image* image,const ChannelType channel, + const double radius,const double sigma,ExceptionInfo *exception) +{ + CacheView + *filteredImage_view, + *image_view; + + char + geometry[MaxTextExtent]; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_kernel + blurColumnKernel, + blurRowKernel; + + cl_mem + filteredImageBuffer, + imageBuffer, + imageKernelBuffer, + tempImageBuffer; + + cl_mem_flags + mem_flags; + + const void + *inputPixels; + + float + *kernelBufferPtr; + + Image + *filteredImage; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + KernelInfo + *kernel; + + unsigned int + i, + imageColumns, + imageRows, + kernelWidth; + + void + *filteredPixels, + *hostPtr; + + context = NULL; + filteredImage = NULL; + filteredImage_view = NULL; + imageBuffer = NULL; + tempImageBuffer = NULL; + filteredImageBuffer = NULL; + imageKernelBuffer = NULL; + blurRowKernel = NULL; + blurColumnKernel = NULL; + queue = NULL; + kernel = NULL; + + outputReady = MagickFalse; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + /* Create and initialize OpenCL buffers. */ + { + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (const void *) NULL) { @@ -933,7 +933,7 @@ static Image *ComputeBlurImage(const Image* image,const ChannelType channel, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -1138,15 +1138,15 @@ static Image *ComputeBlurImage(const Image* image,const ChannelType channel, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) - filteredImage_view=DestroyCacheView(filteredImage_view); - + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) + filteredImage_view=DestroyCacheView(filteredImage_view); + if (imageBuffer!=NULL) clEnv->library->clReleaseMemObject(imageBuffer); if (tempImageBuffer!=NULL) clEnv->library->clReleaseMemObject(tempImageBuffer); if (filteredImageBuffer!=NULL) clEnv->library->clReleaseMemObject(filteredImageBuffer); @@ -1156,95 +1156,95 @@ cleanup: if (queue != NULL) RelinquishOpenCLCommandQueue(clEnv, queue); if (kernel!=NULL) DestroyKernelInfo(kernel); if (outputReady == MagickFalse && filteredImage != NULL) - filteredImage=DestroyImage(filteredImage); + filteredImage=DestroyImage(filteredImage); return(filteredImage); } -static Image* ComputeBlurImageSection(const Image* image, - const ChannelType channel,const double radius,const double sigma, - ExceptionInfo *exception) -{ - CacheView - *filteredImage_view, - *image_view; - - char - geometry[MaxTextExtent]; - - cl_command_queue - queue; - - cl_int - clStatus; - - cl_kernel - blurColumnKernel, - blurRowKernel; - - cl_mem - imageBuffer, - tempImageBuffer, - filteredImageBuffer, - imageKernelBuffer; - - cl_mem_flags - mem_flags; - - cl_context - context; - - const void - *inputPixels; - - float - *kernelBufferPtr; - - Image - *filteredImage; - - KernelInfo - *kernel; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - unsigned int - i, - imageColumns, - imageRows, - kernelWidth; - - void - *filteredPixels, - *hostPtr; - - context = NULL; - filteredImage = NULL; - filteredImage_view = NULL; - imageBuffer = NULL; - tempImageBuffer = NULL; - filteredImageBuffer = NULL; - imageKernelBuffer = NULL; - blurRowKernel = NULL; - blurColumnKernel = NULL; - queue = NULL; - kernel = NULL; - - outputReady = MagickFalse; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - /* Create and initialize OpenCL buffers. */ - { - image_view=AcquireVirtualCacheView(image,exception); +static Image* ComputeBlurImageSection(const Image* image, + const ChannelType channel,const double radius,const double sigma, + ExceptionInfo *exception) +{ + CacheView + *filteredImage_view, + *image_view; + + char + geometry[MaxTextExtent]; + + cl_command_queue + queue; + + cl_int + clStatus; + + cl_kernel + blurColumnKernel, + blurRowKernel; + + cl_mem + imageBuffer, + tempImageBuffer, + filteredImageBuffer, + imageKernelBuffer; + + cl_mem_flags + mem_flags; + + cl_context + context; + + const void + *inputPixels; + + float + *kernelBufferPtr; + + Image + *filteredImage; + + KernelInfo + *kernel; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + unsigned int + i, + imageColumns, + imageRows, + kernelWidth; + + void + *filteredPixels, + *hostPtr; + + context = NULL; + filteredImage = NULL; + filteredImage_view = NULL; + imageBuffer = NULL; + tempImageBuffer = NULL; + filteredImageBuffer = NULL; + imageKernelBuffer = NULL; + blurRowKernel = NULL; + blurColumnKernel = NULL; + queue = NULL; + kernel = NULL; + + outputReady = MagickFalse; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + /* Create and initialize OpenCL buffers. */ + { + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (const void *) NULL) { @@ -1281,7 +1281,7 @@ static Image* ComputeBlurImageSection(const Image* image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -1507,15 +1507,15 @@ static Image* ComputeBlurImageSection(const Image* image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) - filteredImage_view=DestroyCacheView(filteredImage_view); - + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) + filteredImage_view=DestroyCacheView(filteredImage_view); + if (imageBuffer!=NULL) clEnv->library->clReleaseMemObject(imageBuffer); if (tempImageBuffer!=NULL) clEnv->library->clReleaseMemObject(tempImageBuffer); if (filteredImageBuffer!=NULL) clEnv->library->clReleaseMemObject(filteredImageBuffer); @@ -1535,26 +1535,26 @@ cleanup: return filteredImage; } -MagickExport Image* AccelerateBlurImage(const Image *image, - const ChannelType channel,const double radius,const double sigma, - ExceptionInfo *exception) -{ - Image - *filteredImage; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse)) - return NULL; - - if (splitImage(image) && (image->rows / 2 > radius)) - filteredImage=ComputeBlurImageSection(image, channel, radius, sigma, exception); - else - filteredImage=ComputeBlurImage(image, channel, radius, sigma, exception); - - return(filteredImage); +MagickExport Image* AccelerateBlurImage(const Image *image, + const ChannelType channel,const double radius,const double sigma, + ExceptionInfo *exception) +{ + Image + *filteredImage; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse)) + return NULL; + + if (splitImage(image) && (image->rows / 2 > radius)) + filteredImage=ComputeBlurImageSection(image, channel, radius, sigma, exception); + else + filteredImage=ComputeBlurImage(image, channel, radius, sigma, exception); + + return(filteredImage); } /* @@ -1591,96 +1591,96 @@ MagickExport Image* AccelerateBlurImage(const Image *image, % */ -static Image* ComputeRotationalBlurImage(const Image *image, - const ChannelType channel,const double angle,ExceptionInfo *exception) -{ - CacheView - *image_view, - *filteredImage_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_float2 - blurCenter; - - cl_float4 - biasPixel; - - cl_int - clStatus; - - cl_mem - cosThetaBuffer, - filteredImageBuffer, - imageBuffer, - sinThetaBuffer; - - cl_mem_flags - mem_flags; - - cl_kernel - rotationalBlurKernel; - - const void - *inputPixels; - - float - blurRadius, - *cosThetaPtr, - offset, - *sinThetaPtr, - theta; - - Image - *filteredImage; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - PixelInfo - bias; - - MagickSizeType - length; - - size_t - global_work_size[2]; - - unsigned int - cossin_theta_size, - i, - matte; - - void - *filteredPixels, - *hostPtr; - - outputReady = MagickFalse; - context = NULL; - filteredImage = NULL; - filteredImage_view = NULL; - imageBuffer = NULL; - filteredImageBuffer = NULL; - sinThetaBuffer = NULL; - cosThetaBuffer = NULL; - queue = NULL; - rotationalBlurKernel = NULL; - - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - - - /* Create and initialize OpenCL buffers. */ - - image_view=AcquireVirtualCacheView(image,exception); +static Image* ComputeRotationalBlurImage(const Image *image, + const ChannelType channel,const double angle,ExceptionInfo *exception) +{ + CacheView + *image_view, + *filteredImage_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_float2 + blurCenter; + + cl_float4 + biasPixel; + + cl_int + clStatus; + + cl_mem + cosThetaBuffer, + filteredImageBuffer, + imageBuffer, + sinThetaBuffer; + + cl_mem_flags + mem_flags; + + cl_kernel + rotationalBlurKernel; + + const void + *inputPixels; + + float + blurRadius, + *cosThetaPtr, + offset, + *sinThetaPtr, + theta; + + Image + *filteredImage; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + PixelInfo + bias; + + MagickSizeType + length; + + size_t + global_work_size[2]; + + unsigned int + cossin_theta_size, + i, + matte; + + void + *filteredPixels, + *hostPtr; + + outputReady = MagickFalse; + context = NULL; + filteredImage = NULL; + filteredImage_view = NULL; + imageBuffer = NULL; + filteredImageBuffer = NULL; + sinThetaBuffer = NULL; + cosThetaBuffer = NULL; + queue = NULL; + rotationalBlurKernel = NULL; + + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + + + /* Create and initialize OpenCL buffers. */ + + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (const void *) NULL) { @@ -1716,7 +1716,7 @@ static Image* ComputeRotationalBlurImage(const Image *image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -1857,13 +1857,13 @@ static Image* ComputeRotationalBlurImage(const Image *image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", "."); goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) filteredImage_view=DestroyCacheView(filteredImage_view); if (filteredImageBuffer!=NULL) clEnv->library->clReleaseMemObject(filteredImageBuffer); @@ -1883,21 +1883,21 @@ cleanup: return filteredImage; } -MagickExport Image* AccelerateRotationalBlurImage(const Image *image, - const ChannelType channel,const double angle,ExceptionInfo *exception) -{ - Image - *filteredImage; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse)) - return NULL; - - filteredImage=ComputeRotationalBlurImage(image, channel, angle, exception); - return filteredImage; +MagickExport Image* AccelerateRotationalBlurImage(const Image *image, + const ChannelType channel,const double angle,ExceptionInfo *exception) +{ + Image + *filteredImage; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse)) + return NULL; + + filteredImage=ComputeRotationalBlurImage(image, channel, angle, exception); + return filteredImage; } /* @@ -1945,96 +1945,96 @@ MagickExport Image* AccelerateRotationalBlurImage(const Image *image, % */ -static Image *ComputeUnsharpMaskImage(const Image *image, - const ChannelType channel,const double radius,const double sigma, - const double gain,const double threshold,ExceptionInfo *exception) -{ - CacheView - *filteredImage_view, - *image_view; - - char - geometry[MaxTextExtent]; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_kernel - blurRowKernel, - unsharpMaskBlurColumnKernel; - - cl_mem - filteredImageBuffer, - imageBuffer, - imageKernelBuffer, - tempImageBuffer; - - cl_mem_flags - mem_flags; - - const void - *inputPixels; - - float - fGain, - fThreshold, - *kernelBufferPtr; - - Image - *filteredImage; - - int - chunkSize; - - KernelInfo - *kernel; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - void - *filteredPixels, - *hostPtr; - - unsigned int - i, - imageColumns, - imageRows, - kernelWidth; - - clEnv = NULL; - filteredImage = NULL; - filteredImage_view = NULL; - kernel = NULL; - context = NULL; - imageBuffer = NULL; - filteredImageBuffer = NULL; - tempImageBuffer = NULL; - imageKernelBuffer = NULL; - blurRowKernel = NULL; - unsharpMaskBlurColumnKernel = NULL; - queue = NULL; - outputReady = MagickFalse; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - /* Create and initialize OpenCL buffers. */ - { - image_view=AcquireVirtualCacheView(image,exception); +static Image *ComputeUnsharpMaskImage(const Image *image, + const ChannelType channel,const double radius,const double sigma, + const double gain,const double threshold,ExceptionInfo *exception) +{ + CacheView + *filteredImage_view, + *image_view; + + char + geometry[MaxTextExtent]; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_kernel + blurRowKernel, + unsharpMaskBlurColumnKernel; + + cl_mem + filteredImageBuffer, + imageBuffer, + imageKernelBuffer, + tempImageBuffer; + + cl_mem_flags + mem_flags; + + const void + *inputPixels; + + float + fGain, + fThreshold, + *kernelBufferPtr; + + Image + *filteredImage; + + int + chunkSize; + + KernelInfo + *kernel; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + void + *filteredPixels, + *hostPtr; + + unsigned int + i, + imageColumns, + imageRows, + kernelWidth; + + clEnv = NULL; + filteredImage = NULL; + filteredImage_view = NULL; + kernel = NULL; + context = NULL; + imageBuffer = NULL; + filteredImageBuffer = NULL; + tempImageBuffer = NULL; + imageKernelBuffer = NULL; + blurRowKernel = NULL; + unsharpMaskBlurColumnKernel = NULL; + queue = NULL; + outputReady = MagickFalse; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + /* Create and initialize OpenCL buffers. */ + { + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (const void *) NULL) { @@ -2072,7 +2072,7 @@ static Image *ComputeUnsharpMaskImage(const Image *image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -2278,13 +2278,13 @@ static Image *ComputeUnsharpMaskImage(const Image *image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) filteredImage_view=DestroyCacheView(filteredImage_view); if (kernel != NULL) kernel=DestroyKernelInfo(kernel); @@ -2306,96 +2306,96 @@ cleanup: return(filteredImage); } -static Image *ComputeUnsharpMaskImageSection(const Image *image, - const ChannelType channel,const double radius,const double sigma, - const double gain,const double threshold,ExceptionInfo *exception) -{ - CacheView - *filteredImage_view, - *image_view; - - char - geometry[MaxTextExtent]; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_kernel - blurRowKernel, - unsharpMaskBlurColumnKernel; - - cl_mem - filteredImageBuffer, - imageBuffer, - imageKernelBuffer, - tempImageBuffer; - - cl_mem_flags - mem_flags; - - const void - *inputPixels; - - float - fGain, - fThreshold, - *kernelBufferPtr; - - Image - *filteredImage; - - int - chunkSize; - - KernelInfo - *kernel; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - void - *filteredPixels, - *hostPtr; - - unsigned int - i, - imageColumns, - imageRows, - kernelWidth; - - clEnv = NULL; - filteredImage = NULL; - filteredImage_view = NULL; - kernel = NULL; - context = NULL; - imageBuffer = NULL; - filteredImageBuffer = NULL; - tempImageBuffer = NULL; - imageKernelBuffer = NULL; - blurRowKernel = NULL; - unsharpMaskBlurColumnKernel = NULL; - queue = NULL; - outputReady = MagickFalse; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - /* Create and initialize OpenCL buffers. */ - { - image_view=AcquireVirtualCacheView(image,exception); +static Image *ComputeUnsharpMaskImageSection(const Image *image, + const ChannelType channel,const double radius,const double sigma, + const double gain,const double threshold,ExceptionInfo *exception) +{ + CacheView + *filteredImage_view, + *image_view; + + char + geometry[MaxTextExtent]; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_kernel + blurRowKernel, + unsharpMaskBlurColumnKernel; + + cl_mem + filteredImageBuffer, + imageBuffer, + imageKernelBuffer, + tempImageBuffer; + + cl_mem_flags + mem_flags; + + const void + *inputPixels; + + float + fGain, + fThreshold, + *kernelBufferPtr; + + Image + *filteredImage; + + int + chunkSize; + + KernelInfo + *kernel; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + void + *filteredPixels, + *hostPtr; + + unsigned int + i, + imageColumns, + imageRows, + kernelWidth; + + clEnv = NULL; + filteredImage = NULL; + filteredImage_view = NULL; + kernel = NULL; + context = NULL; + imageBuffer = NULL; + filteredImageBuffer = NULL; + tempImageBuffer = NULL; + imageKernelBuffer = NULL; + blurRowKernel = NULL; + unsharpMaskBlurColumnKernel = NULL; + queue = NULL; + outputReady = MagickFalse; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + /* Create and initialize OpenCL buffers. */ + { + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (const void *) NULL) { @@ -2433,7 +2433,7 @@ static Image *ComputeUnsharpMaskImageSection(const Image *image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -2660,13 +2660,13 @@ static Image *ComputeUnsharpMaskImageSection(const Image *image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) filteredImage_view=DestroyCacheView(filteredImage_view); if (kernel != NULL) kernel=DestroyKernelInfo(kernel); @@ -2686,35 +2686,35 @@ cleanup: } } return filteredImage; -} - -MagickExport Image *AccelerateUnsharpMaskImage(const Image *image, - const ChannelType channel,const double radius,const double sigma, - const double gain,const double threshold,ExceptionInfo *exception) -{ - Image - *filteredImage; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse)) - return NULL; - - if (splitImage(image) && (image->rows / 2 > radius)) - filteredImage = ComputeUnsharpMaskImageSection(image,channel,radius,sigma,gain,threshold,exception); - else - filteredImage = ComputeUnsharpMaskImage(image,channel,radius,sigma,gain,threshold,exception); - return(filteredImage); } -/* -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -% % -% % -% % -% A c c e l e r a t e R e s i z e I m a g e % +MagickExport Image *AccelerateUnsharpMaskImage(const Image *image, + const ChannelType channel,const double radius,const double sigma, + const double gain,const double threshold,ExceptionInfo *exception) +{ + Image + *filteredImage; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse)) + return NULL; + + if (splitImage(image) && (image->rows / 2 > radius)) + filteredImage = ComputeUnsharpMaskImageSection(image,channel,radius,sigma,gain,threshold,exception); + else + filteredImage = ComputeUnsharpMaskImage(image,channel,radius,sigma,gain,threshold,exception); + return(filteredImage); +} + +/* +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% % +% % +% % +% A c c e l e r a t e R e s i z e I m a g e % % % % % % % @@ -2751,56 +2751,56 @@ MagickExport Image *AccelerateUnsharpMaskImage(const Image *image, % */ -static MagickBooleanType resizeHorizontalFilter(cl_mem image, - const unsigned int imageColumns,const unsigned int imageRows, - const unsigned int matte,cl_mem resizedImage, - const unsigned int resizedColumns,const unsigned int resizedRows, - const ResizeFilter *resizeFilter,cl_mem resizeFilterCubicCoefficients, - const float xFactor,MagickCLEnv clEnv,cl_command_queue queue, - ExceptionInfo *exception) -{ - cl_kernel - horizontalKernel; - - cl_int clStatus; - - const unsigned int - workgroupSize = 256; - - float - resizeFilterScale, - resizeFilterSupport, - resizeFilterWindowSupport, - resizeFilterBlur, - scale, - support; - - int - cacheRangeStart, - cacheRangeEnd, - numCachedPixels, - resizeFilterType, - resizeWindowType; - - MagickBooleanType - status = MagickFalse; - - size_t - deviceLocalMemorySize, - gammaAccumulatorLocalMemorySize, - global_work_size[2], - imageCacheLocalMemorySize, - pixelAccumulatorLocalMemorySize, - local_work_size[2], - totalLocalMemorySize, - weightAccumulatorLocalMemorySize; - - unsigned int - chunkSize, - i, - pixelPerWorkgroup; - - horizontalKernel = NULL; +static MagickBooleanType resizeHorizontalFilter(cl_mem image, + const unsigned int imageColumns,const unsigned int imageRows, + const unsigned int matte,cl_mem resizedImage, + const unsigned int resizedColumns,const unsigned int resizedRows, + const ResizeFilter *resizeFilter,cl_mem resizeFilterCubicCoefficients, + const float xFactor,MagickCLEnv clEnv,cl_command_queue queue, + ExceptionInfo *exception) +{ + cl_kernel + horizontalKernel; + + cl_int clStatus; + + const unsigned int + workgroupSize = 256; + + float + resizeFilterScale, + resizeFilterSupport, + resizeFilterWindowSupport, + resizeFilterBlur, + scale, + support; + + int + cacheRangeStart, + cacheRangeEnd, + numCachedPixels, + resizeFilterType, + resizeWindowType; + + MagickBooleanType + status = MagickFalse; + + size_t + deviceLocalMemorySize, + gammaAccumulatorLocalMemorySize, + global_work_size[2], + imageCacheLocalMemorySize, + pixelAccumulatorLocalMemorySize, + local_work_size[2], + totalLocalMemorySize, + weightAccumulatorLocalMemorySize; + + unsigned int + chunkSize, + i, + pixelPerWorkgroup; + + horizontalKernel = NULL; status = MagickFalse; /* @@ -2957,59 +2957,59 @@ cleanup: if (horizontalKernel != NULL) RelinquishOpenCLKernel(clEnv, horizontalKernel); - return(status); -} - -static MagickBooleanType resizeVerticalFilter(cl_mem image, - const unsigned int imageColumns,const unsigned int imageRows, - const unsigned int matte,cl_mem resizedImage, - const unsigned int resizedColumns,const unsigned int resizedRows, - const ResizeFilter *resizeFilter,cl_mem resizeFilterCubicCoefficients, - const float yFactor,MagickCLEnv clEnv,cl_command_queue queue, - ExceptionInfo *exception) -{ - cl_kernel - horizontalKernel; - - cl_int clStatus; - - const unsigned int - workgroupSize = 256; - - float - resizeFilterScale, - resizeFilterSupport, - resizeFilterWindowSupport, - resizeFilterBlur, - scale, - support; - - int - cacheRangeStart, - cacheRangeEnd, - numCachedPixels, - resizeFilterType, - resizeWindowType; - - MagickBooleanType - status = MagickFalse; - - size_t - deviceLocalMemorySize, - gammaAccumulatorLocalMemorySize, - global_work_size[2], - imageCacheLocalMemorySize, - pixelAccumulatorLocalMemorySize, - local_work_size[2], - totalLocalMemorySize, - weightAccumulatorLocalMemorySize; - - unsigned int - chunkSize, - i, - pixelPerWorkgroup; - - horizontalKernel = NULL; + return(status); +} + +static MagickBooleanType resizeVerticalFilter(cl_mem image, + const unsigned int imageColumns,const unsigned int imageRows, + const unsigned int matte,cl_mem resizedImage, + const unsigned int resizedColumns,const unsigned int resizedRows, + const ResizeFilter *resizeFilter,cl_mem resizeFilterCubicCoefficients, + const float yFactor,MagickCLEnv clEnv,cl_command_queue queue, + ExceptionInfo *exception) +{ + cl_kernel + horizontalKernel; + + cl_int clStatus; + + const unsigned int + workgroupSize = 256; + + float + resizeFilterScale, + resizeFilterSupport, + resizeFilterWindowSupport, + resizeFilterBlur, + scale, + support; + + int + cacheRangeStart, + cacheRangeEnd, + numCachedPixels, + resizeFilterType, + resizeWindowType; + + MagickBooleanType + status = MagickFalse; + + size_t + deviceLocalMemorySize, + gammaAccumulatorLocalMemorySize, + global_work_size[2], + imageCacheLocalMemorySize, + pixelAccumulatorLocalMemorySize, + local_work_size[2], + totalLocalMemorySize, + weightAccumulatorLocalMemorySize; + + unsigned int + chunkSize, + i, + pixelPerWorkgroup; + + horizontalKernel = NULL; status = MagickFalse; /* @@ -3165,79 +3165,79 @@ cleanup: return(status); } -static Image *ComputeResizeImage(const Image* image, - const size_t resizedColumns,const size_t resizedRows, - const ResizeFilter *resizeFilter,ExceptionInfo *exception) -{ - CacheView - *filteredImage_view, - *image_view; - - cl_command_queue - queue; - - cl_int - clStatus; - - cl_context - context; - - cl_mem - cubicCoefficientsBuffer, - filteredImageBuffer, - imageBuffer, - tempImageBuffer; - - cl_mem_flags - mem_flags; - - const double - *resizeFilterCoefficient; - - const void - *inputPixels; - - float - *mappedCoefficientBuffer, - xFactor, - yFactor; - - MagickBooleanType - outputReady, - status; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - Image - *filteredImage; - - unsigned int - i; - - void - *filteredPixels, - *hostPtr; - - outputReady = MagickFalse; - filteredImage = NULL; - filteredImage_view = NULL; - clEnv = NULL; - context = NULL; - imageBuffer = NULL; - tempImageBuffer = NULL; - filteredImageBuffer = NULL; - cubicCoefficientsBuffer = NULL; - queue = NULL; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - - /* Create and initialize OpenCL buffers. */ - image_view=AcquireVirtualCacheView(image,exception); +static Image *ComputeResizeImage(const Image* image, + const size_t resizedColumns,const size_t resizedRows, + const ResizeFilter *resizeFilter,ExceptionInfo *exception) +{ + CacheView + *filteredImage_view, + *image_view; + + cl_command_queue + queue; + + cl_int + clStatus; + + cl_context + context; + + cl_mem + cubicCoefficientsBuffer, + filteredImageBuffer, + imageBuffer, + tempImageBuffer; + + cl_mem_flags + mem_flags; + + const double + *resizeFilterCoefficient; + + const void + *inputPixels; + + float + *mappedCoefficientBuffer, + xFactor, + yFactor; + + MagickBooleanType + outputReady, + status; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + Image + *filteredImage; + + unsigned int + i; + + void + *filteredPixels, + *hostPtr; + + outputReady = MagickFalse; + filteredImage = NULL; + filteredImage_view = NULL; + clEnv = NULL; + context = NULL; + imageBuffer = NULL; + tempImageBuffer = NULL; + filteredImageBuffer = NULL; + cubicCoefficientsBuffer = NULL; + queue = NULL; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + + /* Create and initialize OpenCL buffers. */ + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (const void *) NULL) { @@ -3300,7 +3300,7 @@ static Image *ComputeResizeImage(const Image* image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -3393,13 +3393,13 @@ static Image *ComputeResizeImage(const Image* image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", "."); goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) filteredImage_view=DestroyCacheView(filteredImage_view); if (imageBuffer!=NULL) clEnv->library->clReleaseMemObject(imageBuffer); @@ -3412,55 +3412,55 @@ cleanup: return(filteredImage); } -const ResizeWeightingFunctionType supportedResizeWeighting[] = -{ - BoxWeightingFunction, - TriangleWeightingFunction, - HanningWeightingFunction, - HammingWeightingFunction, - BlackmanWeightingFunction, - CubicBCWeightingFunction, - SincWeightingFunction, - SincFastWeightingFunction, - LastWeightingFunction +const ResizeWeightingFunctionType supportedResizeWeighting[] = +{ + BoxWeightingFunction, + TriangleWeightingFunction, + HanningWeightingFunction, + HammingWeightingFunction, + BlackmanWeightingFunction, + CubicBCWeightingFunction, + SincWeightingFunction, + SincFastWeightingFunction, + LastWeightingFunction }; -static MagickBooleanType gpuSupportedResizeWeighting( - ResizeWeightingFunctionType f) -{ - unsigned int - i; - - for (i = 0; ;i++) - { - if (supportedResizeWeighting[i] == LastWeightingFunction) - break; - if (supportedResizeWeighting[i] == f) - return(MagickTrue); - } - return(MagickFalse); -} - -MagickExport Image *AccelerateResizeImage(const Image *image, - const size_t resizedColumns,const size_t resizedRows, - const ResizeFilter *resizeFilter,ExceptionInfo *exception) -{ - Image - *filteredImage; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, AllChannels) == MagickFalse)) - return NULL; - - if (gpuSupportedResizeWeighting(GetResizeFilterWeightingType(resizeFilter)) == MagickFalse || - gpuSupportedResizeWeighting(GetResizeFilterWindowWeightingType(resizeFilter)) == MagickFalse) - return NULL; - - filteredImage=ComputeResizeImage(image,resizedColumns,resizedRows,resizeFilter,exception); - return(filteredImage); +static MagickBooleanType gpuSupportedResizeWeighting( + ResizeWeightingFunctionType f) +{ + unsigned int + i; + + for (i = 0; ;i++) + { + if (supportedResizeWeighting[i] == LastWeightingFunction) + break; + if (supportedResizeWeighting[i] == f) + return(MagickTrue); + } + return(MagickFalse); +} + +MagickExport Image *AccelerateResizeImage(const Image *image, + const size_t resizedColumns,const size_t resizedRows, + const ResizeFilter *resizeFilter,ExceptionInfo *exception) +{ + Image + *filteredImage; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, AllChannels) == MagickFalse)) + return NULL; + + if (gpuSupportedResizeWeighting(GetResizeFilterWeightingType(resizeFilter)) == MagickFalse || + gpuSupportedResizeWeighting(GetResizeFilterWindowWeightingType(resizeFilter)) == MagickFalse) + return NULL; + + filteredImage=ComputeResizeImage(image,resizedColumns,resizedRows,resizeFilter,exception); + return(filteredImage); } /* @@ -3491,62 +3491,62 @@ MagickExport Image *AccelerateResizeImage(const Image *image, % */ -static MagickBooleanType ComputeContrastImage(Image *image, - const MagickBooleanType sharpen,ExceptionInfo *exception) -{ - CacheView - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_kernel - filterKernel; - - cl_mem - imageBuffer; - - cl_mem_flags - mem_flags; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - size_t - global_work_size[2]; - - unsigned int - i, - uSharpen; - - void - *inputPixels; - - outputReady = MagickFalse; - clEnv = NULL; - inputPixels = NULL; - context = NULL; - imageBuffer = NULL; - filterKernel = NULL; - queue = NULL; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - - /* Create and initialize OpenCL buffers. */ - image_view=AcquireAuthenticCacheView(image,exception); +static MagickBooleanType ComputeContrastImage(Image *image, + const MagickBooleanType sharpen,ExceptionInfo *exception) +{ + CacheView + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_kernel + filterKernel; + + cl_mem + imageBuffer; + + cl_mem_flags + mem_flags; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + size_t + global_work_size[2]; + + unsigned int + i, + uSharpen; + + void + *inputPixels; + + outputReady = MagickFalse; + clEnv = NULL; + inputPixels = NULL; + context = NULL; + imageBuffer = NULL; + filterKernel = NULL; + queue = NULL; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + + /* Create and initialize OpenCL buffers. */ + image_view=AcquireAuthenticCacheView(image,exception); inputPixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) { @@ -3619,34 +3619,34 @@ static MagickBooleanType ComputeContrastImage(Image *image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", "."); goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(image_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - + outputReady=SyncCacheViewAuthenticPixels(image_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + image_view=DestroyCacheView(image_view); if (imageBuffer!=NULL) clEnv->library->clReleaseMemObject(imageBuffer); if (filterKernel!=NULL) RelinquishOpenCLKernel(clEnv, filterKernel); if (queue != NULL) RelinquishOpenCLCommandQueue(clEnv, queue); return(outputReady); -} - -MagickExport MagickBooleanType AccelerateContrastImage(Image *image, - const MagickBooleanType sharpen,ExceptionInfo *exception) -{ - MagickBooleanType - status; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, AllChannels) == MagickFalse)) - return(MagickFalse); - - status = ComputeContrastImage(image,sharpen,exception); - return(status); +} + +MagickExport MagickBooleanType AccelerateContrastImage(Image *image, + const MagickBooleanType sharpen,ExceptionInfo *exception) +{ + MagickBooleanType + status; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, AllChannels) == MagickFalse)) + return(MagickFalse); + + status = ComputeContrastImage(image,sharpen,exception); + return(status); } /* @@ -3679,75 +3679,75 @@ MagickExport MagickBooleanType AccelerateContrastImage(Image *image, % */ -MagickBooleanType ComputeModulateImage(Image *image, - double percent_brightness,double percent_hue,double percent_saturation, - ColorspaceType colorspace,ExceptionInfo *exception) -{ - CacheView - *image_view; - - cl_float - bright, - hue, - saturation; - - cl_context - context; - - cl_command_queue - queue; - - cl_int - color, - clStatus; - - cl_kernel - modulateKernel; - - cl_mem - imageBuffer; - - cl_mem_flags - mem_flags; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - register ssize_t - i; - - void - *inputPixels; - - inputPixels = NULL; - imageBuffer = NULL; - modulateKernel = NULL; - - assert(image != (Image *) NULL); - assert(image->signature == MagickSignature); - if (image->debug != MagickFalse) - (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); - - /* - * initialize opencl env - */ - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - outputReady = MagickFalse; - - /* Create and initialize OpenCL buffers. - inputPixels = AcquirePixelCachePixels(image, &length, exception); - assume this will get a writable image - */ - image_view=AcquireAuthenticCacheView(image,exception); +MagickBooleanType ComputeModulateImage(Image *image, + double percent_brightness,double percent_hue,double percent_saturation, + ColorspaceType colorspace,ExceptionInfo *exception) +{ + CacheView + *image_view; + + cl_float + bright, + hue, + saturation; + + cl_context + context; + + cl_command_queue + queue; + + cl_int + color, + clStatus; + + cl_kernel + modulateKernel; + + cl_mem + imageBuffer; + + cl_mem_flags + mem_flags; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + register ssize_t + i; + + void + *inputPixels; + + inputPixels = NULL; + imageBuffer = NULL; + modulateKernel = NULL; + + assert(image != (Image *) NULL); + assert(image->signature == MagickSignature); + if (image->debug != MagickFalse) + (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); + + /* + * initialize opencl env + */ + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + outputReady = MagickFalse; + + /* Create and initialize OpenCL buffers. + inputPixels = AcquirePixelCachePixels(image, &length, exception); + assume this will get a writable image + */ + image_view=AcquireAuthenticCacheView(image,exception); inputPixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) { @@ -3831,11 +3831,11 @@ MagickBooleanType ComputeModulateImage(Image *image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(image_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - + outputReady=SyncCacheViewAuthenticPixels(image_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + image_view=DestroyCacheView(image_view); if (imageBuffer!=NULL) @@ -3849,25 +3849,25 @@ cleanup: } -MagickExport MagickBooleanType AccelerateModulateImage(Image *image, - double percent_brightness,double percent_hue,double percent_saturation, - ColorspaceType colorspace,ExceptionInfo *exception) -{ - MagickBooleanType - status; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, AllChannels) == MagickFalse)) - return(MagickFalse); - - if ((colorspace != HSLColorspace && colorspace != UndefinedColorspace)) - return(MagickFalse); - - status = ComputeModulateImage(image,percent_brightness, percent_hue, percent_saturation, colorspace, exception); - return(status); +MagickExport MagickBooleanType AccelerateModulateImage(Image *image, + double percent_brightness,double percent_hue,double percent_saturation, + ColorspaceType colorspace,ExceptionInfo *exception) +{ + MagickBooleanType + status; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, AllChannels) == MagickFalse)) + return(MagickFalse); + + if ((colorspace != HSLColorspace && colorspace != UndefinedColorspace)) + return(MagickFalse); + + status = ComputeModulateImage(image,percent_brightness, percent_hue, percent_saturation, colorspace, exception); + return(status); } /* @@ -3892,71 +3892,71 @@ MagickExport MagickBooleanType AccelerateModulateImage(Image *image, % */ -MagickBooleanType ComputeNegateImageChannel(Image *image, - const ChannelType channel,const MagickBooleanType magick_unused(grayscale), - ExceptionInfo* exception) -{ - CacheView - *image_view; - - cl_context - context; - - cl_command_queue - queue; - - cl_int - clStatus; - - cl_kernel - negateKernel; - - cl_mem - imageBuffer; - - cl_mem_flags - mem_flags; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - register ssize_t - i; - - void - *inputPixels; - - magick_unreferenced(grayscale); - - inputPixels = NULL; - imageBuffer = NULL; - negateKernel = NULL; - - assert(image != (Image *) NULL); - assert(image->signature == MagickSignature); - if (image->debug != MagickFalse) - (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); - - /* - * initialize opencl env - */ - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - outputReady = MagickFalse; - - /* Create and initialize OpenCL buffers. - inputPixels = AcquirePixelCachePixels(image, &length, exception); - assume this will get a writable image - */ - image_view=AcquireAuthenticCacheView(image,exception); +MagickBooleanType ComputeNegateImageChannel(Image *image, + const ChannelType channel,const MagickBooleanType magick_unused(grayscale), + ExceptionInfo* exception) +{ + CacheView + *image_view; + + cl_context + context; + + cl_command_queue + queue; + + cl_int + clStatus; + + cl_kernel + negateKernel; + + cl_mem + imageBuffer; + + cl_mem_flags + mem_flags; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + register ssize_t + i; + + void + *inputPixels; + + magick_unreferenced(grayscale); + + inputPixels = NULL; + imageBuffer = NULL; + negateKernel = NULL; + + assert(image != (Image *) NULL); + assert(image->signature == MagickSignature); + if (image->debug != MagickFalse) + (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); + + /* + * initialize opencl env + */ + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + outputReady = MagickFalse; + + /* Create and initialize OpenCL buffers. + inputPixels = AcquirePixelCachePixels(image, &length, exception); + assume this will get a writable image + */ + image_view=AcquireAuthenticCacheView(image,exception); inputPixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) { @@ -4032,11 +4032,11 @@ MagickBooleanType ComputeNegateImageChannel(Image *image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(image_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - + outputReady=SyncCacheViewAuthenticPixels(image_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + image_view=DestroyCacheView(image_view); if (imageBuffer!=NULL) @@ -4047,24 +4047,24 @@ cleanup: RelinquishOpenCLCommandQueue(clEnv, queue); return(outputReady); -} - -MagickExport MagickBooleanType AccelerateNegateImageChannel(Image *image, - const ChannelType channel,const MagickBooleanType grayscale, - ExceptionInfo* exception) -{ - MagickBooleanType - status; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse)) - return(MagickFalse); - - status=ComputeNegateImageChannel(image,channel,grayscale,exception); - return(status); +} + +MagickExport MagickBooleanType AccelerateNegateImageChannel(Image *image, + const ChannelType channel,const MagickBooleanType grayscale, + ExceptionInfo* exception) +{ + MagickBooleanType + status; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse)) + return(MagickFalse); + + status=ComputeNegateImageChannel(image,channel,grayscale,exception); + return(status); } /* @@ -4093,72 +4093,72 @@ MagickExport MagickBooleanType AccelerateNegateImageChannel(Image *image, % */ -MagickBooleanType ComputeGrayscaleImage(Image *image, - const PixelIntensityMethod method,ExceptionInfo *exception) -{ - CacheView - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus, - intensityMethod; - - cl_int - colorspace; - - cl_kernel - grayscaleKernel; - - cl_mem - imageBuffer; - - cl_mem_flags - mem_flags; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - register ssize_t - i; - - void - *inputPixels; - - inputPixels = NULL; - imageBuffer = NULL; - grayscaleKernel = NULL; - - assert(image != (Image *) NULL); - assert(image->signature == MagickSignature); - if (image->debug != MagickFalse) - (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); - - /* - * initialize opencl env - */ - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - outputReady = MagickFalse; - - /* Create and initialize OpenCL buffers. - inputPixels = AcquirePixelCachePixels(image, &length, exception); - assume this will get a writable image - */ - image_view=AcquireAuthenticCacheView(image,exception); +MagickBooleanType ComputeGrayscaleImage(Image *image, + const PixelIntensityMethod method,ExceptionInfo *exception) +{ + CacheView + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus, + intensityMethod; + + cl_int + colorspace; + + cl_kernel + grayscaleKernel; + + cl_mem + imageBuffer; + + cl_mem_flags + mem_flags; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + register ssize_t + i; + + void + *inputPixels; + + inputPixels = NULL; + imageBuffer = NULL; + grayscaleKernel = NULL; + + assert(image != (Image *) NULL); + assert(image->signature == MagickSignature); + if (image->debug != MagickFalse) + (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); + + /* + * initialize opencl env + */ + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + outputReady = MagickFalse; + + /* Create and initialize OpenCL buffers. + inputPixels = AcquirePixelCachePixels(image, &length, exception); + assume this will get a writable image + */ + image_view=AcquireAuthenticCacheView(image,exception); inputPixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) { @@ -4238,11 +4238,11 @@ MagickBooleanType ComputeGrayscaleImage(Image *image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(image_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - + outputReady=SyncCacheViewAuthenticPixels(image_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + image_view=DestroyCacheView(image_view); if (imageBuffer!=NULL) @@ -4253,29 +4253,29 @@ cleanup: RelinquishOpenCLCommandQueue(clEnv, queue); return( outputReady); -} - -MagickExport MagickBooleanType AccelerateGrayscaleImage(Image* image, - const PixelIntensityMethod method,ExceptionInfo *exception) -{ - MagickBooleanType - status; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, AllChannels) == MagickFalse)) - return(MagickFalse); - - if (method == Rec601LuminancePixelIntensityMethod || method == Rec709LuminancePixelIntensityMethod) - return(MagickFalse); - - if (image->colorspace != sRGBColorspace) - return(MagickFalse); - - status=ComputeGrayscaleImage(image,method,exception); - return(status); +} + +MagickExport MagickBooleanType AccelerateGrayscaleImage(Image* image, + const PixelIntensityMethod method,ExceptionInfo *exception) +{ + MagickBooleanType + status; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, AllChannels) == MagickFalse)) + return(MagickFalse); + + if (method == Rec601LuminancePixelIntensityMethod || method == Rec709LuminancePixelIntensityMethod) + return(MagickFalse); + + if (image->colorspace != sRGBColorspace) + return(MagickFalse); + + status=ComputeGrayscaleImage(image,method,exception); + return(status); } /* @@ -4305,27 +4305,27 @@ MagickExport MagickBooleanType AccelerateGrayscaleImage(Image* image, % */ -static MagickBooleanType LaunchHistogramKernel(MagickCLEnv clEnv, - cl_command_queue queue,cl_mem imageBuffer,cl_mem histogramBuffer, - Image *image,const ChannelType channel,ExceptionInfo *exception) -{ - MagickBooleanType - outputReady; - - cl_int - clStatus, - colorspace, - method; - - cl_kernel - histogramKernel; - - register ssize_t - i; - - size_t - global_work_size[2]; - +static MagickBooleanType LaunchHistogramKernel(MagickCLEnv clEnv, + cl_command_queue queue,cl_mem imageBuffer,cl_mem histogramBuffer, + Image *image,const ChannelType channel,ExceptionInfo *exception) +{ + MagickBooleanType + outputReady; + + cl_int + clStatus, + colorspace, + method; + + cl_kernel + histogramKernel; + + register ssize_t + i; + + size_t + global_work_size[2]; + histogramKernel = NULL; outputReady = MagickFalse; @@ -4377,106 +4377,106 @@ cleanup: return(outputReady); } -MagickExport MagickBooleanType ComputeEqualizeImage(Image *image, - const ChannelType channel,ExceptionInfo *exception) -{ -#define EqualizeImageTag "Equalize/Image" - - CacheView - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_mem_flags - mem_flags; - - cl_mem - equalizeMapBuffer, - histogramBuffer, - imageBuffer; - - cl_kernel - equalizeKernel, - histogramKernel; - - cl_uint4 - *histogram; - - FloatPixelPacket - white, - black, - intensity, - *map; - - MagickBooleanType - outputReady, - status; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - PixelPacket - *equalize_map; - - register ssize_t - i; - - size_t - global_work_size[2]; - - void - *hostPtr, - *inputPixels; - - map=NULL; - histogram=NULL; - equalize_map=NULL; - inputPixels = NULL; - imageBuffer = NULL; - histogramBuffer = NULL; - equalizeMapBuffer = NULL; - histogramKernel = NULL; - equalizeKernel = NULL; - context = NULL; - queue = NULL; - outputReady = MagickFalse; - - assert(image != (Image *) NULL); - assert(image->signature == MagickSignature); - if (image->debug != MagickFalse) - (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); - - /* - * initialize opencl env - */ - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - /* - Allocate and initialize histogram arrays. - */ - histogram=(cl_uint4 *) AcquireQuantumMemory(MaxMap+1UL, sizeof(*histogram)); - if (histogram == (cl_uint4 *) NULL) - ThrowBinaryException(ResourceLimitWarning,"MemoryAllocationFailed", image->filename); - - /* reset histogram */ - (void) ResetMagickMemory(histogram,0,(MaxMap+1)*sizeof(*histogram)); - - /* Create and initialize OpenCL buffers. */ - /* inputPixels = AcquirePixelCachePixels(image, &length, exception); */ - /* assume this will get a writable image */ - image_view=AcquireAuthenticCacheView(image,exception); +MagickExport MagickBooleanType ComputeEqualizeImage(Image *image, + const ChannelType channel,ExceptionInfo *exception) +{ +#define EqualizeImageTag "Equalize/Image" + + CacheView + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_mem_flags + mem_flags; + + cl_mem + equalizeMapBuffer, + histogramBuffer, + imageBuffer; + + cl_kernel + equalizeKernel, + histogramKernel; + + cl_uint4 + *histogram; + + FloatPixelPacket + white, + black, + intensity, + *map; + + MagickBooleanType + outputReady, + status; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + PixelPacket + *equalize_map; + + register ssize_t + i; + + size_t + global_work_size[2]; + + void + *hostPtr, + *inputPixels; + + map=NULL; + histogram=NULL; + equalize_map=NULL; + inputPixels = NULL; + imageBuffer = NULL; + histogramBuffer = NULL; + equalizeMapBuffer = NULL; + histogramKernel = NULL; + equalizeKernel = NULL; + context = NULL; + queue = NULL; + outputReady = MagickFalse; + + assert(image != (Image *) NULL); + assert(image->signature == MagickSignature); + if (image->debug != MagickFalse) + (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); + + /* + * initialize opencl env + */ + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + /* + Allocate and initialize histogram arrays. + */ + histogram=(cl_uint4 *) AcquireQuantumMemory(MaxMap+1UL, sizeof(*histogram)); + if (histogram == (cl_uint4 *) NULL) + ThrowBinaryException(ResourceLimitWarning,"MemoryAllocationFailed", image->filename); + + /* reset histogram */ + (void) ResetMagickMemory(histogram,0,(MaxMap+1)*sizeof(*histogram)); + + /* Create and initialize OpenCL buffers. */ + /* inputPixels = AcquirePixelCachePixels(image, &length, exception); */ + /* assume this will get a writable image */ + image_view=AcquireAuthenticCacheView(image,exception); inputPixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) @@ -4775,11 +4775,11 @@ MagickExport MagickBooleanType ComputeEqualizeImage(Image *image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(image_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - + outputReady=SyncCacheViewAuthenticPixels(image_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + image_view=DestroyCacheView(image_view); if (imageBuffer!=NULL) @@ -4807,24 +4807,24 @@ cleanup: RelinquishOpenCLCommandQueue(clEnv, queue); return(outputReady); -} - -MagickExport MagickBooleanType AccelerateEqualizeImage(Image *image, - const ChannelType channel,ExceptionInfo *exception) -{ - MagickBooleanType - status; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse) || - (checkHistogramCondition(image, channel) == MagickFalse)) - return(MagickFalse); - - status=ComputeEqualizeImage(image,channel,exception); - return(status); +} + +MagickExport MagickBooleanType AccelerateEqualizeImage(Image *image, + const ChannelType channel,ExceptionInfo *exception) +{ + MagickBooleanType + status; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse) || + (checkHistogramCondition(image, channel) == MagickFalse)) + return(MagickFalse); + + status=ComputeEqualizeImage(image,channel,exception); + return(status); } /* @@ -4868,123 +4868,123 @@ MagickExport MagickBooleanType AccelerateEqualizeImage(Image *image, % */ -MagickExport MagickBooleanType ComputeContrastStretchImageChannel(Image *image, - const ChannelType channel,const double black_point,const double white_point, - ExceptionInfo *exception) -{ -#define ContrastStretchImageTag "ContrastStretch/Image" -#define MaxRange(color) ((MagickRealType) ScaleQuantumToMap((Quantum) (color))) - - CacheView - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_mem_flags - mem_flags; - - cl_mem - histogramBuffer, - imageBuffer, - stretchMapBuffer; - - cl_kernel - histogramKernel, - stretchKernel; - - cl_uint4 - *histogram; - - double - intensity; - - FloatPixelPacket - black, - white; - - MagickBooleanType - outputReady, - status; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - PixelPacket - *stretch_map; - - register ssize_t - i; - - size_t - global_work_size[2]; - - void - *hostPtr, - *inputPixels; - - histogram=NULL; - stretch_map=NULL; - inputPixels = NULL; - imageBuffer = NULL; - histogramBuffer = NULL; - stretchMapBuffer = NULL; - histogramKernel = NULL; - stretchKernel = NULL; - context = NULL; - queue = NULL; - outputReady = MagickFalse; - - - assert(image != (Image *) NULL); - assert(image->signature == MagickSignature); - if (image->debug != MagickFalse) - (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); - - //exception=(&image->exception); - - /* - * initialize opencl env - */ - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - /* - Allocate and initialize histogram arrays. - */ - histogram=(cl_uint4 *) AcquireQuantumMemory(MaxMap+1UL, sizeof(*histogram)); - - if (histogram == (cl_uint4 *) NULL) - ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed", image->filename); - - /* reset histogram */ - (void) ResetMagickMemory(histogram,0,(MaxMap+1)*sizeof(*histogram)); - - /* - if (IsGrayImage(image,exception) != MagickFalse) - (void) SetImageColorspace(image,GRAYColorspace); - */ - - status=MagickTrue; - - - /* - Form histogram. - */ - /* Create and initialize OpenCL buffers. */ - /* inputPixels = AcquirePixelCachePixels(image, &length, exception); */ - /* assume this will get a writable image */ - image_view=AcquireAuthenticCacheView(image,exception); +MagickExport MagickBooleanType ComputeContrastStretchImageChannel(Image *image, + const ChannelType channel,const double black_point,const double white_point, + ExceptionInfo *exception) +{ +#define ContrastStretchImageTag "ContrastStretch/Image" +#define MaxRange(color) ((MagickRealType) ScaleQuantumToMap((Quantum) (color))) + + CacheView + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_mem_flags + mem_flags; + + cl_mem + histogramBuffer, + imageBuffer, + stretchMapBuffer; + + cl_kernel + histogramKernel, + stretchKernel; + + cl_uint4 + *histogram; + + double + intensity; + + FloatPixelPacket + black, + white; + + MagickBooleanType + outputReady, + status; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + PixelPacket + *stretch_map; + + register ssize_t + i; + + size_t + global_work_size[2]; + + void + *hostPtr, + *inputPixels; + + histogram=NULL; + stretch_map=NULL; + inputPixels = NULL; + imageBuffer = NULL; + histogramBuffer = NULL; + stretchMapBuffer = NULL; + histogramKernel = NULL; + stretchKernel = NULL; + context = NULL; + queue = NULL; + outputReady = MagickFalse; + + + assert(image != (Image *) NULL); + assert(image->signature == MagickSignature); + if (image->debug != MagickFalse) + (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); + + //exception=(&image->exception); + + /* + * initialize opencl env + */ + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + /* + Allocate and initialize histogram arrays. + */ + histogram=(cl_uint4 *) AcquireQuantumMemory(MaxMap+1UL, sizeof(*histogram)); + + if (histogram == (cl_uint4 *) NULL) + ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed", image->filename); + + /* reset histogram */ + (void) ResetMagickMemory(histogram,0,(MaxMap+1)*sizeof(*histogram)); + + /* + if (IsGrayImage(image,exception) != MagickFalse) + (void) SetImageColorspace(image,GRAYColorspace); + */ + + status=MagickTrue; + + + /* + Form histogram. + */ + /* Create and initialize OpenCL buffers. */ + /* inputPixels = AcquirePixelCachePixels(image, &length, exception); */ + /* assume this will get a writable image */ + image_view=AcquireAuthenticCacheView(image,exception); inputPixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) @@ -5406,11 +5406,11 @@ MagickExport MagickBooleanType ComputeContrastStretchImageChannel(Image *image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(image_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - + outputReady=SyncCacheViewAuthenticPixels(image_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + image_view=DestroyCacheView(image_view); if (imageBuffer!=NULL) @@ -5436,26 +5436,26 @@ cleanup: if (queue != NULL) RelinquishOpenCLCommandQueue(clEnv, queue); - return(outputReady); -} - -MagickExport MagickBooleanType AccelerateContrastStretchImageChannel( - Image *image,const ChannelType channel,const double black_point, - const double white_point,ExceptionInfo *exception) -{ - MagickBooleanType - status; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse) || - (checkHistogramCondition(image, channel) == MagickFalse)) - return(MagickFalse); - - status=ComputeContrastStretchImageChannel(image,channel, black_point, white_point, exception); - return(status); + return(outputReady); +} + +MagickExport MagickBooleanType AccelerateContrastStretchImageChannel( + Image *image,const ChannelType channel,const double black_point, + const double white_point,ExceptionInfo *exception) +{ + MagickBooleanType + status; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse) || + (checkHistogramCondition(image, channel) == MagickFalse)) + return(MagickFalse); + + status=ComputeContrastStretchImageChannel(image,channel, black_point, white_point, exception); + return(status); } /* @@ -5488,86 +5488,86 @@ MagickExport MagickBooleanType AccelerateContrastStretchImageChannel( % */ -static Image *ComputeDespeckleImage(const Image *image, - ExceptionInfo*exception) -{ - static const int - X[4] = {0, 1, 1,-1}, - Y[4] = {1, 0, 1, 1}; - - CacheView - *filteredImage_view, - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_kernel - hullPass1, - hullPass2; - - cl_mem_flags - mem_flags; - - cl_mem - filteredImageBuffer, - imageBuffer, - tempImageBuffer[2]; - - const void - *inputPixels; - - Image - *filteredImage; - - int - k, - matte; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - size_t - global_work_size[2]; - - unsigned int - imageHeight, - imageWidth; - - void - *filteredPixels, - *hostPtr; - - outputReady = MagickFalse; - clEnv = NULL; - inputPixels = NULL; - filteredImage = NULL; - filteredImage_view = NULL; - filteredPixels = NULL; - context = NULL; - imageBuffer = NULL; - filteredImageBuffer = NULL; - hullPass1 = NULL; - hullPass2 = NULL; - queue = NULL; - tempImageBuffer[0] = tempImageBuffer[1] = NULL; - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - image_view=AcquireVirtualCacheView(image,exception); +static Image *ComputeDespeckleImage(const Image *image, + ExceptionInfo*exception) +{ + static const int + X[4] = {0, 1, 1,-1}, + Y[4] = {1, 0, 1, 1}; + + CacheView + *filteredImage_view, + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_kernel + hullPass1, + hullPass2; + + cl_mem_flags + mem_flags; + + cl_mem + filteredImageBuffer, + imageBuffer, + tempImageBuffer[2]; + + const void + *inputPixels; + + Image + *filteredImage; + + int + k, + matte; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + size_t + global_work_size[2]; + + unsigned int + imageHeight, + imageWidth; + + void + *filteredPixels, + *hostPtr; + + outputReady = MagickFalse; + clEnv = NULL; + inputPixels = NULL; + filteredImage = NULL; + filteredImage_view = NULL; + filteredPixels = NULL; + context = NULL; + imageBuffer = NULL; + filteredImageBuffer = NULL; + hullPass1 = NULL; + hullPass2 = NULL; + queue = NULL; + tempImageBuffer[0] = tempImageBuffer[1] = NULL; + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) { @@ -5611,7 +5611,7 @@ static Image *ComputeDespeckleImage(const Image *image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -5812,13 +5812,13 @@ static Image *ComputeDespeckleImage(const Image *image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) filteredImage_view=DestroyCacheView(filteredImage_view); if (queue != NULL) RelinquishOpenCLCommandQueue(clEnv, queue); @@ -5835,119 +5835,119 @@ cleanup: return(filteredImage); } -MagickExport Image *AccelerateDespeckleImage(const Image* image, - ExceptionInfo* exception) -{ - Image - *filteredImage; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, AllChannels) == MagickFalse)) - return NULL; - - filteredImage=ComputeDespeckleImage(image,exception); - return(filteredImage); +MagickExport Image *AccelerateDespeckleImage(const Image* image, + ExceptionInfo* exception) +{ + Image + *filteredImage; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, AllChannels) == MagickFalse)) + return NULL; + + filteredImage=ComputeDespeckleImage(image,exception); + return(filteredImage); } -static Image *ComputeAddNoiseImage(const Image *image, - const ChannelType channel,const NoiseType noise_type, - ExceptionInfo *exception) -{ - CacheView - *filteredImage_view, - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_kernel - addNoiseKernel; - - cl_mem_flags - mem_flags; - - cl_mem - filteredImageBuffer, - imageBuffer, - randomNumberBuffer; - - const char - *option; - - const void - *inputPixels; - - float - attenuate, - *randomNumberBufferPtr; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - Image - *filteredImage; - - int - i; - - RandomInfo - **restrict random_info; - - size_t - global_work_size[2]; - - unsigned int - inputColumns, - inputRows, - k, - numRandomNumberPerBuffer, - numRandomNumberPerPixel, - numRowsPerKernelLaunch, - r; - -#if defined(MAGICKCORE_OPENMP_SUPPORT) - unsigned long - key; -#endif - - void - *filteredPixels, - *hostPtr; - - outputReady = MagickFalse; - clEnv = NULL; - inputPixels = NULL; - filteredImage = NULL; - filteredImage_view = NULL; - filteredPixels = NULL; - randomNumberBufferPtr = NULL; - context = NULL; - imageBuffer = NULL; - randomNumberBuffer = NULL; - filteredImageBuffer = NULL; - queue = NULL; - addNoiseKernel = NULL; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - image_view=AcquireVirtualCacheView(image,exception); +static Image *ComputeAddNoiseImage(const Image *image, + const ChannelType channel,const NoiseType noise_type, + ExceptionInfo *exception) +{ + CacheView + *filteredImage_view, + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_kernel + addNoiseKernel; + + cl_mem_flags + mem_flags; + + cl_mem + filteredImageBuffer, + imageBuffer, + randomNumberBuffer; + + const char + *option; + + const void + *inputPixels; + + float + attenuate, + *randomNumberBufferPtr; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + Image + *filteredImage; + + int + i; + + RandomInfo + **restrict random_info; + + size_t + global_work_size[2]; + + unsigned int + inputColumns, + inputRows, + k, + numRandomNumberPerBuffer, + numRandomNumberPerPixel, + numRowsPerKernelLaunch, + r; + +#if defined(MAGICKCORE_OPENMP_SUPPORT) + unsigned long + key; +#endif + + void + *filteredPixels, + *hostPtr; + + outputReady = MagickFalse; + clEnv = NULL; + inputPixels = NULL; + filteredImage = NULL; + filteredImage_view = NULL; + filteredPixels = NULL; + randomNumberBufferPtr = NULL; + context = NULL; + imageBuffer = NULL; + randomNumberBuffer = NULL; + filteredImageBuffer = NULL; + queue = NULL; + addNoiseKernel = NULL; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) { @@ -5980,7 +5980,7 @@ static Image *ComputeAddNoiseImage(const Image *image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -6124,13 +6124,13 @@ static Image *ComputeAddNoiseImage(const Image *image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) filteredImage_view=DestroyCacheView(filteredImage_view); if (queue!=NULL) RelinquishOpenCLCommandQueue(clEnv, queue); @@ -6138,106 +6138,106 @@ cleanup: if (imageBuffer!=NULL) clEnv->library->clReleaseMemObject(imageBuffer); if (randomNumberBuffer!=NULL) clEnv->library->clReleaseMemObject(randomNumberBuffer); if (filteredImageBuffer!=NULL) clEnv->library->clReleaseMemObject(filteredImageBuffer); - if (outputReady == MagickFalse && filteredImage != NULL) - filteredImage=DestroyImage(filteredImage); - + if (outputReady == MagickFalse && filteredImage != NULL) + filteredImage=DestroyImage(filteredImage); + return(filteredImage); } -static Image *ComputeAddNoiseImageOptRandomNum(const Image*image, - const ChannelType channel,const NoiseType noise_type, - ExceptionInfo *exception) -{ - CacheView - *filteredImage_view, - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_kernel - addNoiseKernel, - randomNumberGeneratorKernel; - - cl_mem - filteredImageBuffer, - imageBuffer, - randomNumberBuffer, - randomNumberSeedsBuffer; - - cl_mem_flags - mem_flags; - - const char - *option; - - const void - *inputPixels; - - float - attenuate, - fNormalize; - - Image - *filteredImage; - - int - i; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - size_t - global_work_size[2], - random_work_size; - - unsigned int - initRandom, - inputColumns, - inputRows, - k, - numRandomNumberGenerators, - numRandomNumberPerBuffer, - numRandomNumberPerPixel, - numRowsPerKernelLaunch, - r; - - void - *filteredPixels, - *hostPtr; - - outputReady = MagickFalse; - clEnv = NULL; - inputPixels = NULL; - filteredImage = NULL; - filteredImage_view = NULL; - filteredPixels = NULL; - context = NULL; - imageBuffer = NULL; - randomNumberBuffer = NULL; - filteredImageBuffer = NULL; - randomNumberSeedsBuffer = NULL; - queue = NULL; - addNoiseKernel = NULL; - randomNumberGeneratorKernel = NULL; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - image_view=AcquireVirtualCacheView(image,exception); +static Image *ComputeAddNoiseImageOptRandomNum(const Image*image, + const ChannelType channel,const NoiseType noise_type, + ExceptionInfo *exception) +{ + CacheView + *filteredImage_view, + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_kernel + addNoiseKernel, + randomNumberGeneratorKernel; + + cl_mem + filteredImageBuffer, + imageBuffer, + randomNumberBuffer, + randomNumberSeedsBuffer; + + cl_mem_flags + mem_flags; + + const char + *option; + + const void + *inputPixels; + + float + attenuate, + fNormalize; + + Image + *filteredImage; + + int + i; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + size_t + global_work_size[2], + random_work_size; + + unsigned int + initRandom, + inputColumns, + inputRows, + k, + numRandomNumberGenerators, + numRandomNumberPerBuffer, + numRandomNumberPerPixel, + numRowsPerKernelLaunch, + r; + + void + *filteredPixels, + *hostPtr; + + outputReady = MagickFalse; + clEnv = NULL; + inputPixels = NULL; + filteredImage = NULL; + filteredImage_view = NULL; + filteredPixels = NULL; + context = NULL; + imageBuffer = NULL; + randomNumberBuffer = NULL; + filteredImageBuffer = NULL; + randomNumberSeedsBuffer = NULL; + queue = NULL; + addNoiseKernel = NULL; + randomNumberGeneratorKernel = NULL; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) { @@ -6270,7 +6270,7 @@ static Image *ComputeAddNoiseImageOptRandomNum(const Image*image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -6439,13 +6439,13 @@ static Image *ComputeAddNoiseImageOptRandomNum(const Image*image, goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) filteredImage_view=DestroyCacheView(filteredImage_view); if (queue!=NULL) RelinquishOpenCLCommandQueue(clEnv, queue); @@ -6455,57 +6455,57 @@ cleanup: if (randomNumberBuffer!=NULL) clEnv->library->clReleaseMemObject(randomNumberBuffer); if (filteredImageBuffer!=NULL) clEnv->library->clReleaseMemObject(filteredImageBuffer); if (randomNumberSeedsBuffer!=NULL) clEnv->library->clReleaseMemObject(randomNumberSeedsBuffer); - if (outputReady == MagickFalse && filteredImage != NULL) - filteredImage=DestroyImage(filteredImage); - + if (outputReady == MagickFalse && filteredImage != NULL) + filteredImage=DestroyImage(filteredImage); + return(filteredImage); } -MagickExport Image *AccelerateAddNoiseImage(const Image *image, - const ChannelType channel,const NoiseType noise_type, - ExceptionInfo *exception) -{ - Image - *filteredImage; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse)) - return NULL; - -DisableMSCWarning(4127) - if (sizeof(unsigned long) == 4) -RestoreMSCWarning - filteredImage = ComputeAddNoiseImageOptRandomNum(image,channel,noise_type,exception); - else - filteredImage = ComputeAddNoiseImage(image,channel,noise_type,exception); - - return(filteredImage); +MagickExport Image *AccelerateAddNoiseImage(const Image *image, + const ChannelType channel,const NoiseType noise_type, + ExceptionInfo *exception) +{ + Image + *filteredImage; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse)) + return NULL; + +DisableMSCWarning(4127) + if (sizeof(unsigned long) == 4) +RestoreMSCWarning + filteredImage = ComputeAddNoiseImageOptRandomNum(image,channel,noise_type,exception); + else + filteredImage = ComputeAddNoiseImage(image,channel,noise_type,exception); + + return(filteredImage); } -static MagickBooleanType LaunchRandomImageKernel(MagickCLEnv clEnv, - cl_command_queue queue,cl_mem imageBuffer,const unsigned int imageColumns, - const unsigned int imageRows,cl_mem seedBuffer, - const unsigned int numGenerators,ExceptionInfo *exception) -{ - int - k; - - cl_int - clStatus; - - cl_kernel - randomImageKernel; - - MagickBooleanType - status; - - size_t - global_work_size, - local_work_size; - +static MagickBooleanType LaunchRandomImageKernel(MagickCLEnv clEnv, + cl_command_queue queue,cl_mem imageBuffer,const unsigned int imageColumns, + const unsigned int imageRows,cl_mem seedBuffer, + const unsigned int numGenerators,ExceptionInfo *exception) +{ + int + k; + + cl_int + clStatus; + + cl_kernel + randomImageKernel; + + MagickBooleanType + status; + + size_t + global_work_size, + local_work_size; + status = MagickFalse; randomImageKernel = AcquireOpenCLKernel(clEnv, MAGICK_OPENCL_ACCELERATE, "RandomImage"); @@ -6540,59 +6540,59 @@ static MagickBooleanType LaunchRandomImageKernel(MagickCLEnv clEnv, cleanup: if (randomImageKernel!=NULL) RelinquishOpenCLKernel(clEnv, randomImageKernel); - return(status); -} - -static MagickBooleanType ComputeRandomImage(Image* image, - ExceptionInfo* exception) -{ - CacheView - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - /* Don't release this buffer in this function !!! */ - cl_mem - randomNumberSeedsBuffer; - - cl_mem_flags - mem_flags; - - cl_mem - imageBuffer; - - MagickBooleanType - outputReady, - status; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - void - *inputPixels; - - status = MagickFalse; - outputReady = MagickFalse; - inputPixels = NULL; - context = NULL; - imageBuffer = NULL; - queue = NULL; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - - /* Create and initialize OpenCL buffers. */ - image_view=AcquireAuthenticCacheView(image,exception); + return(status); +} + +static MagickBooleanType ComputeRandomImage(Image* image, + ExceptionInfo* exception) +{ + CacheView + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + /* Don't release this buffer in this function !!! */ + cl_mem + randomNumberSeedsBuffer; + + cl_mem_flags + mem_flags; + + cl_mem + imageBuffer; + + MagickBooleanType + outputReady, + status; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + void + *inputPixels; + + status = MagickFalse; + outputReady = MagickFalse; + inputPixels = NULL; + context = NULL; + imageBuffer = NULL; + queue = NULL; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + + /* Create and initialize OpenCL buffers. */ + image_view=AcquireAuthenticCacheView(image,exception); inputPixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) { @@ -6658,11 +6658,11 @@ static MagickBooleanType ComputeRandomImage(Image* image, (void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", "."); goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(image_view,exception); - -cleanup: - OpenCLLogException(__FUNCTION__,__LINE__,exception); - + outputReady=SyncCacheViewAuthenticPixels(image_view,exception); + +cleanup: + OpenCLLogException(__FUNCTION__,__LINE__,exception); + image_view=DestroyCacheView(image_view); UnlockRandSeedBuffer(clEnv); @@ -6671,109 +6671,109 @@ cleanup: return outputReady; } -MagickExport MagickBooleanType AccelerateRandomImage(Image *image, - ExceptionInfo* exception) -{ - MagickBooleanType - status; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, AllChannels) == MagickFalse)) - return(MagickFalse); - - status=ComputeRandomImage(image,exception); - return(status); +MagickExport MagickBooleanType AccelerateRandomImage(Image *image, + ExceptionInfo* exception) +{ + MagickBooleanType + status; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, AllChannels) == MagickFalse)) + return(MagickFalse); + + status=ComputeRandomImage(image,exception); + return(status); } -static Image* ComputeMotionBlurImage(const Image *image, - const ChannelType channel,const double *kernel,const size_t width, - const OffsetInfo *offset,ExceptionInfo *exception) -{ - CacheView - *filteredImage_view, - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_float4 - biasPixel; - - cl_int - clStatus; - - cl_kernel - motionBlurKernel; - - cl_mem - filteredImageBuffer, - imageBuffer, - imageKernelBuffer, - offsetBuffer; - - cl_mem_flags - mem_flags; - - const void - *inputPixels; - - float - *kernelBufferPtr; - - Image - *filteredImage; - - int - *offsetBufferPtr; - - MagickBooleanType - outputReady; - - MagickCLEnv - clEnv; - - PixelInfo - bias; - - MagickSizeType - length; - - size_t - global_work_size[2], - local_work_size[2]; - - unsigned int - i, - imageHeight, - imageWidth, - matte; - - void - *filteredPixels, - *hostPtr; - - outputReady = MagickFalse; - context = NULL; - filteredImage = NULL; - filteredImage_view = NULL; - imageBuffer = NULL; - filteredImageBuffer = NULL; - imageKernelBuffer = NULL; - motionBlurKernel = NULL; - queue = NULL; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - - /* Create and initialize OpenCL buffers. */ - - image_view=AcquireVirtualCacheView(image,exception); +static Image* ComputeMotionBlurImage(const Image *image, + const ChannelType channel,const double *kernel,const size_t width, + const OffsetInfo *offset,ExceptionInfo *exception) +{ + CacheView + *filteredImage_view, + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_float4 + biasPixel; + + cl_int + clStatus; + + cl_kernel + motionBlurKernel; + + cl_mem + filteredImageBuffer, + imageBuffer, + imageKernelBuffer, + offsetBuffer; + + cl_mem_flags + mem_flags; + + const void + *inputPixels; + + float + *kernelBufferPtr; + + Image + *filteredImage; + + int + *offsetBufferPtr; + + MagickBooleanType + outputReady; + + MagickCLEnv + clEnv; + + PixelInfo + bias; + + MagickSizeType + length; + + size_t + global_work_size[2], + local_work_size[2]; + + unsigned int + i, + imageHeight, + imageWidth, + matte; + + void + *filteredPixels, + *hostPtr; + + outputReady = MagickFalse; + context = NULL; + filteredImage = NULL; + filteredImage_view = NULL; + imageBuffer = NULL; + filteredImageBuffer = NULL; + imageKernelBuffer = NULL; + motionBlurKernel = NULL; + queue = NULL; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + + /* Create and initialize OpenCL buffers. */ + + image_view=AcquireVirtualCacheView(image,exception); inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (const void *) NULL) { @@ -6814,7 +6814,7 @@ static Image* ComputeMotionBlurImage(const Image *image, ResourceLimitError, "CloneImage failed.", "'%s'", "."); goto cleanup; } - filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); + filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception); filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception); if (filteredPixels == (void *) NULL) { @@ -6993,12 +6993,12 @@ static Image* ComputeMotionBlurImage(const Image *image, "Reading output image from CL buffer failed.", "'%s'", "."); goto cleanup; } - outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); - -cleanup: - - image_view=DestroyCacheView(image_view); - if (filteredImage_view != NULL) + outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception); + +cleanup: + + image_view=DestroyCacheView(image_view); + if (filteredImage_view != NULL) filteredImage_view=DestroyCacheView(filteredImage_view); if (filteredImageBuffer!=NULL) clEnv->library->clReleaseMemObject(filteredImageBuffer); @@ -7006,57 +7006,57 @@ cleanup: if (imageKernelBuffer!=NULL) clEnv->library->clReleaseMemObject(imageKernelBuffer); if (motionBlurKernel!=NULL) RelinquishOpenCLKernel(clEnv, motionBlurKernel); if (queue != NULL) RelinquishOpenCLCommandQueue(clEnv, queue); - if (outputReady == MagickFalse && filteredImage != NULL) - filteredImage=DestroyImage(filteredImage); - + if (outputReady == MagickFalse && filteredImage != NULL) + filteredImage=DestroyImage(filteredImage); + return(filteredImage); } -MagickExport Image *AccelerateMotionBlurImage(const Image *image, - const ChannelType channel,const double* kernel,const size_t width, - const OffsetInfo *offset,ExceptionInfo *exception) -{ - Image - *filteredImage; - - assert(image != NULL); - assert(kernel != (double *) NULL); - assert(offset != (OffsetInfo *) NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse)) - return NULL; - - filteredImage=ComputeMotionBlurImage(image, channel, kernel, width, - offset, exception); - return(filteredImage); +MagickExport Image *AccelerateMotionBlurImage(const Image *image, + const ChannelType channel,const double* kernel,const size_t width, + const OffsetInfo *offset,ExceptionInfo *exception) +{ + Image + *filteredImage; + + assert(image != NULL); + assert(kernel != (double *) NULL); + assert(offset != (OffsetInfo *) NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse)) + return NULL; + + filteredImage=ComputeMotionBlurImage(image, channel, kernel, width, + offset, exception); + return(filteredImage); } -static MagickBooleanType LaunchCompositeKernel(MagickCLEnv clEnv, - cl_command_queue queue,cl_mem imageBuffer,const unsigned int inputWidth, - const unsigned int inputHeight,const unsigned int matte, - const ChannelType channel,const CompositeOperator compose, - const cl_mem compositeImageBuffer,const unsigned int compositeWidth, - const unsigned int compositeHeight,const float destination_dissolve, - const float source_dissolve,ExceptionInfo *magick_unused(exception)) -{ - cl_int - clStatus; - - cl_kernel - compositeKernel; - - int - k; - - size_t - global_work_size[2], - local_work_size[2]; - - unsigned int - composeOp; - +static MagickBooleanType LaunchCompositeKernel(MagickCLEnv clEnv, + cl_command_queue queue,cl_mem imageBuffer,const unsigned int inputWidth, + const unsigned int inputHeight,const unsigned int matte, + const ChannelType channel,const CompositeOperator compose, + const cl_mem compositeImageBuffer,const unsigned int compositeWidth, + const unsigned int compositeHeight,const float destination_dissolve, + const float source_dissolve,ExceptionInfo *magick_unused(exception)) +{ + cl_int + clStatus; + + cl_kernel + compositeKernel; + + int + k; + + size_t + global_work_size[2], + local_work_size[2]; + + unsigned int + composeOp; + magick_unreferenced(exception); compositeKernel = AcquireOpenCLKernel(clEnv, MAGICK_OPENCL_ACCELERATE, @@ -7091,65 +7091,65 @@ static MagickBooleanType LaunchCompositeKernel(MagickCLEnv clEnv, RelinquishOpenCLKernel(clEnv, compositeKernel); - return((clStatus==CL_SUCCESS) ? MagickTrue : MagickFalse); -} - -static MagickBooleanType ComputeCompositeImage(Image *image, - const ChannelType channel,const CompositeOperator compose, - const Image *compositeImage,const ssize_t magick_unused(x_offset), - const ssize_t magick_unused(y_offset),const float destination_dissolve, - const float source_dissolve,ExceptionInfo *exception) -{ - CacheView - *image_view; - - cl_command_queue - queue; - - cl_context - context; - - cl_int - clStatus; - - cl_mem_flags - mem_flags; - - cl_mem - compositeImageBuffer, - imageBuffer; - - const void - *composePixels; - - MagickBooleanType - outputReady, - status; - - MagickCLEnv - clEnv; - - MagickSizeType - length; - - void - *inputPixels; - - magick_unreferenced(x_offset); - magick_unreferenced(y_offset); - - status = MagickFalse; - outputReady = MagickFalse; - composePixels = NULL; - imageBuffer = NULL; - compositeImageBuffer = NULL; - - clEnv = GetDefaultOpenCLEnv(); - context = GetOpenCLContext(clEnv); - queue = AcquireOpenCLCommandQueue(clEnv); - - /* Create and initialize OpenCL buffers. */ - image_view=AcquireAuthenticCacheView(image,exception); + return((clStatus==CL_SUCCESS) ? MagickTrue : MagickFalse); +} + +static MagickBooleanType ComputeCompositeImage(Image *image, + const ChannelType channel,const CompositeOperator compose, + const Image *compositeImage,const ssize_t magick_unused(x_offset), + const ssize_t magick_unused(y_offset),const float destination_dissolve, + const float source_dissolve,ExceptionInfo *exception) +{ + CacheView + *image_view; + + cl_command_queue + queue; + + cl_context + context; + + cl_int + clStatus; + + cl_mem_flags + mem_flags; + + cl_mem + compositeImageBuffer, + imageBuffer; + + const void + *composePixels; + + MagickBooleanType + outputReady, + status; + + MagickCLEnv + clEnv; + + MagickSizeType + length; + + void + *inputPixels; + + magick_unreferenced(x_offset); + magick_unreferenced(y_offset); + + status = MagickFalse; + outputReady = MagickFalse; + composePixels = NULL; + imageBuffer = NULL; + compositeImageBuffer = NULL; + + clEnv = GetDefaultOpenCLEnv(); + context = GetOpenCLContext(clEnv); + queue = AcquireOpenCLCommandQueue(clEnv); + + /* Create and initialize OpenCL buffers. */ + image_view=AcquireAuthenticCacheView(image,exception); inputPixels=GetCacheViewAuthenticPixels(image_view,0,0,image->columns,image->rows,exception); if (inputPixels == (void *) NULL) { @@ -7238,32 +7238,32 @@ static MagickBooleanType ComputeCompositeImage(Image *image, length * sizeof(CLPixelPacket), inputPixels, 0, NULL, NULL); } if (clStatus==CL_SUCCESS) - outputReady=SyncCacheViewAuthenticPixels(image_view,exception); - -cleanup: - - image_view=DestroyCacheView(image_view); + outputReady=SyncCacheViewAuthenticPixels(image_view,exception); + +cleanup: + + image_view=DestroyCacheView(image_view); if (imageBuffer!=NULL) clEnv->library->clReleaseMemObject(imageBuffer); if (compositeImageBuffer!=NULL) clEnv->library->clReleaseMemObject(compositeImageBuffer); if (queue != NULL) RelinquishOpenCLCommandQueue(clEnv, queue); - return(outputReady); -} - -MagickExport MagickBooleanType AccelerateCompositeImage(Image *image, - const ChannelType channel,const CompositeOperator compose, - const Image *composite,const ssize_t x_offset,const ssize_t y_offset, - const float destination_dissolve,const float source_dissolve, - ExceptionInfo *exception) -{ - MagickBooleanType - status; - - assert(image != NULL); - assert(exception != (ExceptionInfo *) NULL); - - if ((checkOpenCLEnvironment(exception) == MagickFalse) || - (checkAccelerateCondition(image, channel) == MagickFalse)) + return(outputReady); +} + +MagickExport MagickBooleanType AccelerateCompositeImage(Image *image, + const ChannelType channel,const CompositeOperator compose, + const Image *composite,const ssize_t x_offset,const ssize_t y_offset, + const float destination_dissolve,const float source_dissolve, + ExceptionInfo *exception) +{ + MagickBooleanType + status; + + assert(image != NULL); + assert(exception != (ExceptionInfo *) NULL); + + if ((checkOpenCLEnvironment(exception) == MagickFalse) || + (checkAccelerateCondition(image, channel) == MagickFalse)) return(MagickFalse); /* only support zero offset and diff --git a/MagickCore/opencl.c b/MagickCore/opencl.c index a54940fa8..1d2c056bc 100644 --- a/MagickCore/opencl.c +++ b/MagickCore/opencl.c @@ -200,7 +200,7 @@ MagickExport MagickBooleanType RelinquishMagickOpenCLEnv(MagickCLEnv clEnv) { if (clEnv != (MagickCLEnv)NULL) { - DestroySemaphoreInfo(&clEnv->lock); + RelinquishSemaphoreInfo(&clEnv->lock); RelinquishMagickMemory(clEnv); return MagickTrue; }