[FFmpeg-devel] libavfilter/unsharpen: patch fixes and resubmission

Titov, Alexey Alexey.Titov at amd.com
Tue Dec 23 22:26:04 CET 2014


Hi,

I've fixed the patch according to the reviewers suggestions. Attached are the two patches (original and fixes)

Regards,
Alexey

>From e94ea7add32791a1c9ac04dbd68b78cf799ca92d Mon Sep 17 00:00:00 2001
From: atitov <alexey.titov at amd.com>
Date: Wed, 17 Dec 2014 16:02:17 -0800
Subject: [PATCH 1/2] libavfilter: unsharpen opencl filter optimizations

---
libavfilter/unsharp.h               |   4 ++
libavfilter/unsharp_opencl.c        |  76 +++++++++++++++-------
libavfilter/unsharp_opencl_kernel.h | 122 ++++++++++++++++++++++++++----------
libavutil/opencl.c                  |  19 +++++-
4 files changed, 165 insertions(+), 56 deletions(-)

diff --git a/libavfilter/unsharp.h b/libavfilter/unsharp.h
index c2aed64..fc651c0 100644
--- a/libavfilter/unsharp.h
+++ b/libavfilter/unsharp.h
@@ -41,6 +41,10 @@ typedef struct {
     cl_kernel kernel_chroma;
     cl_mem cl_luma_mask;
     cl_mem cl_chroma_mask;
+    cl_mem cl_luma_mask_x;
+    cl_mem cl_chroma_mask_x;
+    cl_mem cl_luma_mask_y;
+    cl_mem cl_chroma_mask_y;
     int in_plane_size[8];
     int out_plane_size[8];
     int plane_num;
diff --git a/libavfilter/unsharp_opencl.c b/libavfilter/unsharp_opencl.c
index 5c6b5ef..a99fc5b 100644
--- a/libavfilter/unsharp_opencl.c
+++ b/libavfilter/unsharp_opencl.c
@@ -87,42 +87,36 @@ end:
     return ret;
}
-static int compute_mask_matrix(cl_mem cl_mask_matrix, int step_x, int step_y)
+static int copy_separable_masks(cl_mem cl_mask_x, cl_mem cl_mask_y, int step_x, int step_y)
{
-    int i, j, ret = 0;
-    uint32_t *mask_matrix, *mask_x, *mask_y;
-    size_t size_matrix = sizeof(uint32_t) * (2 * step_x + 1) * (2 * step_y + 1);
-    mask_x = av_mallocz_array(2 * step_x + 1, sizeof(uint32_t));
+    int ret = 0;
+    uint32_t *mask_x, *mask_y;
+    size_t size_mask_x = sizeof(uint32_t) * (2 * step_x + 1);
+    size_t size_mask_y = sizeof(uint32_t) * (2 * step_y + 1);
+    mask_x = av_mallocz_array(size_mask_x);
     if (!mask_x) {
         ret = AVERROR(ENOMEM);
         goto end;
     }
-    mask_y = av_mallocz_array(2 * step_y + 1, sizeof(uint32_t));
+    mask_y = av_mallocz_array(size_mask_y);
     if (!mask_y) {
         ret = AVERROR(ENOMEM);
         goto end;
     }
-    mask_matrix = av_mallocz(size_matrix);
-    if (!mask_matrix) {
-        ret = AVERROR(ENOMEM);
-        goto end;
-    }
+
     ret = compute_mask(step_x, mask_x);
     if (ret < 0)
         goto end;
     ret = compute_mask(step_y, mask_y);
     if (ret < 0)
         goto end;
-    for (j = 0; j < 2 * step_y + 1; j++) {
-        for (i = 0; i < 2 * step_x + 1; i++) {
-            mask_matrix[i + j * (2 * step_x + 1)] = mask_y[j] * mask_x[i];
-        }
-    }
-    ret = av_opencl_buffer_write(cl_mask_matrix, (uint8_t *)mask_matrix, size_matrix);
+
+    ret = av_opencl_buffer_write(cl_mask_x, (uint8_t *)mask_x, size_mask_x);
+    ret = av_opencl_buffer_write(cl_mask_y, (uint8_t *)mask_y, size_mask_y);
end:
     av_freep(&mask_x);
     av_freep(&mask_y);
-    av_freep(&mask_matrix);
+
     return ret;
}
@@ -133,6 +127,11 @@ static int generate_mask(AVFilterContext *ctx)
     cl_mem mask_matrix[2];
     mask_matrix[0] = unsharp->opencl_ctx.cl_luma_mask;
     mask_matrix[1] = unsharp->opencl_ctx.cl_chroma_mask;
+    cl_mem masks[4];
+    masks[0] = unsharp->opencl_ctx.cl_luma_mask_x;
+    masks[1] = unsharp->opencl_ctx.cl_luma_mask_y;
+    masks[2] = unsharp->opencl_ctx.cl_chroma_mask_x;
+    masks[3] = unsharp->opencl_ctx.cl_chroma_mask_y;
     step_x[0] = unsharp->luma.steps_x;
     step_x[1] = unsharp->chroma.steps_x;
     step_y[0] = unsharp->luma.steps_y;
@@ -144,12 +143,16 @@ static int generate_mask(AVFilterContext *ctx)
     else
        unsharp->opencl_ctx.use_fast_kernels = 1;
+    if (!masks[0] || !masks[1] || !masks[2] || !masks[3]) {
+        av_log(ctx, AV_LOG_ERROR, "Luma mask and chroma mask should not be NULL\n");
+        return AVERROR(EINVAL);
+    }
     if (!mask_matrix[0] || !mask_matrix[1]) {
         av_log(ctx, AV_LOG_ERROR, "Luma mask and chroma mask should not be NULL\n");
         return AVERROR(EINVAL);
     }
     for (i = 0; i < 2; i++) {
-        ret = compute_mask_matrix(mask_matrix[i], step_x[i], step_y[i]);
+        ret = copy_separable_masks(masks[2*i], masks[2*i+1], step_x[i], step_y[i]);
         if (ret < 0)
             return ret;
     }
@@ -184,7 +187,8 @@ int ff_opencl_apply_unsharp(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
         ret = avpriv_opencl_set_parameter(&kernel1,
                                       FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_inbuf),
                                       FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_outbuf),
-                                      FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_luma_mask),
+                                      FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_luma_mask_x),
+                                      FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_luma_mask_y),
                                       FF_OPENCL_PARAM_INFO(unsharp->luma.amount),
                                       FF_OPENCL_PARAM_INFO(unsharp->luma.scalebits),
                                       FF_OPENCL_PARAM_INFO(unsharp->luma.halfscale),
@@ -201,7 +205,8 @@ int ff_opencl_apply_unsharp(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
         ret = avpriv_opencl_set_parameter(&kernel2,
                                       FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_inbuf),
                                       FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_outbuf),
-                                      FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_chroma_mask),
+                                      FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_chroma_mask_x),
+                                      FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_chroma_mask_y),
                                       FF_OPENCL_PARAM_INFO(unsharp->chroma.amount),
                                       FF_OPENCL_PARAM_INFO(unsharp->chroma.scalebits),
                                       FF_OPENCL_PARAM_INFO(unsharp->chroma.halfscale),
@@ -264,7 +269,9 @@ int ff_opencl_apply_unsharp(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
             return AVERROR_EXTERNAL;
        }
     }
-    clFinish(unsharp->opencl_ctx.command_queue);
+    //blocking map is suffficient, no need for clFinish
+    //clFinish(unsharp->opencl_ctx.command_queue);
+
     return av_opencl_buffer_read_image(out->data, unsharp->opencl_ctx.out_plane_size,
                                        unsharp->opencl_ctx.plane_num, unsharp->opencl_ctx.cl_outbuf,
                                        unsharp->opencl_ctx.cl_outbuf_size);
@@ -286,6 +293,27 @@ int ff_opencl_unsharp_init(AVFilterContext *ctx)
     ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_chroma_mask,
                                   sizeof(uint32_t) * (2 * unsharp->chroma.steps_x + 1) * (2 * unsharp->chroma.steps_y + 1),
                                   CL_MEM_READ_ONLY, NULL);
+    // separable filters
+    if (ret < 0)
+        return ret;
+    ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_luma_mask_x,
+                                  sizeof(uint32_t) * (2 * unsharp->luma.steps_x + 1),
+                                  CL_MEM_READ_ONLY, NULL);
+    if (ret < 0)
+        return ret;
+    ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_luma_mask_y,
+                                  sizeof(uint32_t) * (2 * unsharp->luma.steps_y + 1),
+                                  CL_MEM_READ_ONLY, NULL);
+    if (ret < 0)
+        return ret;
+    ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_chroma_mask_x,
+                                  sizeof(uint32_t) * (2 * unsharp->chroma.steps_x + 1),
+                                  CL_MEM_READ_ONLY, NULL);
+    if (ret < 0)
+        return ret;
+    ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_chroma_mask_y,
+                                  sizeof(uint32_t) * (2 * unsharp->chroma.steps_y + 1),
+                                  CL_MEM_READ_ONLY, NULL);
     if (ret < 0)
         return ret;
     ret = generate_mask(ctx);
@@ -339,6 +367,10 @@ void ff_opencl_unsharp_uninit(AVFilterContext *ctx)
     av_opencl_buffer_release(&unsharp->opencl_ctx.cl_outbuf);
     av_opencl_buffer_release(&unsharp->opencl_ctx.cl_luma_mask);
     av_opencl_buffer_release(&unsharp->opencl_ctx.cl_chroma_mask);
+    av_opencl_buffer_release(&unsharp->opencl_ctx.cl_luma_mask_x);
+    av_opencl_buffer_release(&unsharp->opencl_ctx.cl_chroma_mask_x);
+    av_opencl_buffer_release(&unsharp->opencl_ctx.cl_luma_mask_y);
+    av_opencl_buffer_release(&unsharp->opencl_ctx.cl_chroma_mask_y);
     clReleaseKernel(unsharp->opencl_ctx.kernel_default);
     clReleaseKernel(unsharp->opencl_ctx.kernel_luma);
     clReleaseKernel(unsharp->opencl_ctx.kernel_chroma);
diff --git a/libavfilter/unsharp_opencl_kernel.h b/libavfilter/unsharp_opencl_kernel.h
index 9c4fd65..e013e2f 100644
--- a/libavfilter/unsharp_opencl_kernel.h
+++ b/libavfilter/unsharp_opencl_kernel.h
@@ -36,7 +36,8 @@ inline unsigned char clip_uint8(int a)
kernel void unsharp_luma(
                     global unsigned char *src,
                     global unsigned char *dst,
-                    global int *mask,
+                    global int *mask_x,
+                    global int *mask_y,
                     int amount,
                     int scalebits,
                     int halfscale,
@@ -59,10 +60,12 @@ kernel void unsharp_luma(
         return;
     }
-    local uchar l[32][32];
-    local int lc[LU_RADIUS_X*LU_RADIUS_Y];
+    local short l[32][32];
+    local int lcx[LU_RADIUS_X];
+    local int lcy[LU_RADIUS_Y];
     int indexIx, indexIy, i, j;
+    //load up tile: actual workspace + halo of 8 points in x and y \n
     for(i = 0; i <= 1; i++) {
         indexIy = -8 + (blockIdx.y + i) * 16 + threadIdx.y;
         indexIy = indexIy < 0 ? 0 : indexIy;
@@ -76,27 +79,54 @@ kernel void unsharp_luma(
    }
     int indexL = threadIdx.y*16 + threadIdx.x;
-    if (indexL < LU_RADIUS_X*LU_RADIUS_Y)
-        lc[indexL] = mask[indexL];
+    if (indexL < LU_RADIUS_X)
+        lcx[indexL] = mask_x[indexL];
+    if (indexL < LU_RADIUS_Y)
+        lcy[indexL] = mask_y[indexL];
     barrier(CLK_LOCAL_MEM_FENCE);
+    //needed for unsharp mask application in the end \n
+    int orig_value = (int)l[threadIdx.y + 8][threadIdx.x + 8];
+
     int idx, idy, maskIndex;
-    int sum = 0;
-    int steps_x = LU_RADIUS_X/2;
-    int steps_y = LU_RADIUS_Y/2;
+    int temp[2] = {0,0};
+    int steps_x = (LU_RADIUS_X-1)/2;
+    int steps_y = (LU_RADIUS_Y-1)/2;
-    \n#pragma unroll\n
-    for (i = -steps_y; i <= steps_y; i++) {
-        idy = 8 + i + threadIdx.y;
-        \n#pragma unroll\n
-        for (j = -steps_x; j <= steps_x; j++) {
-            idx = 8 + j + threadIdx.x;
-            maskIndex = (i + steps_y)*LU_RADIUS_X + j + steps_x;
-            sum += (int)l[idy][idx] * lc[maskIndex];
+    // compute the actual workspace + left&right halos \n
+      \n#pragma unroll\n
+    for (j = 0; j <=1; j++) {
+      //extra work to cover left and right halos \n
+      idx = 16*j + threadIdx.x;
+      \n#pragma unroll\n
+        for (i = -steps_y; i <= steps_y; i++) {
+          idy = 8 + i + threadIdx.y;
+          maskIndex = (i + steps_y);
+          temp[j] += (int)l[idy][idx] * lcy[maskIndex];
         }
     }
-    int temp = (int)l[threadIdx.y + 8][threadIdx.x + 8];
-    int res = temp + (((temp - (int)((sum + halfscale) >> scalebits)) * amount) >> 16);
+    barrier(CLK_LOCAL_MEM_FENCE);
+    //save results from the vertical filter in local memory \n
+    idy = 8 + threadIdx.y;
+      \n#pragma unroll\n
+    for (j = 0; j <=1; j++) {
+      idx = 16*j + threadIdx.x;
+      l[idy][idx] = temp[j];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    //compute results with the horizontal filter \n
+    int sum = 0;
+    idy = 8 + threadIdx.y;
+    \n#pragma unroll\n
+      for (j = -steps_x; j <= steps_x; j++) {
+        idx = 8 + j + threadIdx.x;
+        maskIndex = j + steps_x;
+        sum += (int)l[idy][idx] * lcx[maskIndex];
+      }
+
+    int res = orig_value + (((orig_value - (int)((sum + halfscale) >> scalebits)) * amount) >> 16);
+
     if (globalIdx.x < width && globalIdx.y < height)
         dst[globalIdx.x + globalIdx.y*dst_stride] = clip_uint8(res);
}
@@ -104,7 +134,8 @@ kernel void unsharp_luma(
kernel void unsharp_chroma(
                     global unsigned char *src_y,
                     global unsigned char *dst_y,
-                    global int *mask,
+                    global int *mask_x,
+                    global int *mask_y,
                     int amount,
                     int scalebits,
                     int halfscale,
@@ -141,8 +172,9 @@ kernel void unsharp_chroma(
         return;
     }
-    local uchar l[32][32];
-    local int lc[CH_RADIUS_X*CH_RADIUS_Y];
+    local ushort l[32][32];
+    local int lcx[CH_RADIUS_X];
+    local int lcy[CH_RADIUS_Y];
     int indexIx, indexIy, i, j;
     for(i = 0; i <= 1; i++) {
         indexIy = -8 + (blockIdx.y + i) * 16 + threadIdx.y;
@@ -157,27 +189,51 @@ kernel void unsharp_chroma(
     }
     int indexL = threadIdx.y*16 + threadIdx.x;
-    if (indexL < CH_RADIUS_X*CH_RADIUS_Y)
-        lc[indexL] = mask[indexL];
+    if (indexL < CH_RADIUS_X)
+        lcx[indexL] = mask_x[indexL];
+    if (indexL < CH_RADIUS_Y)
+        lcy[indexL] = mask_y[indexL];
     barrier(CLK_LOCAL_MEM_FENCE);
+    int orig_value = (int)l[threadIdx.y + 8][threadIdx.x + 8];
+
     int idx, idy, maskIndex;
-    int sum = 0;
     int steps_x = CH_RADIUS_X/2;
     int steps_y = CH_RADIUS_Y/2;
+    int temp[2] = {0,0};
     \n#pragma unroll\n
-    for (i = -steps_y; i <= steps_y; i++) {
-        idy = 8 + i + threadIdx.y;
+      for (j = 0; j <= 1; j++) {
+        idx = 16*j + threadIdx.x;
         \n#pragma unroll\n
-        for (j = -steps_x; j <= steps_x; j++) {
-            idx = 8 + j + threadIdx.x;
-            maskIndex = (i + steps_y)*CH_RADIUS_X + j + steps_x;
-            sum += (int)l[idy][idx] * lc[maskIndex];
-        }
+          for (i = -steps_y; i <= steps_y; i++) {
+            idy = 8 + i + threadIdx.y;
+            maskIndex = i + steps_y;
+            temp[j] += (int)l[idy][idx] * lcy[maskIndex];
+          }
+      }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+    idy = 8 + threadIdx.y;
+    \n#pragma unroll\n
+    for (j = 0; j <= 1; j++) {
+      idx = 16*j + threadIdx.x;
+      l[idy][idx] = temp[j];
     }
-    int temp = (int)l[threadIdx.y + 8][threadIdx.x + 8];
-    int res = temp + (((temp - (int)((sum + halfscale) >> scalebits)) * amount) >> 16);
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    //compute results with the horizontal filter \n
+    int sum = 0;
+    idy = 8 + threadIdx.y;
+    \n#pragma unroll\n
+      for (j = -steps_x; j <= steps_x; j++) {
+        idx = 8 + j + threadIdx.x;
+        maskIndex = j + steps_x;
+        sum += (int)l[idy][idx] * lcx[maskIndex];
+      }
+
+    int res = orig_value + (((orig_value - (int)((sum + halfscale) >> scalebits)) * amount) >> 16);
+
     if (globalIdx.x < cw && globalIdx.y < ch)
         dst[globalIdx.x + globalIdx.y*dst_stride_ch] = clip_uint8(res);
}
diff --git a/libavutil/opencl.c b/libavutil/opencl.c
index 36cb6fe..738d0db 100644
--- a/libavutil/opencl.c
+++ b/libavutil/opencl.c
@@ -450,7 +450,24 @@ cl_program av_opencl_compile(const char *program_name, const char *build_opts)
     status = clBuildProgram(program, 1, &(opencl_ctx.device_id), build_opts, NULL, NULL);
     if (status != CL_SUCCESS) {
         av_log(&opencl_ctx, AV_LOG_ERROR,
-               "Compilation failed with OpenCL program: %s\n", program_name);
+            "Compilation failed with OpenCL program: '%s' with error %d \n", program_name, status);
+
+        // Determine the size of the log
+        size_t log_size;
+        clGetProgramBuildInfo(program, &(opencl_ctx.device_id), CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
+
+        // Allocate memory for the log
+        char *log = (char *) malloc(log_size+1);
+
+        // Get the log
+        clGetProgramBuildInfo(program, &(opencl_ctx.device_id), CL_PROGRAM_BUILD_LOG, log_size, log, NULL);
+        log[log_size] = '\0';
+        printf("--- Build log ---\n ");
+        // Print the log
+        printf("%s\n", log);
+        printf("--- End Build log ---\n ");
+
+        free(log);
         program = NULL;
         goto end;
     }
--
1.8.4.msysgit.0








>From 72f4e48f3adf06fd859abc4aecede4e15a36e9d9 Mon Sep 17 00:00:00 2001
From: atitov <alexey.titov at amd.com>
Date: Tue, 23 Dec 2014 13:16:35 -0800
Subject: [PATCH 2/2] Fixed the patch according to the suggestions

build log is now capped and is using av_log, other issues are fixed
---
libavfilter/unsharp_opencl.c        | 11 ++++++-----
libavfilter/unsharp_opencl_kernel.h |  2 +-
libavutil/opencl.c                  | 29 +++++++++++++++++------------
libavutil/opencl.h                  |  2 ++
4 files changed, 26 insertions(+), 18 deletions(-)

diff --git a/libavfilter/unsharp_opencl.c b/libavfilter/unsharp_opencl.c
index a99fc5b..4adad63 100644
--- a/libavfilter/unsharp_opencl.c
+++ b/libavfilter/unsharp_opencl.c
@@ -93,12 +93,12 @@ static int copy_separable_masks(cl_mem cl_mask_x, cl_mem cl_mask_y, int step_x,
     uint32_t *mask_x, *mask_y;
     size_t size_mask_x = sizeof(uint32_t) * (2 * step_x + 1);
     size_t size_mask_y = sizeof(uint32_t) * (2 * step_y + 1);
-    mask_x = av_mallocz_array(size_mask_x);
+    mask_x = av_mallocz_array((2 * step_x + 1), sizeof(uint32_t));
     if (!mask_x) {
         ret = AVERROR(ENOMEM);
         goto end;
     }
-    mask_y = av_mallocz_array(size_mask_y);
+    mask_y = av_mallocz_array((2 * step_y + 1), sizeof(uint32_t));
     if (!mask_y) {
         ret = AVERROR(ENOMEM);
         goto end;
@@ -122,12 +122,13 @@ end:
 static int generate_mask(AVFilterContext *ctx)
{
-    UnsharpContext *unsharp = ctx->priv;
-    int i, ret = 0, step_x[2], step_y[2];
+    cl_mem masks[4];
     cl_mem mask_matrix[2];
+    int i, ret = 0, step_x[2], step_y[2];
+
+    UnsharpContext *unsharp = ctx->priv;
     mask_matrix[0] = unsharp->opencl_ctx.cl_luma_mask;
     mask_matrix[1] = unsharp->opencl_ctx.cl_chroma_mask;
-    cl_mem masks[4];
     masks[0] = unsharp->opencl_ctx.cl_luma_mask_x;
     masks[1] = unsharp->opencl_ctx.cl_luma_mask_y;
     masks[2] = unsharp->opencl_ctx.cl_chroma_mask_x;
diff --git a/libavfilter/unsharp_opencl_kernel.h b/libavfilter/unsharp_opencl_kernel.h
index e013e2f..0fc802e 100644
--- a/libavfilter/unsharp_opencl_kernel.h
+++ b/libavfilter/unsharp_opencl_kernel.h
@@ -89,7 +89,7 @@ kernel void unsharp_luma(
     int orig_value = (int)l[threadIdx.y + 8][threadIdx.x + 8];
     int idx, idy, maskIndex;
-    int temp[2] = {0,0};
+    int temp[2] = {0};
     int steps_x = (LU_RADIUS_X-1)/2;
     int steps_y = (LU_RADIUS_Y-1)/2;
diff --git a/libavutil/opencl.c b/libavutil/opencl.c
index 738d0db..3cd2bf8 100644
--- a/libavutil/opencl.c
+++ b/libavutil/opencl.c
@@ -449,27 +449,32 @@ cl_program av_opencl_compile(const char *program_name, const char *build_opts)
     }
     status = clBuildProgram(program, 1, &(opencl_ctx.device_id), build_opts, NULL, NULL);
     if (status != CL_SUCCESS) {
+        size_t log_size;
+        char *log;
         av_log(&opencl_ctx, AV_LOG_ERROR,
             "Compilation failed with OpenCL program: '%s' with error %d \n", program_name, status);
         // Determine the size of the log
-        size_t log_size;
-        clGetProgramBuildInfo(program, &(opencl_ctx.device_id), CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
+        clGetProgramBuildInfo(program, opencl_ctx.device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
-        // Allocate memory for the log
-        char *log = (char *) malloc(log_size+1);
+        if( log_size <= AV_OPENCL_MAX_PROG_BUILD_LOG_SIZE) {
-        // Get the log
-        clGetProgramBuildInfo(program, &(opencl_ctx.device_id), CL_PROGRAM_BUILD_LOG, log_size, log, NULL);
-        log[log_size] = '\0';
-        printf("--- Build log ---\n ");
-        // Print the log
-        printf("%s\n", log);
-        printf("--- End Build log ---\n ");
+          // Allocate memory for the log
+          log = av_malloc(log_size+1);
-        free(log);
+          // Get the log
+          clGetProgramBuildInfo(program, opencl_ctx.device_id, CL_PROGRAM_BUILD_LOG, log_size, log, NULL);
+          log[log_size] = '\0';
+          // Print the log
+          av_log(NULL, AV_LOG_ERROR, "--- Build log ---\n");
+          av_log(NULL, AV_LOG_ERROR, "%s\n", log);
+          av_log(NULL, AV_LOG_ERROR, "--- End Build log ---\n ");
+
+          av_free(log);
+        }
         program = NULL;
         goto end;
+
     }
     opencl_ctx.kernel_code[kernel_code_idx].is_compiled = 1;
diff --git a/libavutil/opencl.h b/libavutil/opencl.h
index 4655cba..c2c327e 100644
--- a/libavutil/opencl.h
+++ b/libavutil/opencl.h
@@ -51,6 +51,8 @@
 #define AV_OPENCL_MAX_PLATFORM_NAME_SIZE 100
+#define AV_OPENCL_MAX_PROG_BUILD_LOG_SIZE 1000
+
typedef struct {
     int device_type;
     char device_name[AV_OPENCL_MAX_DEVICE_NAME_SIZE];
--
1.8.4.msysgit.0


More information about the ffmpeg-devel mailing list