return IMAGE_UTIL_ERROR_NONE;
}
+static void __mm_util_destroy_color_image(mm_util_color_image_h image)
+{
+ mm_image_info_s *_color_image = (mm_image_info_s *)image;
+
+ if (_color_image == NULL) {
+ image_util_error("[ERROR] - image");
+ return;
+ }
+
+ IMAGE_UTIL_SAFE_FREE(_color_image->data);
+ IMAGE_UTIL_SAFE_FREE(_color_image);
+}
+
+static int __mm_util_create_color_image(mm_util_color_image_h *image, unsigned long width, unsigned long height, mm_util_color_format_e color, void *data, size_t size)
+{
+ int ret = IMAGE_UTIL_ERROR_NONE;
+ mm_image_info_s *_color_image = NULL;
+
+ image_util_retvm_if((image == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid handle");
+ image_util_retvm_if((color >= MM_UTIL_COLOR_NUM), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid color");
+ image_util_retvm_if((data == NULL || size == 0), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid data");
+
+ _color_image = (mm_image_info_s *)calloc(1, sizeof(mm_image_info_s));
+ image_util_retvm_if((_color_image == NULL), IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "Memory allocation failed");
+
+ _color_image->data = calloc(1, size);
+ if (_color_image->data == NULL) {
+ image_util_error("Memory allocation failed");
+ __mm_util_destroy_color_image(_color_image);
+ *image = NULL;
+ return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
+ }
+
+ memcpy(_color_image->data, data, size);
+
+ _color_image->size = size;
+ _color_image->width = width;
+ _color_image->height = height;
+ _color_image->color = color;
+
+ image_util_debug("w [%lu], h [%lu], color [%u], size [%zu], data [%p]", _color_image->width, _color_image->height, _color_image->color, _color_image->size, _color_image->data);
+
+ *image = (mm_util_color_image_h)_color_image;
+
+ return ret;
+}
+
+static int __mm_util_get_color_image(mm_util_color_image_h image, unsigned long *width, unsigned long *height, mm_util_color_format_e *color, void **data, size_t *size)
+{
+ int ret = IMAGE_UTIL_ERROR_NONE;
+ mm_image_info_s *_color_image = (mm_image_info_s *)image;
+
+ image_util_retvm_if((_color_image == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid handle");
+
+ if (width != NULL)
+ *width = _color_image->width;
+
+ if (height != NULL)
+ *height = _color_image->height;
+
+ if (color != NULL)
+ *color = _color_image->color;
+
+ if (data != NULL)
+ *data = _color_image->data;
+
+ if (size != NULL)
+ *size = _color_image->size;
+
+ return ret;
+}
+
+static void __mm_destroy_temp_buffer(unsigned char *buffer[])
+{
+ int i = 0;
+
+ for (i = 0; i < 4; i++)
+ IMAGE_UTIL_SAFE_FREE(buffer[i]);
+}
+
+static int __mm_util_processing(mm_util_s *handle)
+{
+ int ret = IMAGE_UTIL_ERROR_NONE;
+ unsigned char *dst_buf[4] = {NULL,};
+ unsigned int src_width = 0, src_height = 0;
+ mm_util_color_format_e src_format = -1;
+ unsigned int src_index = 0, dst_index = 0;
+ unsigned int res_w = 0;
+ unsigned int res_h = 0;
+ unsigned char *res_buffer = NULL;
+ unsigned char *res_buffer_conv = NULL;
+ unsigned char *res_buffer_rotate = NULL;
+ size_t res_buffer_size = 0;
+
+ image_util_retvm_if(handle == NULL, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "invalid handle");
+
+ image_util_debug("src: %p, dst: %p", handle->src, handle->dst);
+
+ dst_buf[src_index] = calloc(1, handle->src->size);
+ src_width = handle->src->width;
+ src_height = handle->src->height;
+ src_format = handle->src->color;
+ if (dst_buf[src_index] == NULL) {
+ image_util_error("[multi func] memory allocation error");
+ return IMAGE_UTIL_ERROR_INVALID_OPERATION;
+ }
+ memcpy(dst_buf[src_index], handle->src->data, handle->src->size);
+
+ if (handle->set_crop) {
+ dst_index++;
+
+ ret = mm_util_crop_image(dst_buf[src_index], src_width, src_height, src_format, handle->start_x, handle->start_y, handle->dst_width, handle->dst_height, &res_buffer, &res_w, &res_h, &res_buffer_size);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ __mm_destroy_temp_buffer(dst_buf);
+ image_util_error("mm_util_crop_image failed");
+ return _image_error_capi(ERR_TYPE_TRANSFORM, ret);
+ }
+
+ dst_buf[dst_index] = res_buffer;
+ src_index = dst_index;
+ src_width = res_w;
+ src_height = res_h;
+ } else if (handle->set_resize) {
+ dst_index++;
+
+ ret = mm_util_resize_image(dst_buf[src_index], src_width, src_height, src_format, handle->dst_width, handle->dst_height, &res_buffer, &res_w, &res_h, &res_buffer_size);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ __mm_destroy_temp_buffer(dst_buf);
+ image_util_error("mm_util_resize_image failed");
+ return _image_error_capi(ERR_TYPE_TRANSFORM, ret);
+ }
+
+ dst_buf[dst_index] = res_buffer;
+ src_index = dst_index;
+ src_width = res_w;
+ src_height = res_h;
+ }
+
+ if (handle->set_convert) {
+ dst_index++;
+
+ ret = mm_util_convert_colorspace(dst_buf[src_index], src_width, src_height, src_format, handle->dst_format, &res_buffer_conv, &res_w, &res_h, &res_buffer_size);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ __mm_destroy_temp_buffer(dst_buf);
+ image_util_error("mm_util_convert_colorspace failed");
+ return _image_error_capi(ERR_TYPE_TRANSFORM, ret);
+ }
+
+ dst_buf[dst_index] = res_buffer_conv;
+ src_index = dst_index;
+ src_format = handle->dst_format;
+ src_width = res_w;
+ src_height = res_h;
+ }
+
+ if (handle->set_rotate) {
+ dst_index++;
+
+ ret = mm_util_rotate_image(dst_buf[src_index], src_width, src_height, src_format, handle->rotation, &res_buffer_rotate, &res_w, &res_h, &res_buffer_size);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ __mm_destroy_temp_buffer(dst_buf);
+ image_util_error("mm_util_rotate_image failed");
+ return _image_error_capi(ERR_TYPE_TRANSFORM, ret);
+ }
+
+ dst_buf[dst_index] = res_buffer_rotate;
+ src_index = dst_index;
+ src_width = res_w;
+ src_height = res_h;
+ }
+
+ if (dst_buf[dst_index] != NULL && res_buffer_size != 0) {
+ ret = __mm_util_create_color_image((mm_util_color_image_h *)&(handle->dst), (unsigned long)src_width, (unsigned long)src_height, src_format, (void *)dst_buf[dst_index], res_buffer_size);
+ if (ret != IMAGE_UTIL_ERROR_NONE)
+ image_util_error("__mm_util_create_color_image failed");
+ } else {
+ image_util_error("invalid result %p %zu", dst_buf[dst_index], res_buffer_size);
+ ret = IMAGE_UTIL_ERROR_INVALID_OPERATION;
+ }
+ __mm_destroy_temp_buffer(dst_buf);
+
+ image_util_error("mm_util_processing was finished");
+
+ return ret;
+}
+
+static int __mm_util_transform_exec(mm_util_s *handle, mm_image_info_s *source_image)
+{
+ int ret = IMAGE_UTIL_ERROR_NONE;
+
+ image_util_retvm_if(handle == NULL, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "invalid handle");
+ image_util_retvm_if(source_image == NULL, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "invalid source_image");
+
+ image_util_debug("orig_image: %p [%zu] %lu X %lu (%u)", source_image->data, source_image->size,
+ source_image->width, source_image->height, source_image->color);
+
+ handle->src = source_image;
+ handle->dst = NULL;
+
+ ret = __mm_util_processing(handle);
+ image_util_retvm_if(ret != IMAGE_UTIL_ERROR_NONE, ret, "__mm_util_processing failed [%d]", ret);
+
+ image_util_debug("result_image: %p [%zu] %lu X %lu (%u)", handle->dst->data, handle->dst->size,
+ handle->dst->width, handle->dst->height, handle->dst->color);
+
+ return ret;
+}
+
+gpointer __mm_util_thread_repeate(gpointer data)
+{
+ mm_util_s *handle = (mm_util_s *) data;
+ int ret = IMAGE_UTIL_ERROR_NONE;
+ mm_util_color_image_h pop_data = NULL;
+
+ image_util_retvm_if(handle == NULL, NULL, "invalid handle");
+
+ while (!handle->is_finish) {
+ image_util_debug("waiting...");
+ pop_data = (mm_util_color_image_h)g_async_queue_timeout_pop(handle->queue, 300 * G_TIME_SPAN_MILLISECOND);
+ image_util_debug("get from data or timeout");
+
+ if (pop_data == NULL) {
+ image_util_error("The data is null");
+ continue;
+ }
+
+ ret = __mm_util_transform_exec(handle, (mm_image_info_s *)pop_data); /* Need to block */
+ if (ret == IMAGE_UTIL_ERROR_NONE)
+ image_util_debug("Success - transform_exec");
+ else
+ image_util_error("Error - transform_exec");
+
+ if (handle->_util_cb->completed_cb) {
+ image_util_debug("completed_cb is called");
+ handle->_util_cb->completed_cb(handle->dst, ret, handle->_util_cb->user_data);
+ }
+ __mm_util_destroy_color_image(pop_data);
+ __mm_util_destroy_color_image(handle->dst);
+ handle->is_completed = FALSE;
+ }
+
+ image_util_debug("exit thread");
+ handle->thread = NULL;
+
+ return NULL;
+}
+
+static int __mm_util_create_thread(mm_util_s *handle)
+{
+ int ret = IMAGE_UTIL_ERROR_NONE;
+
+ image_util_retvm_if(handle == NULL, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "invalid handle");
+ image_util_retvm_if(handle->thread != NULL, IMAGE_UTIL_ERROR_NONE, "[NO-ERROR] Thread is already created");
+
+ /*create threads*/
+ handle->thread = g_thread_new("transform_thread", (GThreadFunc)__mm_util_thread_repeate, (gpointer)handle);
+ image_util_retvm_if(handle->thread == NULL, IMAGE_UTIL_ERROR_INVALID_OPERATION, "ERROR - create thread");
+
+ image_util_debug("New thread is created");
+
+ return ret;
+}
+
+static int __mm_util_transform(mm_util_imgp_h imgp_handle, mm_util_color_image_h image, mm_util_completed_callback completed_callback, void *user_data)
+{
+ int ret = IMAGE_UTIL_ERROR_NONE;
+ mm_util_s *handle = (mm_util_s *) imgp_handle;
+
+ image_util_fenter();
+
+ image_util_retvm_if(handle == NULL, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "invalid handle");
+ image_util_retvm_if(image == NULL, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "invalid image");
+ image_util_retvm_if(completed_callback == NULL, IMAGE_UTIL_ERROR_INVALID_PARAMETER, "invalid completed_callback");
+
+ image_util_debug("image: %p", image);
+
+ IMAGE_UTIL_SAFE_FREE(handle->_util_cb);
+ handle->_util_cb = (mm_util_cb_s *)calloc(1, sizeof(mm_util_cb_s));
+ if (handle->_util_cb) {
+ handle->_util_cb->completed_cb = completed_callback;
+ handle->_util_cb->user_data = user_data;
+ } else {
+ image_util_error("[ERROR] _util_cb_s");
+ }
+
+ if (handle->queue) {
+ image_util_debug("g_async_queue_push");
+ g_async_queue_push(handle->queue, GINT_TO_POINTER(image));
+ ret = __mm_util_create_thread(handle);
+ if (ret != IMAGE_UTIL_ERROR_NONE) {
+ image_util_error("ERROR - Create thread");
+ return ret;
+ } else {
+ image_util_debug("Success -__mm_util_create_thread");
+ }
+ }
+
+ image_util_fleave();
+
+ return ret;
+}
+
static int _image_util_packet_to_image(media_packet_h packet, mm_util_color_image_h *color_image)
{
int err = IMAGE_UTIL_ERROR_NONE;
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");
- err = mm_util_create_color_image(color_image, (unsigned long)width, (unsigned long)height, __mimetype_to_image_format(mimetype), ptr, (size_t)size);
- image_util_retvm_if((err != MM_UTIL_ERROR_NONE), _image_error_capi(ERR_TYPE_TRANSFORM, err), "mm_util_create_color_image failed (%d)", err);
+ err = __mm_util_create_color_image(color_image, (unsigned long)width, (unsigned long)height, __mimetype_to_image_format(mimetype), ptr, (size_t)size);
+ image_util_retvm_if((err != IMAGE_UTIL_ERROR_NONE), err, "__mm_util_create_color_image failed (%d)", err);
image_util_debug("_image_util_packet_to_image succeed");
uint64_t packet_size = 0;
size_t size = 0;
- err = mm_util_get_color_image(image, &width, &height, &format, &buffer, &buffer_size);
- image_util_retvm_if((err != MM_UTIL_ERROR_NONE), _image_error_capi(ERR_TYPE_TRANSFORM, err), "mm_util_get_color_image failed (%d)", err);
+ err = __mm_util_get_color_image(image, &width, &height, &format, &buffer, &buffer_size);
+ image_util_retvm_if((err != IMAGE_UTIL_ERROR_NONE), err, "__mm_util_get_color_image failed (%d)", err);
err = __create_media_format(__image_format_to_mimetype(format), (unsigned int)width, (unsigned int)height, &fmt);
image_util_retvm_if((err != IMAGE_UTIL_ERROR_NONE), err, "__create_media_format failed (%d)", err);
if ((_util_cb != NULL) && (_util_cb->completed_cb != NULL)) {
err = _image_util_image_to_packet(raw_image, &packet);
- if (err != MM_UTIL_ERROR_NONE) {
+ if (err != IMAGE_UTIL_ERROR_NONE) {
image_util_error("_image_util_image_to_packet failed (%d)", err);
_util_cb->completed_cb(NULL, err, _util_cb->user_data);
} else {
if (_handle->queue == NULL) {
image_util_error("g_async_queue_new failed");
IMAGE_UTIL_SAFE_FREE(_handle);
- return MM_UTIL_ERROR_INVALID_OPERATION;
+ return IMAGE_UTIL_ERROR_INVALID_OPERATION;
}
handle->image_h = _handle;
int image_util_transform_create(transformation_h * handle)
{
- int err = MM_UTIL_ERROR_NONE;
+ int err = IMAGE_UTIL_ERROR_NONE;
image_util_fenter();
_handle->image_h = NULL;
err = _image_util_create_transform_handle(_handle);
- if (err != MM_UTIL_ERROR_NONE) {
+ if (err != IMAGE_UTIL_ERROR_NONE) {
image_util_error("Error - create transform handle");
IMAGE_UTIL_SAFE_FREE(_handle);
- return MM_UTIL_ERROR_INVALID_OPERATION;
+ return IMAGE_UTIL_ERROR_INVALID_OPERATION;
}
*handle = (transformation_h) _handle;
int image_util_transform_run(transformation_h handle, media_packet_h src, image_util_transform_completed_cb completed_cb, void *user_data)
{
- int err = MM_UTIL_ERROR_NONE;
+ int err = IMAGE_UTIL_ERROR_NONE;
transformation_s *_handle = (transformation_s *) handle;
image_util_fenter();
_handle->_util_cb = (image_util_cb_s *) calloc(1, sizeof(image_util_cb_s));
if (_handle->_util_cb == NULL) {
image_util_error("Memory allocation failed");
- mm_util_destroy_color_image(color_image);
+ __mm_util_destroy_color_image(color_image);
return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
}
_handle->_util_cb->user_data = user_data;
_handle->_util_cb->completed_cb = completed_cb;
- err = mm_util_transform(_handle->image_h, color_image, (mm_util_completed_callback) _image_util_transform_completed_cb, (void *)_handle->_util_cb);
- if (err != MM_UTIL_ERROR_NONE) {
+ err = __mm_util_transform(_handle->image_h, color_image, (mm_util_completed_callback) _image_util_transform_completed_cb, (void *)_handle->_util_cb);
+ if (err != IMAGE_UTIL_ERROR_NONE) {
image_util_error("Error - Run transform (%d)", err);
- mm_util_destroy_color_image(color_image);
- return _image_error_capi(ERR_TYPE_TRANSFORM, err);
+ __mm_util_destroy_color_image(color_image);
+ return err;
}
return IMAGE_UTIL_ERROR_NONE;
image_util_fleave();
- return MM_UTIL_ERROR_NONE;
+ return IMAGE_UTIL_ERROR_NONE;
}
int image_util_calculate_buffer_size(int width, int height, image_util_colorspace_e colorspace, unsigned int *size)
{
- int err = MM_UTIL_ERROR_NONE;
+ int err = IMAGE_UTIL_ERROR_NONE;
size_t size_ptr = 0;
image_util_retvm_if((is_valid_colorspace(colorspace) == FALSE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
int image_util_extract_color_from_memory(const unsigned char *image_buffer, int width, int height, unsigned char *rgb_r, unsigned char *rgb_g, unsigned char *rgb_b)
{
- int ret = MM_UTIL_ERROR_NONE;
+ int ret = IMAGE_UTIL_ERROR_NONE;
image_util_retvm_if((image_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "image_buffer is null");