From: Andrey Klimenko Date: Mon, 3 Aug 2015 13:34:36 +0000 (+0300) Subject: removed usage of non-public api: image_util_resize() and image_util_convert_colorspace() X-Git-Tag: tizen_3.0/TD_SYNC/20161201~625^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a8b2519772b14ba1f80d89817973175d36079416;p=sdk%2Fonline-doc.git removed usage of non-public api: image_util_resize() and image_util_convert_colorspace() Change-Id: I6c12c9a22303186c0787e25e0ccbc524b404a67e Signed-off-by: Andrey Klimenko --- diff --git a/org.tizen.sampledescriptions/html/mobile_n/mediaapp_sd_mn.htm b/org.tizen.sampledescriptions/html/mobile_n/mediaapp_sd_mn.htm index 30fda63..3581368 100644 --- a/org.tizen.sampledescriptions/html/mobile_n/mediaapp_sd_mn.htm +++ b/org.tizen.sampledescriptions/html/mobile_n/mediaapp_sd_mn.htm @@ -120,6 +120,92 @@ static void _update_scale(image_viewer_view *view)

This view allows the user to transform a source image into a new image with a different pixel format and size. Internally, when the Change pixel format button is clicked, the _change_format callback is called and the _process method executed:

+int image_sample_util_resize(const int src_w, const int src_h, const uchar *src, const int dest_w, const int dest_h,  uchar *dest)
+{
+   if (src_w <= 0 || src_h <= 0 || !src || dest_w <= 0 || dest_h <= 0 || !dest)
+   {
+      return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
+   }
+
+   int h = 0, w = 0;
+   float t, u, coef;
+   t = u = coef = 0.0;
+   float c1, c2, c3, c4;
+   c1 = c2 = c3 = c4 = 0.0;
+   u_int32_t pixel1, pixel2, pixel3, pixel4;
+   pixel1 = pixel2 = pixel3 = pixel4 = 0;
+   u_int32_t *pixel_res = NULL;
+   u_int32_t red, green, blue, alpha;
+   red = green = blue = alpha = 0;
+
+   int i = 0, j = 0;
+   for (j = 0; j < dest_h; j++)
+   {
+      coef = (float) (j) / (float) (dest_h - 1) * (src_h - 1);
+      h = (int) floor(coef);
+      if (h < 0)
+      {
+         h = 0;
+      }
+      else
+      {
+         if (h >= src_h - 1)
+         {
+            h = src_h - 2;
+         }
+      }
+      u = coef - h;
+
+      for (i = 0; i < dest_w; i++)
+      {
+         coef = (float) (i) / (float) (dest_w - 1) * (src_w - 1);
+         w = (int) floor(coef);
+         if (w < 0)
+         {
+            w = 0;
+         }
+         else
+         {
+            if (w >= src_w - 1)
+            {
+               w = src_w - 2;
+            }
+         }
+         t = coef - w;
+
+         c1 = (1 - t) * (1 - u);
+         c2 = t * (1 - u);
+         c3 = t * u;
+         c4 = (1 - t) * u;
+
+         pixel1 = *((u_int32_t*) (src + BRGA_BPP * (h * src_w + w)));
+         pixel2 = *((u_int32_t*) (src + BRGA_BPP * (h * src_w + w + 1)));
+         pixel3 = *((u_int32_t*) (src + BRGA_BPP * ((h + 1) * src_w + w + 1)));
+         pixel4 = *((u_int32_t*) (src + BRGA_BPP * ((h + 1) * src_w + w)));
+
+         blue = (uchar) pixel1 * c1 + (uchar) pixel2 * c2
+            + (uchar) pixel3 * c3 + (uchar) pixel4 * c4;
+         green = (uchar) (pixel1 >> 8) * c1
+            + (uchar) (pixel2 >> 8) * c2
+            + (uchar) (pixel3 >> 8) * c3
+            + (uchar) (pixel4 >> 8) * c4;
+         red = (uchar) (pixel1 >> 16) * c1
+            + (uchar) (pixel2 >> 16) * c2
+            + (uchar) (pixel3 >> 16) * c3
+            + (uchar) (pixel4 >> 16) * c4;
+         alpha = (uchar) (pixel1 >> 24) * c1
+            + (uchar) (pixel2 >> 24) * c2
+            + (uchar) (pixel3 >> 24) * c3
+            + (uchar) (pixel4 >> 24) * c4;
+
+         pixel_res = (u_int32_t*)(dest + BRGA_BPP * (i + j * dest_w));
+         *pixel_res = ((u_int32_t) alpha << 24) | ((u_int32_t) red << 16)
+            | ((u_int32_t) green << 8) | (blue);
+      }
+   }
+   return IMAGE_UTIL_ERROR_NONE;
+}
+
 static bool _process(image_converter_view *view, double scale)
 {
    RETVM_IF(NULL == view, false, "view is NULL");
@@ -148,7 +234,7 @@ static bool _process(image_converter_view *view, double scale)
    dest_buff = malloc(dest_size);
    RETVM_IF(NULL == dest_buff, false, "malloc destination buffer error %d", dest_size);
 
-   error = image_util_resize(dest_buff, &dest_width , &dest_height, src_buff, w, h, IMAGE_UTIL_COLORSPACE_BGRA8888);
+   error = image_sample_util_resize(w, h, src_buff, dest_width , dest_height, dest_buff);
    if (IMAGE_UTIL_ERROR_NONE == error)
    {
       Evas_Object* im = evas_object_image_filled_add(evas_object_evas_get(view->layout));
@@ -176,7 +262,7 @@ static bool _process(image_converter_view *view, double scale)
    }
    else
    {
-      INF("Image buffer manipulation: image_util_resize error");
+      INF("Image buffer manipulation: image_sample_util_resize error");
       result = false;
    }
    free(dest_buff);
@@ -319,6 +405,402 @@ static bool _process_colorspace_convert(color_converter_view *view)
 
This view allows the user to extract frames from the input video stream. Internally, when the frame slider is changed, the _sliderbar_changed_cb callback is called and the frame_extractor_frame_get method is executed:

 
 
+static inline rgb16 bgra_to_rgb(const bgra32 src)
+{
+   rgb16 result = (rgb16)
+      ( ((src.r >> (RGB32_CHANEL_BIT_SIZE - RGB16_R_SIZE)) << RGB16_R_SHIFT)
+      | ((src.g >> (RGB32_CHANEL_BIT_SIZE - RGB16_G_SIZE)) << RGB16_G_SHIFT)
+      | ((src.b >> (RGB32_CHANEL_BIT_SIZE - RGB16_B_SIZE)) << RGB16_B_SHIFT));
+   return result;
+}
+
+static inline bgra32 rgb_to_bgra(const rgb16 src)
+{
+   bgra32 result = {};
+   result.r = (uchar)( src >> RGB16_R_SHIFT) << (RGB32_CHANEL_BIT_SIZE - RGB16_R_SIZE);
+   result.g = (uchar)( src >> RGB16_G_SHIFT) << (RGB32_CHANEL_BIT_SIZE - RGB16_G_SIZE);
+   result.b = (uchar)( src >> RGB16_B_SHIFT) << (RGB32_CHANEL_BIT_SIZE - RGB16_B_SIZE);
+   result.a = RGB32_DEFAULT_ALPHA;
+   return result;
+}
+
+static uchar clamp(int x)
+{
+   if (x > 255)
+   {
+      x = 255;
+   }
+   else if (x < 0)
+   {
+      x = 0;
+   }
+   return x;
+}
+
+static inline uchar bgra_to_yuv_y(const bgra32 src)
+{
+   return ((66*src.r + 129*src.g + 25*src.b) >> 8) + 16;
+}
+
+static inline uchar bgra_to_yuv_u(const bgra32 src)
+{
+   return ((-38*src.r + -74*src.g + 112*src.b) >> 8) + 128;
+}
+
+static inline uchar bgra_to_yuv_v(const bgra32 src)
+{
+   return ((112*src.r + -94*src.g + -18*src.b) >> 8) + 128;
+}
+
+static inline uchar yuv_to_r(const uchar yuv_y, const uchar yuv_u, const uchar yuv_v)
+{
+   return clamp(yuv_y + 1.402 * (yuv_v - 128));
+}
+
+static inline uchar yuv_to_g(const uchar yuv_y, const uchar yuv_u, const uchar yuv_v)
+{
+   return clamp(yuv_y - 0.344 * (yuv_u - 128) - 0.714 * (yuv_v - 128));
+}
+
+static inline uchar yuv_to_b(const uchar yuv_y, const uchar yuv_u, const uchar yuv_v)
+{
+   return clamp(yuv_y + 1.772 * (yuv_u - 128));
+}
+
+static void _convert_bgra8888_to_yuv420( uchar *dest, const uchar *src,
+            const int width, const int height,
+            const int d_size, const int s_size)
+{
+   unsigned int src_stride = (s_size / height);
+   unsigned int pix_count = width * height;
+   unsigned int upos = pix_count;
+   unsigned int vpos = upos + upos / 4;
+
+   unsigned int y;
+   for (y = 0; y < height; ++y )
+   {
+      const bgra32* src_pixel = (const bgra32*) &(src[y * src_stride]);
+      unsigned int dest_line_pos = width * y;
+
+      if( !(y % 2) )
+      {
+         unsigned int x;
+         for (x = 0; x < width; x += 2 )
+         {
+            bgra32 pixel = src_pixel[x];
+
+            dest[dest_line_pos + x] = bgra_to_yuv_y(pixel);
+            dest[upos++] = bgra_to_yuv_u(pixel);
+            dest[vpos++] = bgra_to_yuv_v(pixel);
+
+            pixel = src_pixel[x + 1];
+            dest[dest_line_pos + x + 1] = bgra_to_yuv_y(pixel);
+         }
+      }
+      else
+      {
+         unsigned int x;
+         for (x = 0; x < width; ++x)
+         {
+            dest[dest_line_pos + x] = bgra_to_yuv_y( src_pixel[x] );
+         }
+      }
+   }
+}
+
+static void _convert_bgra8888_to_rgb565( uchar *dest, const uchar *src,
+            const int width, const int height,
+            const int d_size, const int s_size)
+{
+   unsigned int src_stride = (s_size / height);
+   unsigned int dest_stride = (d_size / height);
+
+   unsigned int y;
+   for (y = 0; y < height; ++y)
+   {
+      const bgra32* src_pixel = (const bgra32*) &(src[y * src_stride]);
+      rgb16* dest_pixel = (rgb16*) &(dest[y * dest_stride]);
+      unsigned int x;
+      for (x = 0; x < width; ++x)
+      {
+         dest_pixel[x] = bgra_to_rgb( src_pixel[x]);
+      }
+   }
+}
+
+static void _convert_rgb565_to_yuv420( uchar *dest, const uchar *src,
+            const int width, const int height,
+            const int d_size, const int s_size)
+{
+   unsigned int src_stride = (s_size / height);
+   unsigned int pix_count = width * height;
+   unsigned int upos = pix_count;
+   unsigned int vpos = upos + upos / 4;
+
+   unsigned int y;
+   for (y = 0; y < height; ++y )
+   {
+      const rgb16* src_pixel = (const rgb16*) &(src[y * src_stride]);
+      unsigned int dest_line_pos = width * y;
+
+   if ( !(y % 2) )
+   {
+      unsigned int x;
+      for (x = 0; x < width; x += 2 )
+      {
+         bgra32 pixel = rgb_to_bgra(src_pixel[x]);
+
+         dest[dest_line_pos + x] = bgra_to_yuv_y(pixel);
+         dest[upos++] = bgra_to_yuv_u(pixel);
+         dest[vpos++] = bgra_to_yuv_v(pixel);
+
+         pixel = rgb_to_bgra(src_pixel[x + 1]);
+         dest[dest_line_pos + x + 1] = bgra_to_yuv_y(pixel);
+      }
+   }
+   else
+   {
+      unsigned int x;
+      for (x = 0; x < width; ++x)
+      {
+         bgra32 pixel = rgb_to_bgra(src_pixel[x]);
+         dest[dest_line_pos + x] = bgra_to_yuv_y(pixel);
+      }
+   }
+   }
+}
+
+static void _convert_rgb565_to_bgra8888( uchar *dest, const uchar *src,
+            const int width, const int height,
+            const int d_size, const int s_size)
+{
+   unsigned int src_stride = (s_size / height);
+   unsigned int dest_stride = (d_size / height);
+
+   unsigned int y;
+   for (y = 0; y < height; ++y)
+   {
+      const rgb16* src_pixel = (const rgb16*) &(src[y * src_stride]);
+      bgra32* dest_pixel = (bgra32*) &(dest[y * dest_stride]);
+      unsigned int x;
+      for (x = 0; x < width; ++x)
+      {
+         dest_pixel[x] = rgb_to_bgra( src_pixel[x]);
+      }
+   }
+}
+
+static void _convert_yuv420_to_rgb565( uchar *dest, const uchar *src,
+            const int width, const int height,
+            const int d_size, const int s_size)
+{
+   unsigned int pix_count = width * height;
+   unsigned int dest_stride = (d_size / height);
+
+   unsigned int y;
+   for (y = 0; y < height; y++)
+   {
+      rgb16* dest_pixel = (rgb16*) &(dest[y*dest_stride]);
+      unsigned int x;
+      for (x = 0; x < width; x++)
+      {
+         uchar yuv_y = src[ y*width + x];
+         uchar yuv_u = src[ (int)(pix_count + (y/2)*(width/2)  + x/2)];
+         uchar yuv_v = src[ (int)(pix_count*1.25 + (y/2)*(width/2) + x/2)];
+
+         dest_pixel[x] =
+            ( ( yuv_to_r(yuv_y, yuv_u, yuv_v) >> (RGB32_CHANEL_BIT_SIZE - RGB16_R_SIZE)) << RGB16_R_SHIFT)
+            | ((yuv_to_g(yuv_y, yuv_u, yuv_v) >> (RGB32_CHANEL_BIT_SIZE - RGB16_G_SIZE)) << RGB16_G_SHIFT)
+            | ((yuv_to_b(yuv_y, yuv_u, yuv_v) >> (RGB32_CHANEL_BIT_SIZE - RGB16_B_SIZE)) << RGB16_B_SHIFT);
+      }
+   }
+}
+
+static void _convert_yuv420_to_bgra8888( uchar *dest, const uchar *src,
+            const int width, const int height,
+            const int d_size, const int s_size)
+{
+   unsigned int pix_count = width * height;
+   unsigned int dest_stride = (d_size / height);
+
+   unsigned int y;
+   for (y = 0; y < height; y++)
+   {
+      bgra32* dest_pixel = (bgra32*) &(dest[dest_stride * y]);
+      unsigned int x;
+      for (x = 0; x < width; x++)
+      {
+         uchar yuv_y = src[ y*width + x];
+         uchar yuv_u = src[ (int)(pix_count + (y/2)*(width/2)  + x/2)];
+         uchar yuv_v = src[ (int)(pix_count*1.25 + (y/2)*(width/2) + x/2)];
+
+         dest_pixel[x].r = yuv_to_r(yuv_y, yuv_u, yuv_v);
+         dest_pixel[x].g = yuv_to_g(yuv_y, yuv_u, yuv_v);
+         dest_pixel[x].b = yuv_to_b(yuv_y, yuv_u, yuv_v);
+         dest_pixel[x].a = RGB32_DEFAULT_ALPHA;
+      }
+   }
+}
+
+static void _convert_yuv422_to_bgra8888( uchar *dest, const uchar *src,
+            const int width, const int height,
+            const int d_size, const int s_size)
+{
+   unsigned int dest_stride = (d_size / height);
+   uchar yuv_u, yuv_v, yuv_y1, yuv_y2;
+   yuv_u = yuv_v = yuv_y1 = yuv_y2 = 0;
+   unsigned int y;
+   for (y = 0; y < height; y++)
+   {
+      bgra32* dest_pixel = (bgra32*) &(dest[dest_stride * y]);
+      const uchar * src_line = &(src[2 * y * width]);
+      unsigned int x;
+      for (x = 0; x < width; x += 2)
+      {
+         yuv_y1 = src_line[2 * x + 1];
+         yuv_y2 = src_line[2 * x + 3];
+         yuv_u = src_line[2 * x];
+         yuv_v = src_line[2 * x + 2];
+
+         dest_pixel[x].r = yuv_to_r(yuv_y1, yuv_u, yuv_v);
+         dest_pixel[x].g = yuv_to_g(yuv_y1, yuv_u, yuv_v);
+         dest_pixel[x].b = yuv_to_b(yuv_y1, yuv_u, yuv_v);
+         dest_pixel[x].a = RGB32_DEFAULT_ALPHA;
+
+         dest_pixel[x + 1].r = yuv_to_r(yuv_y2, yuv_u, yuv_v);
+         dest_pixel[x + 1].g = yuv_to_g(yuv_y2, yuv_u, yuv_v);
+         dest_pixel[x + 1].b = yuv_to_b(yuv_y2, yuv_u, yuv_v);
+         dest_pixel[x + 1].a = RGB32_DEFAULT_ALPHA;
+      }
+   }
+}
+
+static void _convert_rgb888_to_bgra8888( uchar *dest, const uchar *src,
+            const int width, const int height,
+            const int d_size, const int s_size)
+{
+   unsigned int src_stride = (s_size / height);
+   unsigned int dest_stride = (d_size / height);
+
+   unsigned int y;
+   for (y = 0; y < height; ++y)
+   {
+      const uchar* src_pixel = &(src[y * src_stride]);
+      bgra32* dest_pixel = (bgra32*) &(dest[y * dest_stride]);
+      unsigned int x;
+      for (x = 0; x < width; ++x)
+      {
+         dest_pixel[x].r = src_pixel[RGB24_BPP * x];
+         dest_pixel[x].g = src_pixel[RGB24_BPP * x + 1];
+         dest_pixel[x].b = src_pixel[RGB24_BPP * x + 2];
+         dest_pixel[x].a = RGB32_DEFAULT_ALPHA;
+      }
+   }
+}
+
+int image_sample_util_convert_colorspace( uchar *dest , image_util_colorspace_e dest_colorspace,
+            const uchar *src , int width, int height,
+            image_util_colorspace_e src_colorspace)
+{
+   RETVM_IF(NULL == src, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "source buffer in NULL");
+   RETVM_IF(NULL == dest, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "destination buffer in NULL");
+   RETVM_IF(width <= 0 || height <= 0, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "width or heightis incorrect");
+   int error = IMAGE_UTIL_ERROR_NONE;
+
+
+   if (IMAGE_UTIL_COLORSPACE_BGRA8888 != src_colorspace
+      && IMAGE_UTIL_COLORSPACE_RGB565 != src_colorspace
+      && IMAGE_UTIL_COLORSPACE_I420 != src_colorspace
+      && IMAGE_UTIL_COLORSPACE_UYVY != src_colorspace
+      && IMAGE_UTIL_COLORSPACE_RGB888 != src_colorspace)
+   {
+      ERR("src_colorspace not supported yet");
+      return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
+   }
+
+   if (IMAGE_UTIL_COLORSPACE_BGRA8888 != dest_colorspace
+      && IMAGE_UTIL_COLORSPACE_RGB565 != dest_colorspace
+      && IMAGE_UTIL_COLORSPACE_I420 != dest_colorspace)
+   {
+      ERR("dest_colorspace not supported yet");
+      return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
+   }
+
+   unsigned int dest_size = 0;
+   error = image_util_calculate_buffer_size(width, height, dest_colorspace, &dest_size);
+   RETVM_IF(IMAGE_UTIL_ERROR_NONE != error, error, "image_util_calculate_buffer_size error");
+   unsigned int src_size = 0;
+   error = image_util_calculate_buffer_size(width, height, src_colorspace, &src_size);
+   RETVM_IF(IMAGE_UTIL_ERROR_NONE != error, error, "image_util_calculate_buffer_size error");
+
+   if (dest_colorspace == src_colorspace)
+   {
+      memcpy(dest, src, src_size);
+      return error;
+   }
+
+
+   if (IMAGE_UTIL_COLORSPACE_BGRA8888 == src_colorspace)
+   {
+      if (IMAGE_UTIL_COLORSPACE_I420 == dest_colorspace)
+      {
+         _convert_bgra8888_to_yuv420(dest, src, width, height, dest_size, src_size);
+      }
+      else
+      {
+         _convert_bgra8888_to_rgb565(dest, src, width, height, dest_size, src_size);
+      }
+   }
+   else if (IMAGE_UTIL_COLORSPACE_RGB565 == src_colorspace)
+   {
+      if (IMAGE_UTIL_COLORSPACE_I420 == dest_colorspace)
+      {
+         _convert_rgb565_to_yuv420(dest, src, width, height, dest_size, src_size);
+      }
+      else
+      {
+         _convert_rgb565_to_bgra8888(dest, src, width, height, dest_size, src_size);
+      }
+   }
+   else if (IMAGE_UTIL_COLORSPACE_I420 == src_colorspace)
+   {
+      if (IMAGE_UTIL_COLORSPACE_RGB565 == dest_colorspace)
+      {
+         _convert_yuv420_to_rgb565(dest, src, width, height, dest_size, src_size);
+      }
+      else
+      {
+         _convert_yuv420_to_bgra8888(dest, src, width, height, dest_size, src_size);
+      }
+   }
+   else if (IMAGE_UTIL_COLORSPACE_UYVY == src_colorspace)
+   {
+      if (IMAGE_UTIL_COLORSPACE_BGRA8888 == dest_colorspace)
+      {
+         _convert_yuv422_to_bgra8888(dest, src, width, height, dest_size, src_size);
+      }
+      else
+      {
+         ERR("dest_colorspace not supported yet");
+         return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
+      }
+   }
+   else
+   {
+      if (IMAGE_UTIL_COLORSPACE_BGRA8888 == dest_colorspace)
+      {
+         _convert_rgb888_to_bgra8888(dest, src, width, height, dest_size, src_size);
+      }
+      else
+      {
+         ERR("dest_colorspace not supported yet");
+         return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
+      }
+   }
+
+   return error;
+}
+
 bool frame_extractor_frame_get(const frame_extractor *extractor, unsigned char **frame, int pos)
 {
    bool result = false;
@@ -333,7 +815,7 @@ bool frame_extractor_frame_get(const frame_extractor *extractor, unsigned char *
          *frame = malloc(size + (extractor->width * extractor->height) * ARGB_PIXEL_SIZE);
          if (*frame)
          {
-            error = image_util_convert_colorspace(*frame , IMAGE_UTIL_COLORSPACE_BGRA8888, buf,  extractor->width, extractor->height, IMAGE_UTIL_COLORSPACE_RGB888);
+            error = image_sample_util_convert_colorspace(*frame , IMAGE_UTIL_COLORSPACE_BGRA8888, buf,  extractor->width, extractor->height, IMAGE_UTIL_COLORSPACE_RGB888);
             if (IMAGE_UTIL_ERROR_NONE == error)
             {
                result = true;