[gegl] Use CL_CHECK_ONLY for clReleaseMemObject calls

[Daniel Sabo <daniels src gnome org>]

commit e695cc3b87ec86d48a1a29a605aea02b26a3c45f
Author: Daniel Sabo <DanielSabo gmail com>
Date:   Sun Nov 3 14:54:13 2013 -0800

    Use CL_CHECK_ONLY for clReleaseMemObject calls
    
    CL_CHECK_ONLY prints the same error message as CL_CHECK but
    doesn't jump to the error label.

 gegl/opencl/gegl-cl.h                     |   18 +++++++++++++-
 operations/common/bilateral-filter-fast.c |    5 +--
 operations/common/c2g.c                   |   23 +++++++++++++-----
 operations/common/contrast-curve.c        |   35 ++++++++++++++++------------
 operations/common/dot.c                   |    4 +-
 operations/common/gaussian-blur.c         |   12 +++++++--
 operations/common/noise-hurl.c            |    4 +-
 operations/common/noise-reduction.c       |   13 ++++++++--
 operations/common/stretch-contrast.c      |    7 ++---
 9 files changed, 80 insertions(+), 41 deletions(-)
---
diff --git a/gegl/opencl/gegl-cl.h b/gegl/opencl/gegl-cl.h
index a81bd10..12e783b 100644
--- a/gegl/opencl/gegl-cl.h
+++ b/gegl/opencl/gegl-cl.h
@@ -26,8 +26,22 @@
 
 cl_int gegl_cl_set_kernel_args (cl_kernel kernel, ...) G_GNUC_NULL_TERMINATED;
 
-#define CL_ERROR {g_warning("Error in %s:%d %s - %s\n", __FILE__, __LINE__, __func__, 
gegl_cl_errstring(cl_err)); goto error;}
+#define CL_ERROR \
+{                                          \
+  g_warning ("Error in %s:%d %s - %s\n",   \
+             __FILE__, __LINE__, __func__, \
+             gegl_cl_errstring (cl_err));  \
+  goto error;                              \
+}
 
-#define CL_CHECK {if (cl_err != CL_SUCCESS) CL_ERROR;}
+#define CL_CHECK { if (cl_err != CL_SUCCESS) CL_ERROR; }
+
+#define CL_CHECK_ONLY(errcode) \
+if (errcode != CL_SUCCESS)                  \
+{                                           \
+  g_warning ("Error in %s:%d %s - %s\n",    \
+             __FILE__, __LINE__, __func__,  \
+             gegl_cl_errstring (errcode));  \
+}
 
 #endif
diff --git a/operations/common/bilateral-filter-fast.c b/operations/common/bilateral-filter-fast.c
index 6924839..d9458e8 100644
--- a/operations/common/bilateral-filter-fast.c
+++ b/operations/common/bilateral-filter-fast.c
@@ -404,14 +404,13 @@ cl_bilateral (cl_mem                in_tex,
   cl_err = gegl_clFinish (gegl_cl_get_command_queue ());
   CL_CHECK;
 
-  /* FIXME: These should just raise a warning instead of calling CL_CHECK */
   cl_err = gegl_clReleaseMemObject (grid);
-  CL_CHECK;
+  CL_CHECK_ONLY (cl_err);
 
   for(c = 0; c < 4; c++)
     {
       cl_err = gegl_clReleaseMemObject (blur[c]);
-      CL_CHECK;
+      CL_CHECK_ONLY (cl_err);
     }
 
   return FALSE;
diff --git a/operations/common/c2g.c b/operations/common/c2g.c
index 8d2b6c6..66438a8 100644
--- a/operations/common/c2g.c
+++ b/operations/common/c2g.c
@@ -177,7 +177,9 @@ cl_c2g (cl_mem                in_tex,
         gdouble               rgamma)
 {
   cl_int cl_err = 0;
-  cl_mem cl_lut_cos, cl_lut_sin, cl_radiuses;
+  cl_mem cl_lut_cos = NULL;
+  cl_mem cl_lut_sin = NULL;
+  cl_mem cl_radiuses = NULL;
   const size_t gbl_size[2] = {roi->width, roi->height};
 
   if (!cl_data)
@@ -240,16 +242,23 @@ cl_c2g (cl_mem                in_tex,
   cl_err = gegl_clFinish(gegl_cl_get_command_queue ());
   CL_CHECK;
 
-  cl_err = gegl_clReleaseMemObject(cl_radiuses);
-  CL_CHECK;
-  cl_err = gegl_clReleaseMemObject(cl_lut_cos);
-  CL_CHECK;
-  cl_err = gegl_clReleaseMemObject(cl_lut_sin);
-  CL_CHECK;
+  cl_err = gegl_clReleaseMemObject (cl_radiuses);
+  CL_CHECK_ONLY (cl_err);
+  cl_err = gegl_clReleaseMemObject (cl_lut_cos);
+  CL_CHECK_ONLY (cl_err);
+  cl_err = gegl_clReleaseMemObject (cl_lut_sin);
+  CL_CHECK_ONLY (cl_err);
 
   return FALSE;
 
 error:
+  if (cl_radiuses)
+    gegl_clReleaseMemObject (cl_radiuses);
+  if (cl_lut_cos)
+    gegl_clReleaseMemObject (cl_lut_cos);
+  if (cl_lut_sin)
+    gegl_clReleaseMemObject (cl_lut_sin);
+
   return TRUE;
 }
 
diff --git a/operations/common/contrast-curve.c b/operations/common/contrast-curve.c
index d015478..040cbde 100644
--- a/operations/common/contrast-curve.c
+++ b/operations/common/contrast-curve.c
@@ -72,20 +72,29 @@ cl_process (GeglOperation       *self,
   GeglChantO *o = GEGL_CHANT_PROPERTIES (self);
   gint       num_sampling_points;
   gdouble    *xs, *ys;
-  gfloat     *ysf;
-  cl_mem     cl_curve;
+  gfloat     *ysf = NULL;
+  cl_mem     cl_curve = NULL;
   cl_ulong   cl_max_constant_size;
   cl_int     cl_err = 0;
 
   num_sampling_points = o->sampling_points;
 
+  if (!cl_data)
+    {
+      const char *kernel_name[] = {"cl_contrast_curve",NULL};
+      cl_data = gegl_cl_compile_and_build (contrast_curve_cl_source,
+                                           kernel_name);
+    }
+  if (!cl_data)
+    return TRUE;
+
   if (num_sampling_points > 0)
     {
       xs = g_new (gdouble, num_sampling_points);
       ys = g_new (gdouble, num_sampling_points);
 
       gegl_curve_calc_values (o->curve, 0.0, 1.0, num_sampling_points, xs, ys);
-      g_free(xs);
+      g_free (xs);
 
       /*We need to downscale the array to pass it to the GPU*/
       ysf = g_new (gfloat, num_sampling_points);
@@ -104,15 +113,6 @@ cl_process (GeglOperation       *self,
 
       if (sizeof (cl_float) * num_sampling_points < cl_max_constant_size)
         {
-          if (!cl_data)
-            {
-              const char *kernel_name[] = {"cl_contrast_curve",NULL};
-              cl_data = gegl_cl_compile_and_build (contrast_curve_cl_source,
-                                                   kernel_name);
-            }
-          if (!cl_data)
-            return TRUE;
-
           cl_curve = gegl_clCreateBuffer (gegl_cl_get_context (),
                                           CL_MEM_USE_HOST_PTR | CL_MEM_READ_ONLY,
                                           num_sampling_points * sizeof (cl_float),
@@ -139,8 +139,8 @@ cl_process (GeglOperation       *self,
           cl_err = gegl_clFinish (gegl_cl_get_command_queue ());
           CL_CHECK;
 
-          cl_err= gegl_clReleaseMemObject (cl_curve);
-          CL_CHECK;
+          cl_err = gegl_clReleaseMemObject (cl_curve);
+          CL_CHECK_ONLY (cl_err);
         }
       else
         {
@@ -151,9 +151,14 @@ cl_process (GeglOperation       *self,
           return TRUE;
         }
 
-      g_free(ysf);
+      g_free (ysf);
       return FALSE;
 error:
+      if (ysf)
+        g_free (ysf);
+      if (cl_curve)
+        gegl_clReleaseMemObject (cl_curve);
+
       return TRUE;
     }
   else  /*If the curve doesn't have a lookup table is better to use CPU*/
diff --git a/operations/common/dot.c b/operations/common/dot.c
index d6070f0..f8f0bcb 100644
--- a/operations/common/dot.c
+++ b/operations/common/dot.c
@@ -76,7 +76,7 @@ cl_dot (cl_mem               in,
         gint                 size,
         gfloat               ratio)
 {
-  cl_int   cl_err        = 0;
+  cl_int cl_err        = 0;
   cl_mem block_colors  = NULL;
 
   if (!cl_data)
@@ -154,7 +154,7 @@ cl_dot (cl_mem               in,
   CL_CHECK;
 
   cl_err = gegl_clReleaseMemObject (block_colors);
-  CL_CHECK;
+  CL_CHECK_ONLY (cl_err);
   }
 
   return FALSE;
diff --git a/operations/common/gaussian-blur.c b/operations/common/gaussian-blur.c
index 007cb42..eb66b36 100644
--- a/operations/common/gaussian-blur.c
+++ b/operations/common/gaussian-blur.c
@@ -452,7 +452,8 @@ cl_gaussian_blur (cl_mem                in_tex,
 
   size_t global_ws[2];
 
-  cl_mem cl_matrix_x, cl_matrix_y;
+  cl_mem cl_matrix_x = NULL;
+  cl_mem cl_matrix_y = NULL;
 
   if (!cl_data)
     {
@@ -516,13 +517,18 @@ cl_gaussian_blur (cl_mem                in_tex,
   CL_CHECK;
 
   cl_err = gegl_clReleaseMemObject (cl_matrix_x);
-  CL_CHECK;
+  CL_CHECK_ONLY (cl_err);
   cl_err = gegl_clReleaseMemObject (cl_matrix_y);
-  CL_CHECK;
+  CL_CHECK_ONLY (cl_err);
 
   return FALSE;
 
 error:
+  if (cl_matrix_x)
+    gegl_clReleaseMemObject (cl_matrix_x);
+  if (cl_matrix_y)
+    gegl_clReleaseMemObject (cl_matrix_y);
+
   return TRUE;
 }
 
diff --git a/operations/common/noise-hurl.c b/operations/common/noise-hurl.c
index 5a50475..a8692dd 100644
--- a/operations/common/noise-hurl.c
+++ b/operations/common/noise-hurl.c
@@ -191,10 +191,10 @@ cl_process (GeglOperation       *operation,
   CL_CHECK;
 
   cl_err = gegl_clReleaseMemObject (cl_random_data);
-  CL_CHECK;
+  CL_CHECK_ONLY (cl_err);
 
   cl_err = gegl_clReleaseMemObject (cl_random_primes);
-  CL_CHECK;
+  CL_CHECK_ONLY (cl_err);
   }
 
   return  FALSE;
diff --git a/operations/common/noise-reduction.c b/operations/common/noise-reduction.c
index 8e66e2d..4f6b5bc 100644
--- a/operations/common/noise-reduction.c
+++ b/operations/common/noise-reduction.c
@@ -171,7 +171,8 @@ cl_noise_reduction (cl_mem                in_tex,
   cl_int n_src_stride  = roi->width + iterations * 2;
   cl_int cl_err = 0;
 
-  cl_mem temp_tex, tmptex;
+  cl_mem temp_tex = NULL;
+  cl_mem tmptex   = NULL;
 
   gint stride = 16; /*R'G'B'A float*/
 
@@ -239,12 +240,18 @@ cl_noise_reduction (cl_mem                in_tex,
   cl_err = gegl_clFinish(gegl_cl_get_command_queue());
   CL_CHECK;
 
-  if (tmptex) cl_err = gegl_clReleaseMemObject (tmptex);
-  CL_CHECK;
+  if (tmptex)
+    {
+      cl_err = gegl_clReleaseMemObject (tmptex);
+      CL_CHECK_ONLY (cl_err);
+    }
 
   return FALSE;
 
 error:
+  if (tmptex)
+    gegl_clReleaseMemObject (tmptex);
+
   return TRUE;
 }
 
diff --git a/operations/common/stretch-contrast.c b/operations/common/stretch-contrast.c
index 8f0b6b3..18b364d 100644
--- a/operations/common/stretch-contrast.c
+++ b/operations/common/stretch-contrast.c
@@ -234,15 +234,14 @@ cl_buffer_get_min_max (cl_mem               in_tex,
   *min = min_max_buf[0];
   *max = min_max_buf[1];
 
-
   cl_err = gegl_clReleaseMemObject (cl_aux_min);
-  CL_CHECK;
+  CL_CHECK_ONLY (cl_err);
 
   cl_err = gegl_clReleaseMemObject (cl_aux_max);
-  CL_CHECK;
+  CL_CHECK_ONLY (cl_err);
 
   cl_err = gegl_clReleaseMemObject (cl_min_max);
-  CL_CHECK;
+  CL_CHECK_ONLY (cl_err);
 
   return FALSE;