/* pad the global workgroup size to the next multiple of
the local workgroup size */
-inline static unsigned int padGlobalWorkgroupSizeToLocalWorkgroupSize(\r
- const unsigned int orgGlobalSize,const unsigned int localGroupSize) \r
-{\r
- return ((orgGlobalSize+(localGroupSize-1))/localGroupSize*localGroupSize);\r
-}\r
-\r
-static MagickBooleanType checkOpenCLEnvironment(ExceptionInfo* exception)\r
-{\r
- MagickBooleanType\r
- flag;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- clEnv=GetDefaultOpenCLEnv();\r
-\r
- GetMagickOpenCLEnvParam(clEnv,MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED,\r
- sizeof(MagickBooleanType),&flag,exception);\r
- if (flag != MagickFalse)\r
- return(MagickFalse);\r
-\r
- GetMagickOpenCLEnvParam(clEnv,MAGICK_OPENCL_ENV_PARAM_OPENCL_INITIALIZED,\r
- sizeof(MagickBooleanType),&flag,exception);\r
- if (flag == MagickFalse)\r
- {\r
- if (InitOpenCLEnv(clEnv,exception) == MagickFalse)\r
- return(MagickFalse);\r
-\r
- GetMagickOpenCLEnvParam(clEnv,MAGICK_OPENCL_ENV_PARAM_OPENCL_DISABLED,\r
- sizeof(MagickBooleanType),&flag,exception);\r
- if (flag != MagickFalse)\r
- return(MagickFalse);\r
- }\r
-\r
- return(MagickTrue);\r
-}\r
-\r
-static MagickBooleanType checkAccelerateCondition(const Image* image,\r
- const ChannelType channel)\r
-{\r
- /* check if the image's colorspace is supported */\r
- if (image->colorspace != RGBColorspace &&\r
- image->colorspace != sRGBColorspace &&\r
- image->colorspace != GRAYColorspace)\r
- return(MagickFalse);\r
-\r
- /* check if the channel is supported */\r
- if (((channel & RedChannel) == 0) ||\r
- ((channel & GreenChannel) == 0) ||\r
- ((channel & BlueChannel) == 0))\r
- return(MagickFalse);\r
-\r
- /* check if the virtual pixel method is compatible with the OpenCL implementation */\r
- if ((GetImageVirtualPixelMethod(image) != UndefinedVirtualPixelMethod) &&\r
- (GetImageVirtualPixelMethod(image) != EdgeVirtualPixelMethod))\r
- return(MagickFalse);\r
-\r
- /* check if the image has read / write mask */\r
- if (image->read_mask != MagickFalse || image->write_mask != MagickFalse)\r
- return(MagickFalse);\r
-\r
- return(MagickTrue);\r
-}\r
-\r
-static MagickBooleanType checkHistogramCondition(Image *image,\r
- const ChannelType channel)\r
-{\r
- /* ensure this is the only pass get in for now. */\r
- if ((channel & SyncChannels) == 0)\r
- return MagickFalse;\r
-\r
- if (image->intensity == Rec601LuminancePixelIntensityMethod ||\r
- image->intensity == Rec709LuminancePixelIntensityMethod)\r
- return MagickFalse;\r
-\r
- if (image->colorspace != sRGBColorspace)\r
- return MagickFalse;\r
-\r
- return MagickTrue;\r
-}\r
-\r
-static MagickBooleanType splitImage(const Image* image)\r
-{\r
- MagickBooleanType\r
- split;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- unsigned long\r
- allocSize,\r
- tempSize;\r
-\r
- clEnv=GetDefaultOpenCLEnv();\r
-\r
- allocSize=GetOpenCLDeviceMaxMemAllocSize(clEnv);\r
- tempSize=image->columns * image->rows * 4 * 4;\r
-\r
- split = ((tempSize > allocSize) ? MagickTrue : MagickFalse);\r
- return(split);\r
+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);
}
/*
%
*/
-static Image *ComputeConvolveImage(const Image* image,\r
- const ChannelType channel,const KernelInfo *kernel,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_kernel\r
- clkernel;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_mem\r
- convolutionKernel,\r
- filteredImageBuffer,\r
- imageBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- cl_ulong\r
- deviceLocalMemorySize;\r
-\r
- const void\r
- *inputPixels;\r
-\r
- float\r
- *kernelBufferPtr;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- size_t\r
- global_work_size[3],\r
- localGroupSize[3],\r
- localMemoryRequirement;\r
-\r
- unsigned\r
- kernelSize;\r
-\r
- unsigned int\r
- filterHeight,\r
- filterWidth,\r
- i,\r
- imageHeight,\r
- imageWidth,\r
- matte;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- /* intialize all CL objects to NULL */\r
- context = NULL;\r
- imageBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- convolutionKernel = NULL;\r
- clkernel = NULL;\r
- queue = NULL;\r
-\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
+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);\r
+ image_view=AcquireVirtualCacheView(image,exception);
inputPixels=GetCacheViewVirtualPixels(image_view,0,0,image->columns,image->rows,exception);
if (inputPixels == (const void *) NULL)
{
mem_flags = CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR;
}
/* create a CL buffer from image pixel buffer */
- length = image->columns * image->rows;\r
+ length = image->columns * image->rows;
imageBuffer = clEnv->library->clCreateBuffer(context, mem_flags, length * sizeof(CLPixelPacket), (void*)inputPixels, &clStatus);
if (clStatus != CL_SUCCESS)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
+ 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)
return(filteredImage);
}
-MagickExport Image *AccelerateConvolveImageChannel(const Image *image,\r
- const ChannelType channel,const KernelInfo *kernel,ExceptionInfo *exception)\r
-{\r
- Image\r
- *filteredImage;\r
-\r
- assert(image != NULL);\r
- assert(kernel != (KernelInfo *) NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse))\r
- return NULL;\r
-\r
- filteredImage=ComputeConvolveImage(image, channel, kernel, exception);\r
- return(filteredImage);\r
+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,\r
- const ChannelType channel,const MagickFunction function,\r
- const size_t number_parameters,const double *parameters,\r
- ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- clkernel;\r
-\r
- cl_mem\r
- imageBuffer,\r
- parametersBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- float\r
- *parametersBufferPtr;\r
-\r
- MagickBooleanType\r
- status;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- size_t\r
- globalWorkSize[2];\r
-\r
- unsigned int\r
- i;\r
-\r
- void\r
- *pixels;\r
-\r
- status = MagickFalse;\r
-\r
- context = NULL;\r
- clkernel = NULL;\r
- queue = NULL;\r
- imageBuffer = NULL;\r
- parametersBuffer = NULL;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
-\r
- image_view=AcquireAuthenticCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", ".");
goto cleanup;
}
- status=SyncCacheViewAuthenticPixels(image_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
+ status=SyncCacheViewAuthenticPixels(image_view,exception);
+
+cleanup:
+ OpenCLLogException(__FUNCTION__,__LINE__,exception);
+
image_view=DestroyCacheView(image_view);
if (clkernel != NULL) RelinquishOpenCLKernel(clEnv, clkernel);
return(status);
}
-MagickExport MagickBooleanType AccelerateFunctionImage(Image *image,\r
- const ChannelType channel,const MagickFunction function,\r
- const size_t number_parameters,const double *parameters,\r
- ExceptionInfo *exception)\r
-{\r
- MagickBooleanType\r
- status;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse))\r
- return(MagickFalse);\r
-\r
- status=ComputeFunctionImage(image, channel, function, number_parameters, parameters, exception);\r
- return(status);\r
+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);
}
/*
%
*/
-static Image *ComputeBlurImage(const Image* image,const ChannelType channel,\r
- const double radius,const double sigma,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- char\r
- geometry[MaxTextExtent];\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- blurColumnKernel,\r
- blurRowKernel;\r
-\r
- cl_mem\r
- filteredImageBuffer,\r
- imageBuffer,\r
- imageKernelBuffer,\r
- tempImageBuffer;\r
- \r
- cl_mem_flags\r
- mem_flags;\r
-\r
- const void\r
- *inputPixels;\r
-\r
- float\r
- *kernelBufferPtr;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- KernelInfo\r
- *kernel;\r
-\r
- unsigned int\r
- i,\r
- imageColumns,\r
- imageRows,\r
- kernelWidth;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- context = NULL;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- imageBuffer = NULL;\r
- tempImageBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- imageKernelBuffer = NULL;\r
- blurRowKernel = NULL;\r
- blurColumnKernel = NULL;\r
- queue = NULL;\r
- kernel = NULL;\r
-\r
- outputReady = MagickFalse;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- /* Create and initialize OpenCL buffers. */\r
- {\r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
- filteredImage_view=DestroyCacheView(filteredImage_view);\r
-\r
+ 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);
if (queue != NULL) RelinquishOpenCLCommandQueue(clEnv, queue);
if (kernel!=NULL) DestroyKernelInfo(kernel);
if (outputReady == MagickFalse && filteredImage != NULL)
- filteredImage=DestroyImage(filteredImage);\r
+ filteredImage=DestroyImage(filteredImage);
return(filteredImage);
}
-static Image* ComputeBlurImageSection(const Image* image,\r
- const ChannelType channel,const double radius,const double sigma,\r
- ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- char\r
- geometry[MaxTextExtent];\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- blurColumnKernel,\r
- blurRowKernel;\r
-\r
- cl_mem\r
- imageBuffer,\r
- tempImageBuffer,\r
- filteredImageBuffer,\r
- imageKernelBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- cl_context\r
- context;\r
- \r
- const void\r
- *inputPixels;\r
-\r
- float\r
- *kernelBufferPtr;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- KernelInfo\r
- *kernel;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- unsigned int\r
- i,\r
- imageColumns,\r
- imageRows,\r
- kernelWidth;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- context = NULL;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- imageBuffer = NULL;\r
- tempImageBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- imageKernelBuffer = NULL;\r
- blurRowKernel = NULL;\r
- blurColumnKernel = NULL;\r
- queue = NULL;\r
- kernel = NULL;\r
-\r
- outputReady = MagickFalse;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- /* Create and initialize OpenCL buffers. */\r
- {\r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
- filteredImage_view=DestroyCacheView(filteredImage_view);\r
-\r
+ 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);
return filteredImage;
}
-MagickExport Image* AccelerateBlurImage(const Image *image,\r
- const ChannelType channel,const double radius,const double sigma,\r
- ExceptionInfo *exception)\r
-{\r
- Image\r
- *filteredImage;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse))\r
- return NULL;\r
-\r
- if (splitImage(image) && (image->rows / 2 > radius)) \r
- filteredImage=ComputeBlurImageSection(image, channel, radius, sigma, exception);\r
- else\r
- filteredImage=ComputeBlurImage(image, channel, radius, sigma, exception);\r
-\r
- return(filteredImage);\r
+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);
}
/*
%
*/
-static Image* ComputeRotationalBlurImage(const Image *image,\r
- const ChannelType channel,const double angle,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *image_view,\r
- *filteredImage_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_float2\r
- blurCenter;\r
-\r
- cl_float4\r
- biasPixel;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_mem\r
- cosThetaBuffer,\r
- filteredImageBuffer,\r
- imageBuffer,\r
- sinThetaBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- cl_kernel\r
- rotationalBlurKernel;\r
-\r
- const void\r
- *inputPixels;\r
-\r
- float\r
- blurRadius,\r
- *cosThetaPtr,\r
- offset,\r
- *sinThetaPtr,\r
- theta;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- PixelInfo\r
- bias;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- size_t\r
- global_work_size[2];\r
-\r
- unsigned int\r
- cossin_theta_size,\r
- i,\r
- matte;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- outputReady = MagickFalse;\r
- context = NULL;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- imageBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- sinThetaBuffer = NULL;\r
- cosThetaBuffer = NULL;\r
- queue = NULL;\r
- rotationalBlurKernel = NULL;\r
-\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
-\r
-\r
- /* Create and initialize OpenCL buffers. */\r
-\r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", ".");
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
+ 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);
return filteredImage;
}
-MagickExport Image* AccelerateRotationalBlurImage(const Image *image,\r
- const ChannelType channel,const double angle,ExceptionInfo *exception)\r
-{\r
- Image\r
- *filteredImage;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse))\r
- return NULL;\r
-\r
- filteredImage=ComputeRotationalBlurImage(image, channel, angle, exception);\r
- return filteredImage;\r
+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;
}
/*
%
*/
-static Image *ComputeUnsharpMaskImage(const Image *image,\r
- const ChannelType channel,const double radius,const double sigma,\r
- const double gain,const double threshold,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- char\r
- geometry[MaxTextExtent];\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- blurRowKernel,\r
- unsharpMaskBlurColumnKernel;\r
-\r
- cl_mem\r
- filteredImageBuffer,\r
- imageBuffer,\r
- imageKernelBuffer,\r
- tempImageBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- const void\r
- *inputPixels;\r
-\r
- float\r
- fGain,\r
- fThreshold,\r
- *kernelBufferPtr;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- int\r
- chunkSize;\r
-\r
- KernelInfo\r
- *kernel;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- unsigned int\r
- i,\r
- imageColumns,\r
- imageRows,\r
- kernelWidth;\r
-\r
- clEnv = NULL;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- kernel = NULL;\r
- context = NULL;\r
- imageBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- tempImageBuffer = NULL;\r
- imageKernelBuffer = NULL;\r
- blurRowKernel = NULL;\r
- unsharpMaskBlurColumnKernel = NULL;\r
- queue = NULL;\r
- outputReady = MagickFalse;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- /* Create and initialize OpenCL buffers. */\r
- {\r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
+ 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);
return(filteredImage);
}
-static Image *ComputeUnsharpMaskImageSection(const Image *image,\r
- const ChannelType channel,const double radius,const double sigma,\r
- const double gain,const double threshold,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- char\r
- geometry[MaxTextExtent];\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- blurRowKernel,\r
- unsharpMaskBlurColumnKernel;\r
-\r
- cl_mem\r
- filteredImageBuffer,\r
- imageBuffer,\r
- imageKernelBuffer,\r
- tempImageBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- const void\r
- *inputPixels;\r
-\r
- float\r
- fGain,\r
- fThreshold,\r
- *kernelBufferPtr;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- int\r
- chunkSize;\r
-\r
- KernelInfo\r
- *kernel;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- unsigned int\r
- i,\r
- imageColumns,\r
- imageRows,\r
- kernelWidth;\r
-\r
- clEnv = NULL;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- kernel = NULL;\r
- context = NULL;\r
- imageBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- tempImageBuffer = NULL;\r
- imageKernelBuffer = NULL;\r
- blurRowKernel = NULL;\r
- unsharpMaskBlurColumnKernel = NULL;\r
- queue = NULL;\r
- outputReady = MagickFalse;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- /* Create and initialize OpenCL buffers. */\r
- {\r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
+ 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);
}
}
return filteredImage;
-}\r
-\r
-MagickExport Image *AccelerateUnsharpMaskImage(const Image *image,\r
- const ChannelType channel,const double radius,const double sigma,\r
- const double gain,const double threshold,ExceptionInfo *exception)\r
-{\r
- Image\r
- *filteredImage;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse))\r
- return NULL;\r
-\r
- if (splitImage(image) && (image->rows / 2 > radius)) \r
- filteredImage = ComputeUnsharpMaskImageSection(image,channel,radius,sigma,gain,threshold,exception);\r
- else\r
- filteredImage = ComputeUnsharpMaskImage(image,channel,radius,sigma,gain,threshold,exception);\r
- return(filteredImage);\r
}
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% 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 %
% %
% %
% %
%
*/
-static MagickBooleanType resizeHorizontalFilter(cl_mem image,\r
- const unsigned int imageColumns,const unsigned int imageRows,\r
- const unsigned int matte,cl_mem resizedImage,\r
- const unsigned int resizedColumns,const unsigned int resizedRows,\r
- const ResizeFilter *resizeFilter,cl_mem resizeFilterCubicCoefficients,\r
- const float xFactor,MagickCLEnv clEnv,cl_command_queue queue,\r
- ExceptionInfo *exception)\r
-{\r
- cl_kernel\r
- horizontalKernel;\r
-\r
- cl_int clStatus;\r
-\r
- const unsigned int\r
- workgroupSize = 256;\r
-\r
- float\r
- resizeFilterScale,\r
- resizeFilterSupport,\r
- resizeFilterWindowSupport,\r
- resizeFilterBlur,\r
- scale,\r
- support;\r
-\r
- int\r
- cacheRangeStart,\r
- cacheRangeEnd,\r
- numCachedPixels,\r
- resizeFilterType,\r
- resizeWindowType;\r
-\r
- MagickBooleanType\r
- status = MagickFalse;\r
-\r
- size_t\r
- deviceLocalMemorySize,\r
- gammaAccumulatorLocalMemorySize,\r
- global_work_size[2],\r
- imageCacheLocalMemorySize,\r
- pixelAccumulatorLocalMemorySize,\r
- local_work_size[2],\r
- totalLocalMemorySize,\r
- weightAccumulatorLocalMemorySize;\r
-\r
- unsigned int\r
- chunkSize,\r
- i,\r
- pixelPerWorkgroup;\r
-\r
- horizontalKernel = NULL;\r
+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;
/*
if (horizontalKernel != NULL) RelinquishOpenCLKernel(clEnv, horizontalKernel);
- return(status);\r
-}\r
-\r
-static MagickBooleanType resizeVerticalFilter(cl_mem image,\r
- const unsigned int imageColumns,const unsigned int imageRows,\r
- const unsigned int matte,cl_mem resizedImage,\r
- const unsigned int resizedColumns,const unsigned int resizedRows,\r
- const ResizeFilter *resizeFilter,cl_mem resizeFilterCubicCoefficients,\r
- const float yFactor,MagickCLEnv clEnv,cl_command_queue queue,\r
- ExceptionInfo *exception)\r
-{\r
- cl_kernel\r
- horizontalKernel;\r
-\r
- cl_int clStatus;\r
-\r
- const unsigned int\r
- workgroupSize = 256;\r
-\r
- float\r
- resizeFilterScale,\r
- resizeFilterSupport,\r
- resizeFilterWindowSupport,\r
- resizeFilterBlur,\r
- scale,\r
- support;\r
-\r
- int\r
- cacheRangeStart,\r
- cacheRangeEnd,\r
- numCachedPixels,\r
- resizeFilterType,\r
- resizeWindowType;\r
-\r
- MagickBooleanType\r
- status = MagickFalse;\r
-\r
- size_t\r
- deviceLocalMemorySize,\r
- gammaAccumulatorLocalMemorySize,\r
- global_work_size[2],\r
- imageCacheLocalMemorySize,\r
- pixelAccumulatorLocalMemorySize,\r
- local_work_size[2],\r
- totalLocalMemorySize,\r
- weightAccumulatorLocalMemorySize;\r
-\r
- unsigned int\r
- chunkSize,\r
- i,\r
- pixelPerWorkgroup;\r
-\r
- horizontalKernel = NULL;\r
+ 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;
/*
return(status);
}
-static Image *ComputeResizeImage(const Image* image,\r
- const size_t resizedColumns,const size_t resizedRows,\r
- const ResizeFilter *resizeFilter,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_mem\r
- cubicCoefficientsBuffer,\r
- filteredImageBuffer,\r
- imageBuffer,\r
- tempImageBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- const double\r
- *resizeFilterCoefficient;\r
-\r
- const void\r
- *inputPixels;\r
-\r
- float\r
- *mappedCoefficientBuffer,\r
- xFactor,\r
- yFactor;\r
-\r
- MagickBooleanType\r
- outputReady,\r
- status;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- unsigned int\r
- i;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- outputReady = MagickFalse;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- clEnv = NULL;\r
- context = NULL;\r
- imageBuffer = NULL;\r
- tempImageBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- cubicCoefficientsBuffer = NULL;\r
- queue = NULL;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
-\r
- /* Create and initialize OpenCL buffers. */\r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", ".");
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
+ 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);
return(filteredImage);
}
-const ResizeWeightingFunctionType supportedResizeWeighting[] = \r
-{\r
- BoxWeightingFunction,\r
- TriangleWeightingFunction,\r
- HanningWeightingFunction,\r
- HammingWeightingFunction,\r
- BlackmanWeightingFunction,\r
- CubicBCWeightingFunction,\r
- SincWeightingFunction,\r
- SincFastWeightingFunction,\r
- LastWeightingFunction\r
+const ResizeWeightingFunctionType supportedResizeWeighting[] =
+{
+ BoxWeightingFunction,
+ TriangleWeightingFunction,
+ HanningWeightingFunction,
+ HammingWeightingFunction,
+ BlackmanWeightingFunction,
+ CubicBCWeightingFunction,
+ SincWeightingFunction,
+ SincFastWeightingFunction,
+ LastWeightingFunction
};
-static MagickBooleanType gpuSupportedResizeWeighting(\r
- ResizeWeightingFunctionType f)\r
-{\r
- unsigned int\r
- i;\r
-\r
- for (i = 0; ;i++)\r
- {\r
- if (supportedResizeWeighting[i] == LastWeightingFunction)\r
- break;\r
- if (supportedResizeWeighting[i] == f)\r
- return(MagickTrue);\r
- }\r
- return(MagickFalse);\r
-}\r
-\r
-MagickExport Image *AccelerateResizeImage(const Image *image,\r
- const size_t resizedColumns,const size_t resizedRows,\r
- const ResizeFilter *resizeFilter,ExceptionInfo *exception) \r
-{\r
- Image\r
- *filteredImage;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, AllChannels) == MagickFalse))\r
- return NULL;\r
-\r
- if (gpuSupportedResizeWeighting(GetResizeFilterWeightingType(resizeFilter)) == MagickFalse ||\r
- gpuSupportedResizeWeighting(GetResizeFilterWindowWeightingType(resizeFilter)) == MagickFalse)\r
- return NULL;\r
-\r
- filteredImage=ComputeResizeImage(image,resizedColumns,resizedRows,resizeFilter,exception);\r
- return(filteredImage);\r
+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 ComputeContrastImage(Image *image,\r
- const MagickBooleanType sharpen,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- filterKernel;\r
-\r
- cl_mem\r
- imageBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- size_t\r
- global_work_size[2];\r
-\r
- unsigned int\r
- i,\r
- uSharpen;\r
-\r
- void\r
- *inputPixels;\r
-\r
- outputReady = MagickFalse;\r
- clEnv = NULL;\r
- inputPixels = NULL;\r
- context = NULL;\r
- imageBuffer = NULL;\r
- filterKernel = NULL;\r
- queue = NULL;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
-\r
- /* Create and initialize OpenCL buffers. */\r
- image_view=AcquireAuthenticCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", ".");
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(image_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
+ 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);
-}\r
-\r
-MagickExport MagickBooleanType AccelerateContrastImage(Image *image,\r
- const MagickBooleanType sharpen,ExceptionInfo *exception)\r
-{\r
- MagickBooleanType\r
- status;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, AllChannels) == MagickFalse))\r
- return(MagickFalse);\r
-\r
- status = ComputeContrastImage(image,sharpen,exception);\r
- return(status);\r
+}
+
+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);
}
/*
%
*/
-MagickBooleanType ComputeModulateImage(Image *image,\r
- double percent_brightness,double percent_hue,double percent_saturation,\r
- ColorspaceType colorspace,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *image_view;\r
-\r
- cl_float\r
- bright,\r
- hue,\r
- saturation;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_int\r
- color,\r
- clStatus;\r
-\r
- cl_kernel\r
- modulateKernel;\r
-\r
- cl_mem\r
- imageBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- register ssize_t\r
- i;\r
-\r
- void\r
- *inputPixels;\r
-\r
- inputPixels = NULL;\r
- imageBuffer = NULL;\r
- modulateKernel = NULL; \r
-\r
- assert(image != (Image *) NULL);\r
- assert(image->signature == MagickSignature);\r
- if (image->debug != MagickFalse)\r
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);\r
-\r
- /*\r
- * initialize opencl env\r
- */\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- outputReady = MagickFalse;\r
-\r
- /* Create and initialize OpenCL buffers.\r
- inputPixels = AcquirePixelCachePixels(image, &length, exception);\r
- assume this will get a writable image\r
- */\r
- image_view=AcquireAuthenticCacheView(image,exception);\r
+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)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(image_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
+ outputReady=SyncCacheViewAuthenticPixels(image_view,exception);
+
+cleanup:
+ OpenCLLogException(__FUNCTION__,__LINE__,exception);
+
image_view=DestroyCacheView(image_view);
if (imageBuffer!=NULL)
}
-MagickExport MagickBooleanType AccelerateModulateImage(Image *image,\r
- double percent_brightness,double percent_hue,double percent_saturation,\r
- ColorspaceType colorspace,ExceptionInfo *exception)\r
-{\r
- MagickBooleanType\r
- status;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, AllChannels) == MagickFalse))\r
- return(MagickFalse);\r
-\r
- if ((colorspace != HSLColorspace && colorspace != UndefinedColorspace))\r
- return(MagickFalse);\r
-\r
- status = ComputeModulateImage(image,percent_brightness, percent_hue, percent_saturation, colorspace, exception);\r
- return(status);\r
+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);
}
/*
%
*/
-MagickBooleanType ComputeNegateImageChannel(Image *image,\r
- const ChannelType channel,const MagickBooleanType magick_unused(grayscale),\r
- ExceptionInfo* exception)\r
-{\r
- CacheView\r
- *image_view;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- negateKernel; \r
-\r
- cl_mem\r
- imageBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- register ssize_t\r
- i;\r
-\r
- void\r
- *inputPixels;\r
-\r
- magick_unreferenced(grayscale);\r
-\r
- inputPixels = NULL;\r
- imageBuffer = NULL;\r
- negateKernel = NULL; \r
-\r
- assert(image != (Image *) NULL);\r
- assert(image->signature == MagickSignature);\r
- if (image->debug != MagickFalse)\r
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);\r
-\r
- /*\r
- * initialize opencl env\r
- */\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- outputReady = MagickFalse;\r
-\r
- /* Create and initialize OpenCL buffers.\r
- inputPixels = AcquirePixelCachePixels(image, &length, exception);\r
- assume this will get a writable image\r
- */\r
- image_view=AcquireAuthenticCacheView(image,exception);\r
+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)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(image_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
+ outputReady=SyncCacheViewAuthenticPixels(image_view,exception);
+
+cleanup:
+ OpenCLLogException(__FUNCTION__,__LINE__,exception);
+
image_view=DestroyCacheView(image_view);
if (imageBuffer!=NULL)
RelinquishOpenCLCommandQueue(clEnv, queue);
return(outputReady);
-}\r
-\r
-MagickExport MagickBooleanType AccelerateNegateImageChannel(Image *image,\r
- const ChannelType channel,const MagickBooleanType grayscale,\r
- ExceptionInfo* exception)\r
-{\r
- MagickBooleanType\r
- status;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse))\r
- return(MagickFalse);\r
-\r
- status=ComputeNegateImageChannel(image,channel,grayscale,exception);\r
- return(status);\r
+}
+
+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);
}
/*
%
*/
-MagickBooleanType ComputeGrayscaleImage(Image *image,\r
- const PixelIntensityMethod method,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus,\r
- intensityMethod;\r
-\r
- cl_int\r
- colorspace;\r
-\r
- cl_kernel\r
- grayscaleKernel;\r
-\r
- cl_mem\r
- imageBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- register ssize_t\r
- i;\r
-\r
- void\r
- *inputPixels;\r
-\r
- inputPixels = NULL;\r
- imageBuffer = NULL;\r
- grayscaleKernel = NULL; \r
-\r
- assert(image != (Image *) NULL);\r
- assert(image->signature == MagickSignature);\r
- if (image->debug != MagickFalse)\r
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);\r
-\r
- /*\r
- * initialize opencl env\r
- */\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- outputReady = MagickFalse;\r
-\r
- /* Create and initialize OpenCL buffers.\r
- inputPixels = AcquirePixelCachePixels(image, &length, exception);\r
- assume this will get a writable image\r
- */\r
- image_view=AcquireAuthenticCacheView(image,exception);\r
+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)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(image_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
+ outputReady=SyncCacheViewAuthenticPixels(image_view,exception);
+
+cleanup:
+ OpenCLLogException(__FUNCTION__,__LINE__,exception);
+
image_view=DestroyCacheView(image_view);
if (imageBuffer!=NULL)
RelinquishOpenCLCommandQueue(clEnv, queue);
return( outputReady);
-}\r
-\r
-MagickExport MagickBooleanType AccelerateGrayscaleImage(Image* image,\r
- const PixelIntensityMethod method,ExceptionInfo *exception)\r
-{\r
- MagickBooleanType\r
- status;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, AllChannels) == MagickFalse))\r
- return(MagickFalse);\r
-\r
- if (method == Rec601LuminancePixelIntensityMethod || method == Rec709LuminancePixelIntensityMethod)\r
- return(MagickFalse);\r
-\r
- if (image->colorspace != sRGBColorspace)\r
- return(MagickFalse);\r
-\r
- status=ComputeGrayscaleImage(image,method,exception);\r
- return(status);\r
+}
+
+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);
}
/*
%
*/
-static MagickBooleanType LaunchHistogramKernel(MagickCLEnv clEnv,\r
- cl_command_queue queue,cl_mem imageBuffer,cl_mem histogramBuffer,\r
- Image *image,const ChannelType channel,ExceptionInfo *exception)\r
-{\r
- MagickBooleanType\r
- outputReady;\r
-\r
- cl_int\r
- clStatus,\r
- colorspace,\r
- method;\r
-\r
- cl_kernel\r
- histogramKernel; \r
-\r
- register ssize_t\r
- i;\r
-\r
- size_t\r
- global_work_size[2];\r
-\r
+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;
return(outputReady);
}
-MagickExport MagickBooleanType ComputeEqualizeImage(Image *image,\r
- const ChannelType channel,ExceptionInfo *exception)\r
-{\r
-#define EqualizeImageTag "Equalize/Image"\r
-\r
- CacheView\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- cl_mem\r
- equalizeMapBuffer,\r
- histogramBuffer,\r
- imageBuffer;\r
-\r
- cl_kernel\r
- equalizeKernel,\r
- histogramKernel;\r
-\r
- cl_uint4\r
- *histogram;\r
-\r
- FloatPixelPacket\r
- white,\r
- black,\r
- intensity,\r
- *map;\r
-\r
- MagickBooleanType\r
- outputReady,\r
- status;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- PixelPacket\r
- *equalize_map;\r
-\r
- register ssize_t\r
- i;\r
-\r
- size_t\r
- global_work_size[2];\r
-\r
- void\r
- *hostPtr,\r
- *inputPixels;\r
-\r
- map=NULL;\r
- histogram=NULL;\r
- equalize_map=NULL;\r
- inputPixels = NULL;\r
- imageBuffer = NULL;\r
- histogramBuffer = NULL;\r
- equalizeMapBuffer = NULL;\r
- histogramKernel = NULL; \r
- equalizeKernel = NULL; \r
- context = NULL;\r
- queue = NULL;\r
- outputReady = MagickFalse;\r
-\r
- assert(image != (Image *) NULL);\r
- assert(image->signature == MagickSignature);\r
- if (image->debug != MagickFalse)\r
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);\r
-\r
- /*\r
- * initialize opencl env\r
- */\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- /*\r
- Allocate and initialize histogram arrays.\r
- */\r
- histogram=(cl_uint4 *) AcquireQuantumMemory(MaxMap+1UL, sizeof(*histogram));\r
- if (histogram == (cl_uint4 *) NULL)\r
- ThrowBinaryException(ResourceLimitWarning,"MemoryAllocationFailed", image->filename);\r
-\r
- /* reset histogram */\r
- (void) ResetMagickMemory(histogram,0,(MaxMap+1)*sizeof(*histogram));\r
-\r
- /* Create and initialize OpenCL buffers. */\r
- /* inputPixels = AcquirePixelCachePixels(image, &length, exception); */\r
- /* assume this will get a writable image */\r
- image_view=AcquireAuthenticCacheView(image,exception);\r
+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)
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(image_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
+ outputReady=SyncCacheViewAuthenticPixels(image_view,exception);
+
+cleanup:
+ OpenCLLogException(__FUNCTION__,__LINE__,exception);
+
image_view=DestroyCacheView(image_view);
if (imageBuffer!=NULL)
RelinquishOpenCLCommandQueue(clEnv, queue);
return(outputReady);
-}\r
-\r
-MagickExport MagickBooleanType AccelerateEqualizeImage(Image *image,\r
- const ChannelType channel,ExceptionInfo *exception)\r
-{\r
- MagickBooleanType\r
- status;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse) ||\r
- (checkHistogramCondition(image, channel) == MagickFalse))\r
- return(MagickFalse);\r
-\r
- status=ComputeEqualizeImage(image,channel,exception);\r
- return(status);\r
+}
+
+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 ComputeContrastStretchImageChannel(Image *image,\r
- const ChannelType channel,const double black_point,const double white_point, \r
- ExceptionInfo *exception) \r
-{\r
-#define ContrastStretchImageTag "ContrastStretch/Image"\r
-#define MaxRange(color) ((MagickRealType) ScaleQuantumToMap((Quantum) (color)))\r
-\r
- CacheView\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- cl_mem\r
- histogramBuffer,\r
- imageBuffer,\r
- stretchMapBuffer;\r
-\r
- cl_kernel\r
- histogramKernel,\r
- stretchKernel;\r
-\r
- cl_uint4\r
- *histogram;\r
-\r
- double\r
- intensity;\r
-\r
- FloatPixelPacket\r
- black,\r
- white;\r
-\r
- MagickBooleanType\r
- outputReady,\r
- status;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- PixelPacket\r
- *stretch_map;\r
-\r
- register ssize_t\r
- i;\r
-\r
- size_t\r
- global_work_size[2];\r
-\r
- void\r
- *hostPtr,\r
- *inputPixels;\r
-\r
- histogram=NULL;\r
- stretch_map=NULL;\r
- inputPixels = NULL;\r
- imageBuffer = NULL;\r
- histogramBuffer = NULL;\r
- stretchMapBuffer = NULL;\r
- histogramKernel = NULL; \r
- stretchKernel = NULL; \r
- context = NULL;\r
- queue = NULL;\r
- outputReady = MagickFalse;\r
-\r
-\r
- assert(image != (Image *) NULL);\r
- assert(image->signature == MagickSignature);\r
- if (image->debug != MagickFalse)\r
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);\r
-\r
- //exception=(&image->exception);\r
-\r
- /*\r
- * initialize opencl env\r
- */\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- /*\r
- Allocate and initialize histogram arrays.\r
- */\r
- histogram=(cl_uint4 *) AcquireQuantumMemory(MaxMap+1UL, sizeof(*histogram));\r
-\r
- if (histogram == (cl_uint4 *) NULL)\r
- ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed", image->filename);\r
- \r
- /* reset histogram */\r
- (void) ResetMagickMemory(histogram,0,(MaxMap+1)*sizeof(*histogram));\r
-\r
- /*\r
- if (IsGrayImage(image,exception) != MagickFalse)\r
- (void) SetImageColorspace(image,GRAYColorspace);\r
- */\r
-\r
- status=MagickTrue;\r
-\r
-\r
- /*\r
- Form histogram.\r
- */\r
- /* Create and initialize OpenCL buffers. */\r
- /* inputPixels = AcquirePixelCachePixels(image, &length, exception); */\r
- /* assume this will get a writable image */\r
- image_view=AcquireAuthenticCacheView(image,exception);\r
+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)
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(image_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
+ outputReady=SyncCacheViewAuthenticPixels(image_view,exception);
+
+cleanup:
+ OpenCLLogException(__FUNCTION__,__LINE__,exception);
+
image_view=DestroyCacheView(image_view);
if (imageBuffer!=NULL)
if (queue != NULL)
RelinquishOpenCLCommandQueue(clEnv, queue);
- return(outputReady);\r
-}\r
-\r
-MagickExport MagickBooleanType AccelerateContrastStretchImageChannel(\r
- Image *image,const ChannelType channel,const double black_point,\r
- const double white_point,ExceptionInfo *exception)\r
-{\r
- MagickBooleanType\r
- status;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse) ||\r
- (checkHistogramCondition(image, channel) == MagickFalse))\r
- return(MagickFalse);\r
-\r
- status=ComputeContrastStretchImageChannel(image,channel, black_point, white_point, exception);\r
- return(status);\r
+ 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);
}
/*
%
*/
-static Image *ComputeDespeckleImage(const Image *image,\r
- ExceptionInfo*exception)\r
-{\r
- static const int \r
- X[4] = {0, 1, 1,-1},\r
- Y[4] = {1, 0, 1, 1};\r
-\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- hullPass1,\r
- hullPass2;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- cl_mem\r
- filteredImageBuffer,\r
- imageBuffer,\r
- tempImageBuffer[2];\r
-\r
- const void\r
- *inputPixels;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- int\r
- k,\r
- matte;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- size_t\r
- global_work_size[2];\r
-\r
- unsigned int\r
- imageHeight,\r
- imageWidth;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- outputReady = MagickFalse;\r
- clEnv = NULL;\r
- inputPixels = NULL;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- filteredPixels = NULL;\r
- context = NULL;\r
- imageBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- hullPass1 = NULL;\r
- hullPass2 = NULL;\r
- queue = NULL;\r
- tempImageBuffer[0] = tempImageBuffer[1] = NULL;\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
- \r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
+ 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);
return(filteredImage);
}
-MagickExport Image *AccelerateDespeckleImage(const Image* image,\r
- ExceptionInfo* exception)\r
-{\r
- Image\r
- *filteredImage;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, AllChannels) == MagickFalse))\r
- return NULL;\r
-\r
- filteredImage=ComputeDespeckleImage(image,exception);\r
- return(filteredImage);\r
+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,\r
- const ChannelType channel,const NoiseType noise_type,\r
- ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- addNoiseKernel;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- cl_mem\r
- filteredImageBuffer,\r
- imageBuffer,\r
- randomNumberBuffer;\r
-\r
- const char\r
- *option;\r
-\r
- const void\r
- *inputPixels;\r
-\r
- float\r
- attenuate,\r
- *randomNumberBufferPtr;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- int\r
- i;\r
-\r
- RandomInfo\r
- **restrict random_info;\r
-\r
- size_t\r
- global_work_size[2];\r
-\r
- unsigned int\r
- inputColumns,\r
- inputRows,\r
- k,\r
- numRandomNumberPerBuffer,\r
- numRandomNumberPerPixel,\r
- numRowsPerKernelLaunch,\r
- r;\r
-\r
-#if defined(MAGICKCORE_OPENMP_SUPPORT)\r
- unsigned long\r
- key;\r
-#endif\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- outputReady = MagickFalse;\r
- clEnv = NULL;\r
- inputPixels = NULL;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- filteredPixels = NULL;\r
- randomNumberBufferPtr = NULL;\r
- context = NULL;\r
- imageBuffer = NULL;\r
- randomNumberBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- queue = NULL;\r
- addNoiseKernel = NULL;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
- \r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
+ 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);
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) \r
- filteredImage=DestroyImage(filteredImage);\r
-\r
+ if (outputReady == MagickFalse && filteredImage != NULL)
+ filteredImage=DestroyImage(filteredImage);
+
return(filteredImage);
}
-static Image *ComputeAddNoiseImageOptRandomNum(const Image*image,\r
- const ChannelType channel,const NoiseType noise_type,\r
- ExceptionInfo *exception) \r
-{\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- addNoiseKernel,\r
- randomNumberGeneratorKernel;\r
-\r
- cl_mem\r
- filteredImageBuffer,\r
- imageBuffer,\r
- randomNumberBuffer,\r
- randomNumberSeedsBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- const char\r
- *option;\r
-\r
- const void\r
- *inputPixels;\r
-\r
- float\r
- attenuate,\r
- fNormalize;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- int\r
- i;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- size_t\r
- global_work_size[2],\r
- random_work_size;\r
-\r
- unsigned int\r
- initRandom,\r
- inputColumns,\r
- inputRows,\r
- k,\r
- numRandomNumberGenerators,\r
- numRandomNumberPerBuffer,\r
- numRandomNumberPerPixel,\r
- numRowsPerKernelLaunch,\r
- r;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- outputReady = MagickFalse;\r
- clEnv = NULL;\r
- inputPixels = NULL;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- filteredPixels = NULL;\r
- context = NULL;\r
- imageBuffer = NULL;\r
- randomNumberBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- randomNumberSeedsBuffer = NULL;\r
- queue = NULL;\r
- addNoiseKernel = NULL;\r
- randomNumberGeneratorKernel = NULL;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
- \r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
+ 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);
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) \r
- filteredImage=DestroyImage(filteredImage);\r
-\r
+ if (outputReady == MagickFalse && filteredImage != NULL)
+ filteredImage=DestroyImage(filteredImage);
+
return(filteredImage);
}
-MagickExport Image *AccelerateAddNoiseImage(const Image *image,\r
- const ChannelType channel,const NoiseType noise_type,\r
- ExceptionInfo *exception) \r
-{\r
- Image\r
- *filteredImage;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse))\r
- return NULL;\r
-\r
-DisableMSCWarning(4127)\r
- if (sizeof(unsigned long) == 4)\r
-RestoreMSCWarning\r
- filteredImage = ComputeAddNoiseImageOptRandomNum(image,channel,noise_type,exception);\r
- else\r
- filteredImage = ComputeAddNoiseImage(image,channel,noise_type,exception);\r
- \r
- return(filteredImage);\r
+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,\r
- cl_command_queue queue,cl_mem imageBuffer,const unsigned int imageColumns,\r
- const unsigned int imageRows,cl_mem seedBuffer,\r
- const unsigned int numGenerators,ExceptionInfo *exception)\r
-{\r
- int\r
- k;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- randomImageKernel;\r
-\r
- MagickBooleanType\r
- status;\r
-\r
- size_t\r
- global_work_size,\r
- local_work_size;\r
-\r
+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");
cleanup:
if (randomImageKernel!=NULL) RelinquishOpenCLKernel(clEnv, randomImageKernel);
- return(status);\r
-}\r
-\r
-static MagickBooleanType ComputeRandomImage(Image* image,\r
- ExceptionInfo* exception)\r
-{\r
- CacheView\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- /* Don't release this buffer in this function !!! */\r
- cl_mem\r
- randomNumberSeedsBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- cl_mem \r
- imageBuffer;\r
-\r
- MagickBooleanType \r
- outputReady,\r
- status;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- void\r
- *inputPixels;\r
-\r
- status = MagickFalse;\r
- outputReady = MagickFalse;\r
- inputPixels = NULL;\r
- context = NULL;\r
- imageBuffer = NULL;\r
- queue = NULL;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
-\r
- /* Create and initialize OpenCL buffers. */\r
- image_view=AcquireAuthenticCacheView(image,exception);\r
+ 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)
{
(void) OpenCLThrowMagickException(exception, GetMagickModule(), ResourceLimitWarning, "Reading output image from CL buffer failed.", "'%s'", ".");
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(image_view,exception);\r
-\r
-cleanup:\r
- OpenCLLogException(__FUNCTION__,__LINE__,exception);\r
-\r
+ outputReady=SyncCacheViewAuthenticPixels(image_view,exception);
+
+cleanup:
+ OpenCLLogException(__FUNCTION__,__LINE__,exception);
+
image_view=DestroyCacheView(image_view);
UnlockRandSeedBuffer(clEnv);
return outputReady;
}
-MagickExport MagickBooleanType AccelerateRandomImage(Image *image,\r
- ExceptionInfo* exception)\r
-{\r
- MagickBooleanType\r
- status;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, AllChannels) == MagickFalse))\r
- return(MagickFalse);\r
-\r
- status=ComputeRandomImage(image,exception);\r
- return(status);\r
+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,\r
- const ChannelType channel,const double *kernel,const size_t width, \r
- const OffsetInfo *offset,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *filteredImage_view,\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_float4\r
- biasPixel;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- motionBlurKernel;\r
-\r
- cl_mem\r
- filteredImageBuffer,\r
- imageBuffer,\r
- imageKernelBuffer, \r
- offsetBuffer;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- const void\r
- *inputPixels;\r
-\r
- float\r
- *kernelBufferPtr;\r
-\r
- Image\r
- *filteredImage;\r
-\r
- int\r
- *offsetBufferPtr;\r
-\r
- MagickBooleanType\r
- outputReady;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- PixelInfo\r
- bias;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- size_t\r
- global_work_size[2],\r
- local_work_size[2];\r
-\r
- unsigned int\r
- i,\r
- imageHeight,\r
- imageWidth,\r
- matte;\r
-\r
- void\r
- *filteredPixels,\r
- *hostPtr;\r
-\r
- outputReady = MagickFalse;\r
- context = NULL;\r
- filteredImage = NULL;\r
- filteredImage_view = NULL;\r
- imageBuffer = NULL;\r
- filteredImageBuffer = NULL;\r
- imageKernelBuffer = NULL;\r
- motionBlurKernel = NULL;\r
- queue = NULL;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
-\r
- /* Create and initialize OpenCL buffers. */\r
-\r
- image_view=AcquireVirtualCacheView(image,exception);\r
+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)
{
ResourceLimitError, "CloneImage failed.", "'%s'", ".");
goto cleanup;
}
- filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);\r
+ filteredImage_view=AcquireAuthenticCacheView(filteredImage,exception);
filteredPixels=GetCacheViewAuthenticPixels(filteredImage_view,0,0,filteredImage->columns,filteredImage->rows,exception);
if (filteredPixels == (void *) NULL)
{
"Reading output image from CL buffer failed.", "'%s'", ".");
goto cleanup;
}
- outputReady=SyncCacheViewAuthenticPixels(filteredImage_view,exception);\r
-\r
-cleanup:\r
-\r
- image_view=DestroyCacheView(image_view);\r
- if (filteredImage_view != NULL)\r
+ 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);
if (imageKernelBuffer!=NULL) clEnv->library->clReleaseMemObject(imageKernelBuffer);
if (motionBlurKernel!=NULL) RelinquishOpenCLKernel(clEnv, motionBlurKernel);
if (queue != NULL) RelinquishOpenCLCommandQueue(clEnv, queue);
- if (outputReady == MagickFalse && filteredImage != NULL)\r
- filteredImage=DestroyImage(filteredImage);\r
-\r
+ if (outputReady == MagickFalse && filteredImage != NULL)
+ filteredImage=DestroyImage(filteredImage);
+
return(filteredImage);
}
-MagickExport Image *AccelerateMotionBlurImage(const Image *image,\r
- const ChannelType channel,const double* kernel,const size_t width,\r
- const OffsetInfo *offset,ExceptionInfo *exception)\r
-{\r
- Image\r
- *filteredImage;\r
-\r
- assert(image != NULL);\r
- assert(kernel != (double *) NULL);\r
- assert(offset != (OffsetInfo *) NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse))\r
- return NULL;\r
-\r
- filteredImage=ComputeMotionBlurImage(image, channel, kernel, width,\r
- offset, exception);\r
- return(filteredImage);\r
+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,\r
- cl_command_queue queue,cl_mem imageBuffer,const unsigned int inputWidth,\r
- const unsigned int inputHeight,const unsigned int matte,\r
- const ChannelType channel,const CompositeOperator compose,\r
- const cl_mem compositeImageBuffer,const unsigned int compositeWidth,\r
- const unsigned int compositeHeight,const float destination_dissolve,\r
- const float source_dissolve,ExceptionInfo *magick_unused(exception))\r
-{\r
- cl_int\r
- clStatus;\r
-\r
- cl_kernel\r
- compositeKernel;\r
-\r
- int\r
- k;\r
-\r
- size_t\r
- global_work_size[2],\r
- local_work_size[2];\r
-\r
- unsigned int\r
- composeOp;\r
-\r
+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,
RelinquishOpenCLKernel(clEnv, compositeKernel);
- return((clStatus==CL_SUCCESS) ? MagickTrue : MagickFalse);\r
-}\r
-\r
-static MagickBooleanType ComputeCompositeImage(Image *image,\r
- const ChannelType channel,const CompositeOperator compose,\r
- const Image *compositeImage,const ssize_t magick_unused(x_offset),\r
- const ssize_t magick_unused(y_offset),const float destination_dissolve,\r
- const float source_dissolve,ExceptionInfo *exception)\r
-{\r
- CacheView\r
- *image_view;\r
-\r
- cl_command_queue\r
- queue;\r
-\r
- cl_context\r
- context;\r
-\r
- cl_int\r
- clStatus;\r
-\r
- cl_mem_flags\r
- mem_flags;\r
-\r
- cl_mem\r
- compositeImageBuffer,\r
- imageBuffer;\r
-\r
- const void\r
- *composePixels;\r
-\r
- MagickBooleanType\r
- outputReady,\r
- status;\r
-\r
- MagickCLEnv\r
- clEnv;\r
-\r
- MagickSizeType\r
- length;\r
-\r
- void\r
- *inputPixels;\r
-\r
- magick_unreferenced(x_offset);\r
- magick_unreferenced(y_offset);\r
-\r
- status = MagickFalse;\r
- outputReady = MagickFalse;\r
- composePixels = NULL;\r
- imageBuffer = NULL;\r
- compositeImageBuffer = NULL;\r
-\r
- clEnv = GetDefaultOpenCLEnv();\r
- context = GetOpenCLContext(clEnv);\r
- queue = AcquireOpenCLCommandQueue(clEnv);\r
-\r
- /* Create and initialize OpenCL buffers. */\r
- image_view=AcquireAuthenticCacheView(image,exception);\r
+ 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)
{
length * sizeof(CLPixelPacket), inputPixels, 0, NULL, NULL);
}
if (clStatus==CL_SUCCESS)
- outputReady=SyncCacheViewAuthenticPixels(image_view,exception);\r
-\r
-cleanup:\r
-\r
- image_view=DestroyCacheView(image_view);\r
+ 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);\r
-}\r
-\r
-MagickExport MagickBooleanType AccelerateCompositeImage(Image *image,\r
- const ChannelType channel,const CompositeOperator compose,\r
- const Image *composite,const ssize_t x_offset,const ssize_t y_offset,\r
- const float destination_dissolve,const float source_dissolve,\r
- ExceptionInfo *exception)\r
-{\r
- MagickBooleanType\r
- status;\r
-\r
- assert(image != NULL);\r
- assert(exception != (ExceptionInfo *) NULL);\r
-\r
- if ((checkOpenCLEnvironment(exception) == MagickFalse) ||\r
- (checkAccelerateCondition(image, channel) == MagickFalse))\r
+ 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
projects / imagemagick / commitdiff