Fix the way to use media_packet when multiple bos are given

To get pointer address of planes from media packet,
replace media_packet_get_buffer_data_ptr() with media_packet_get_video_plane_data_ptr().

Change-Id: I4c7da53d6c3b2d0cee1cfd6e3fc3b7f41915f494

diff --git a/packaging/capi-media-image-util.spec b/packaging/capi-media-image-util.spec
index bfb9237ef54b711f03f49df30c2b690f2b89fdce..eb3c586e5c94660688607c5e5f08e722d3c89f18 100755 (executable)
--- a/packaging/capi-media-image-util.spec
+++ b/packaging/capi-media-image-util.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-image-util
 Summary:    A Image Utility library in Tizen Native API
-Version:    0.1.48
+Version:    0.1.49
 Release:    2
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/image_util.c b/src/image_util.c
index a0ea209e316222379976c79b63f510be959acdad..2fce9c4c8d34aaebeacb3f70d455b28b1ed9ee23 100644 (file)
--- a/src/image_util.c
+++ b/src/image_util.c
@@ -122,38 +122,83 @@ static int __create_media_format(media_format_mimetype_e mimetype, unsigned int
        return IMAGE_UTIL_ERROR_NONE;
 }
 
-static int __create_media_packet(media_format_h fmt, media_packet_h *new_pkt, void **pkt_ptr, uint64_t *pkt_size)
+static int __create_media_packet(media_format_h fmt, unsigned char *buffer, size_t buffer_size, media_packet_h *packet)
 {
-       int err = MEDIA_FORMAT_ERROR_NONE;
-
-       image_util_retvm_if((fmt == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid fmt");
-       image_util_retvm_if((new_pkt == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid new_pkt");
-       image_util_retvm_if((pkt_ptr == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid pkt_ptr");
-       image_util_retvm_if((pkt_size == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid pkt_size");
-
-       err = media_packet_create_alloc(fmt, NULL, NULL, new_pkt);
-       if (err != MEDIA_PACKET_ERROR_NONE) {
-               image_util_error("media_packet_create_alloc failed (%d)", err);
+       int ret = MEDIA_FORMAT_ERROR_NONE;
+       unsigned int i = 0;
+       uint32_t plane_num = 0;
+       int stride_width = 0, stride_height = 0;
+       void *plane_ptr = NULL;
+       size_t plane_size = 0;
+       size_t buffer_offset = 0;
+       size_t memcpy_size = 0;
+
+       image_util_retvm_if(!fmt, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid fmt");
+       image_util_retvm_if(!packet, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid new_pkt");
+       image_util_retvm_if(!buffer, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid pkt_ptr");
+       image_util_retvm_if(buffer_size == 0, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid pkt_size");
+
+       ret = media_packet_create_alloc(fmt, NULL, NULL, packet);
+       if (ret != MEDIA_PACKET_ERROR_NONE) {
+               image_util_error("media_packet_create_from_external_memory failed (%d)", ret);
                return IMAGE_UTIL_ERROR_INVALID_OPERATION;
        }
 
-       err = media_packet_get_buffer_size(*new_pkt, pkt_size);
-       if (err != MEDIA_PACKET_ERROR_NONE) {
-               image_util_error("media_packet_get_buffer_size failed (%d)", err);
-               media_packet_destroy(*new_pkt);
-               return IMAGE_UTIL_ERROR_INVALID_OPERATION;
+       ret = media_packet_get_number_of_video_planes(*packet, &plane_num);
+       if (ret != MEDIA_PACKET_ERROR_NONE) {
+               image_util_error("media_packet_get_number_of_video_plances failed (%d)", ret);
+               ret = IMAGE_UTIL_ERROR_INVALID_OPERATION;
+               goto ERROR;
        }
 
-       err = media_packet_get_buffer_data_ptr(*new_pkt, pkt_ptr);
-       if (err != MEDIA_PACKET_ERROR_NONE) {
-               image_util_error("media_packet_get_buffer_data_ptr failed");
-               media_packet_destroy(*new_pkt);
-               return IMAGE_UTIL_ERROR_INVALID_OPERATION;
+       image_util_debug("plane_num: %u", plane_num);
+
+       for (i = 0; i < plane_num; i++) {
+               ret = media_packet_get_video_stride_width(*packet, i, &stride_width);
+               if (ret != MEDIA_PACKET_ERROR_NONE) {
+                       image_util_error("media_packet_get_video_stride_width failed (%d)", ret);
+                       ret = IMAGE_UTIL_ERROR_INVALID_OPERATION;
+                       goto ERROR;
+               }
+
+               ret = media_packet_get_video_stride_height(*packet, i, &stride_height);
+               if (ret != MEDIA_PACKET_ERROR_NONE) {
+                       image_util_error("media_packet_get_video_stride_height failed (%d)", ret);
+                       ret = IMAGE_UTIL_ERROR_INVALID_OPERATION;
+                       goto ERROR;
+               }
+
+               plane_size = stride_width * stride_height;
+
+               ret = media_packet_get_video_plane_data_ptr(*packet, i, &plane_ptr);
+               if (ret != MEDIA_PACKET_ERROR_NONE) {
+                       image_util_error("media_packet_get_video_plane_data_ptr failed (%d)", ret);
+                       ret = IMAGE_UTIL_ERROR_INVALID_OPERATION;
+                       goto ERROR;
+               }
+
+               image_util_debug("stride_width: %d, stride_height: %d, plane_ptr: %p, plane_size: %zu",
+                               stride_width, stride_height, plane_ptr,plane_size);
+
+               if (buffer_offset + plane_size > buffer_size)
+                       memcpy_size = buffer_size - buffer_offset;
+               else
+                       memcpy_size = plane_size;
+
+               memcpy(plane_ptr, buffer + buffer_offset, memcpy_size);
+               buffer_offset += memcpy_size;
        }
 
-       image_util_debug("Success - media_packet is created (%p, %" PRIu64 ")", *pkt_ptr, *pkt_size);
+       image_util_debug("Success - media_packet is created (%p)", *packet);
 
        return IMAGE_UTIL_ERROR_NONE;
+
+ERROR:
+       if (*packet != NULL)
+               media_packet_destroy(*packet);
+       *packet = NULL;
+
+       return ret;
 }
 
 static int __mm_util_transform(transformation_h handle, image_util_image_h origin, image_util_image_h *transform)
@@ -209,9 +254,9 @@ static int __image_util_image_to_packet(image_util_image_h image, media_packet_h
        unsigned char *buffer = NULL;
        size_t buffer_size = 0;
        media_format_h fmt = NULL;
-       void *packet_ptr = NULL;
-       uint64_t packet_size = 0;
-       size_t size = 0;
+//     void *packet_ptr = NULL;
+//     uint64_t packet_size = 0;
+//     size_t size = 0;
 
        image_util_fenter();
 
@@ -221,6 +266,8 @@ static int __image_util_image_to_packet(image_util_image_h image, media_packet_h
        ret = mm_image_get_image(image, &width, &height, &format, &buffer, &buffer_size);
        image_util_retvm_if((ret != MM_UTIL_ERROR_NONE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "mm_image_get_image failed");
 
+       image_util_debug("Buffer: %p buffer_size: %zu", buffer, buffer_size);
+
        ret = __create_media_format(__image_format_to_mimetype(format), width, height, &fmt);
        if (ret != IMAGE_UTIL_ERROR_NONE) {
                image_util_error("__create_media_format failed (%d)", ret);
@@ -228,7 +275,7 @@ static int __image_util_image_to_packet(image_util_image_h image, media_packet_h
                return IMAGE_UTIL_ERROR_INVALID_OPERATION;
        }
 
-       ret = __create_media_packet(fmt, packet, &packet_ptr, &packet_size);
+       ret = __create_media_packet(fmt, buffer, buffer_size, packet);
        if (ret != MEDIA_PACKET_ERROR_NONE) {
                image_util_error("__create_media_packet failed (%d)", ret);
                media_format_unref(fmt);
@@ -236,23 +283,6 @@ static int __image_util_image_to_packet(image_util_image_h image, media_packet_h
                return IMAGE_UTIL_ERROR_INVALID_OPERATION;
        }
 
-       if ((uint64_t)buffer_size < packet_size) {
-               size = (size_t)buffer_size;
-       } else {
-               size = (size_t)packet_size;
-       }
-
-       image_util_debug("Size: result(%zu) media_packet(%" PRIu64 ") copied(%zu)", buffer_size, packet_size, size);
-       memcpy(packet_ptr, buffer, size);
-       IMAGE_UTIL_SAFE_FREE(buffer);
-
-       ret = media_packet_set_buffer_size(*packet, (uint64_t)size);
-       if (ret != MEDIA_PACKET_ERROR_NONE) {
-               image_util_error("media_packet_set_buffer_size failed (%d)", ret);
-               media_packet_destroy(*packet);
-               return IMAGE_UTIL_ERROR_INVALID_OPERATION;
-       }
-
        image_util_fleave();
 
        return IMAGE_UTIL_ERROR_NONE;
@@ -336,9 +366,14 @@ static int __image_util_packet_to_image(media_packet_h packet, image_util_image_
        int ret = IMAGE_UTIL_ERROR_NONE;
        media_format_mimetype_e mimetype = 0;
        int width = 0, height = 0;
-       uint64_t size = 0;
-       void *ptr = NULL;
        media_format_h fmt = NULL;
+       unsigned int i = 0;
+       uint32_t plane_num = 0;
+       int stride_width = 0, stride_height = 0;
+       void *plane_ptr = NULL;
+       size_t plane_size = 0;
+       void *ptr = NULL;
+       size_t size = 0;
 
        image_util_retvm_if(!packet, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid packet");
        image_util_retvm_if(!image, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid image");
@@ -354,23 +389,59 @@ static int __image_util_packet_to_image(media_packet_h packet, image_util_image_
        }
        media_format_unref(fmt);
 
-       ret = media_packet_get_buffer_size(packet, &size);
-       image_util_retvm_if((ret != MEDIA_PACKET_ERROR_NONE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "media_packet_get_buffer_size failed (%d)", ret);
+       ret = media_packet_get_number_of_video_planes(packet, &plane_num);
+       if (ret != MEDIA_PACKET_ERROR_NONE) {
+               image_util_error("media_packet_get_number_of_video_plances failed (%d)", ret);
+               goto ERROR;
+       }
+
+       image_util_debug("plane_num: %u", plane_num);
+
+       for (i = 0; i < plane_num; i++) {
+               ret = media_packet_get_video_stride_width(packet, i, &stride_width);
+               if (ret != MEDIA_PACKET_ERROR_NONE) {
+                       image_util_error("media_packet_get_number_of_video_plances failed (%d)", ret);
+                       goto ERROR;
+               }
+
+               ret = media_packet_get_video_stride_height(packet, i, &stride_height);
+               if (ret != MEDIA_PACKET_ERROR_NONE) {
+                       image_util_error("media_packet_get_number_of_video_plances failed (%d)", ret);
+                       goto ERROR;
+               }
+
+               plane_size = stride_width * stride_height;
 
-       if (size) {
-               ret = media_packet_get_buffer_data_ptr(packet, &ptr);
-               image_util_retvm_if((ret != MEDIA_PACKET_ERROR_NONE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "media_packet_get_buffer_data_ptr failed (%d)", ret);
+               ret = media_packet_get_video_plane_data_ptr(packet, i, &plane_ptr);
+               if (ret != MEDIA_PACKET_ERROR_NONE) {
+                       image_util_error("media_packet_get_number_of_video_plances failed (%d)", ret);
+                       goto ERROR;
+               }
+
+               image_util_debug("stride_width: %d, stride_height: %d, plane_ptr: %p, plane_size: %zu",
+                               stride_width, stride_height, plane_ptr,plane_size);
+
+               ptr = realloc(ptr, size + plane_size);
+               image_util_retvm_if(!ptr, IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "Memory allocation failed");
+
+               memcpy(ptr + size, plane_ptr, plane_size);
+               size += plane_size;
        }
 
        image_util_debug("[Fotmat: %u] W x H : %d x %d", mimetype, width, height);
        image_util_retvm_if(((width <= 0) || (height <= 0) || (size == 0) || (ptr == NULL)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid source packet");
 
-       ret = mm_image_create_image(width, height, __mimetype_to_image_format(mimetype), ptr, (size_t)size, image);
+       ret = mm_image_create_image(width, height, __mimetype_to_image_format(mimetype), ptr, size, image);
+       IMAGE_UTIL_SAFE_FREE(ptr);
        image_util_retvm_if((ret != IMAGE_UTIL_ERROR_NONE), ret, "mm_image_create_image failed (%d)", ret);
 
        image_util_debug("__image_util_packet_to_image succeed");
 
        return IMAGE_UTIL_ERROR_NONE;
+
+ERROR:
+       IMAGE_UTIL_SAFE_FREE(ptr);
+       return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 }
 
 static int __clone_transform(transformation_h src, transformation_h *dst)

diff --git a/src/image_util_encode.c b/src/image_util_encode.c
index d1b0ebc9484fa9912ffe7ccfa8d85598469686cb..116a43817a3be0fc1959fa7c1218a8b81a92f100 100755 (executable)
--- a/src/image_util_encode.c
+++ b/src/image_util_encode.c
@@ -152,7 +152,7 @@ int image_util_encode_set_colorspace(image_util_encode_h handle, image_util_colo
        image_util_retvm_if((is_valid_colorspace(colorspace) == FALSE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
        image_util_retvm_if((is_supported_colorspace(colorspace, _handle->image_type) == FALSE), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
 
-       _handle->src.color = colorspace;
+       _handle->src.color = TYPECAST_COLOR_BY_TYPE(colorspace, _handle->image_type);
 
        return IMAGE_UTIL_ERROR_NONE;
 }

diff --git a/test/image_util_test.c b/test/image_util_test.c
index a26fc74c935ace79f74402a3df1553e2fd1995b6..82288b0cac8e52e3e5c3a1f5eb0318ee8e40fcb9 100644 (file)
--- a/test/image_util_test.c
+++ b/test/image_util_test.c
@@ -75,6 +75,7 @@ _image_util_mapping_imgp_format_to_mime(image_util_colorspace_e colorspace)
        case IMAGE_UTIL_COLORSPACE_I420:
                mimetype = MEDIA_FORMAT_I420;
                break;
+       case IMAGE_UTIL_COLORSPACE_YV12:
        case IMAGE_UTIL_COLORSPACE_NV21:
                mimetype = MEDIA_FORMAT_YV12;
                break;
@@ -265,14 +266,19 @@ static gboolean __create_src_image()
 
 void test_transform_completed_cb(media_packet_h *packet, image_util_error_e error, void *user_data)
 {
-       uint64_t size = 0;
        char output_file[25] = {};
 
        media_format_h dst_fmt;
        media_format_mimetype_e dst_mimetype;
        int dst_width, dst_height, dst_avg_bps, dst_max_bps;
        char *output_fmt = NULL;
-       void *dst = NULL;
+       unsigned int i = 0;
+       uint32_t plane_num = 0;
+       int stride_width = 0, stride_height = 0;
+       void *plane_ptr = NULL;
+       size_t plane_size = 0;
+       void *ptr = NULL;
+       size_t size = 0;
 
        g_printf("test_transform_completed_cb [%d][%d] \n", error, --g_request_count);
        if (error != IMAGE_UTIL_ERROR_NONE) {
@@ -281,12 +287,12 @@ void test_transform_completed_cb(media_packet_h *packet, image_util_error_e erro
 
        output_fmt = (char *)malloc(sizeof(char) * IMAGE_FORMAT_LABEL_BUFFER_SIZE);
        if (!output_fmt) {
-               g_printf("memory allocation failed");
+               g_printf("memory allocation failed\n");
                goto END;
        }
 
        if (media_packet_get_format(*packet, &dst_fmt) != MEDIA_PACKET_ERROR_NONE) {
-               g_printf("Imedia_packet_get_format");
+               g_printf("Imedia_packet_get_format\n");
                goto END;
        }
 
@@ -302,16 +308,46 @@ void test_transform_completed_cb(media_packet_h *packet, image_util_error_e erro
                snprintf(output_file, 25, "result_%dx%d.%s", dst_width, dst_height, output_fmt);
        }
 
-       if (media_packet_get_buffer_size(*packet, &size) != MEDIA_PACKET_ERROR_NONE)
-               g_printf("Fail to media_packet_get_buffer_size \n");
-
-       if (media_packet_get_buffer_data_ptr(*packet, &dst) != MEDIA_PACKET_ERROR_NONE) {
-               IMAGE_UTIL_SAFE_FREE(dst);
-               g_printf("[dst] media_packet_get_extra \n");
+       if (MEDIA_PACKET_ERROR_NONE != media_packet_get_number_of_video_planes(*packet, &plane_num)) {
+               g_printf("media_packet_get_number_of_video_plances failed\n");
                goto END;
        }
-       if (!__write_file(output_file, dst, size)) {
-               g_printf("__write_file failed");
+
+       g_printf("plane_num: %u\n", plane_num);
+
+       for (i = 0; i < plane_num; i++) {
+               if (MEDIA_PACKET_ERROR_NONE != media_packet_get_video_stride_width(*packet, i, &stride_width)) {
+                       g_printf("media_packet_get_number_of_video_plances failed\n");
+                       goto END;
+               }
+
+               if (MEDIA_PACKET_ERROR_NONE != media_packet_get_video_stride_height(*packet, i, &stride_height)) {
+                       g_printf("media_packet_get_number_of_video_plances failed\n");
+                       goto END;
+               }
+
+               plane_size = stride_width * stride_height;
+
+               if (MEDIA_PACKET_ERROR_NONE != media_packet_get_video_plane_data_ptr(*packet, i, &plane_ptr)) {
+                       g_printf("media_packet_get_number_of_video_plances failed\n");
+                       goto END;
+               }
+
+               g_printf("stride_width: %d, stride_height: %d, plane_ptr: %p, plane_size: %zu\n",
+                               stride_width, stride_height, plane_ptr,plane_size);
+
+               ptr = realloc(ptr, size + plane_size);
+               if (!ptr) {
+                       g_printf("Memory allocation failed");
+                       goto END;
+               }
+
+               memcpy(ptr + size, plane_ptr, plane_size);
+               size += plane_size;
+       }
+
+       if (!__write_file(output_file, ptr, size)) {
+               g_printf("__write_file failed\n");
                goto END;
        }
        g_printf("<<<<< SUCCESS >>>>>\n");
@@ -320,6 +356,7 @@ END:
 
        IMAGE_UTIL_SAFE_FREE(output_fmt);
        media_packet_destroy(*packet);
+       IMAGE_UTIL_SAFE_FREE(ptr);
 
        if (g_request_count == 0)
                display_menu();