From f5511799075237ff49550c0416ef5e8fcf021a24 Mon Sep 17 00:00:00 2001 From: hj kim Date: Tue, 12 Mar 2019 13:00:48 +0900 Subject: [PATCH] Modify parameters in encoding APIs have been changed from mm_image_info_s to mm_util_image_h Change-Id: Ibfbd29d2482142054f88b4aa74938e195d6995e4 --- bmp/include/mm_util_bmp.h | 4 +- bmp/mm_util_bmp.c | 70 +++++++--------- bmp/test/mm_util_bmp_testsuite.c | 4 +- bmp/unittest/libmm_bmp_unittest.cpp | 26 ++++-- common/include/mm_util_image.h | 3 + common/mm_util_image.c | 28 +++++-- gif/include/mm_util_gif.h | 4 +- gif/mm_util_gif.c | 39 +++++---- gif/test/mm_util_gif_testsuite.c | 4 +- gif/unittest/libmm_gif_unittest.cpp | 28 +++++-- jpeg/include/mm_util_jpeg.h | 6 +- jpeg/mm_util_jpeg.c | 151 ++++++++++++++++------------------ jpeg/test/mm_util_jpeg_testsuite.c | 4 +- jpeg/unittest/libmm_jpeg_unittest.cpp | 12 +-- png/include/mm_util_png.h | 4 +- png/mm_util_png.c | 52 +++++------- png/test/mm_util_png_testsuite.c | 4 +- png/unittest/libmm_png_unittest.cpp | 26 ++++-- 18 files changed, 244 insertions(+), 225 deletions(-) diff --git a/bmp/include/mm_util_bmp.h b/bmp/include/mm_util_bmp.h index 31cb4c8..628bd0f 100755 --- a/bmp/include/mm_util_bmp.h +++ b/bmp/include/mm_util_bmp.h @@ -29,8 +29,8 @@ extern "C" { int mm_util_decode_from_bmp_file(const char *file_path, mm_util_image_h *decoded); int mm_util_decode_from_bmp_memory(void *memory, const size_t src_size, mm_util_image_h *decoded); -int mm_util_encode_bmp_to_file(mm_image_info_s * decoded, const char *filename); -int mm_util_encode_bmp_to_memory(mm_image_info_s *decoded, void **buffer, size_t *size); +int mm_util_encode_bmp_to_file(mm_util_image_h decoded, const char *file_path); +int mm_util_encode_bmp_to_memory(mm_util_image_h decoded, void **buffer, size_t *size); #ifdef __cplusplus } diff --git a/bmp/mm_util_bmp.c b/bmp/mm_util_bmp.c index 2d12d7e..4ef1022 100755 --- a/bmp/mm_util_bmp.c +++ b/bmp/mm_util_bmp.c @@ -179,27 +179,31 @@ static int __read_bmp(const char *file_path, void *memory, size_t src_size, mm_u } /* encodes color image to bmp image */ -static int _write_bmp(mm_image_info_s *decoded, const char *filename, void **memory, size_t *src_size) +static int __write_bmp(mm_util_image_h decoded, const char *file_path, void **buffer, size_t *src_size) { + mm_image_info_s *_decoded = (mm_image_info_s *)decoded; bmpfile_t *bmp; rgb_pixel_t pixel = { 0, 0, 0, 0 }; uint16_t row, col; uint8_t *image; - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - mm_util_retvm_if(!MMUTIL_STRING_VALID(filename) && (memory == NULL || src_size == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid bmp image"); + mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image src"); + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path) && (!buffer || !src_size), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid parameter"); + mm_util_retvm_if(_decoded->color != MM_UTIL_COLOR_RGBA, MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported color [%d]", _decoded->color); + + mm_util_fenter(); /* header of bmp image is create at 'bmp' */ - if ((bmp = bmp_create(decoded->width, decoded->height, BYTES_PER_PIXEL * 8)) == NULL) { + if ((bmp = bmp_create(_decoded->width, _decoded->height, BYTES_PER_PIXEL * 8)) == NULL) { mm_util_error("Invalid depth value."); return MM_UTIL_ERROR_INVALID_OPERATION; } /* pixcels of bmp image is stored at 'bmp' */ - image = (uint8_t *) decoded->data; - for (row = 0; row != decoded->height; row++) { - for (col = 0; col != decoded->width; col++) { - size_t z = (row * decoded->width + col) * BYTES_PER_PIXEL; + image = (uint8_t *) _decoded->data; + for (row = 0; row != _decoded->height; row++) { + for (col = 0; col != _decoded->width; col++) { + size_t z = (row * _decoded->width + col) * BYTES_PER_PIXEL; pixel.red = image[z]; pixel.green = image[z + 1]; pixel.blue = image[z + 2]; @@ -207,24 +211,29 @@ static int _write_bmp(mm_image_info_s *decoded, const char *filename, void **mem } } - /* write 'bmp' to file or memory */ - if (MMUTIL_STRING_VALID(filename)) { - if (bmp_save(bmp, filename) == false) { + /* write 'bmp' to file or buffer */ + if (MMUTIL_STRING_VALID(file_path)) { + mm_util_sec_debug("Save to file [%s]", file_path); + if (bmp_save(bmp, file_path) == false) { mm_util_error("Saving bmp was failed."); bmp_destroy(bmp); return MM_UTIL_ERROR_INVALID_OPERATION; } } else { - if (bmp_save2(bmp, memory, src_size) == false) { + mm_util_sec_debug("Save to buffer"); + if (bmp_save2(bmp, buffer, src_size) == false) { mm_util_error("Saving bmp was failed."); bmp_destroy(bmp); - MMUTIL_SAFE_FREE(*memory); + MMUTIL_SAFE_FREE(*buffer); *src_size = 0; return MM_UTIL_ERROR_INVALID_OPERATION; } } bmp_destroy(bmp); + + mm_util_fleave(); + return MM_UTIL_ERROR_NONE; } @@ -243,38 +252,17 @@ int mm_util_decode_from_bmp_memory(void *memory, const size_t src_size, mm_util_ return __read_bmp(NULL, memory, src_size, decoded); } -int mm_util_encode_bmp_to_file(mm_image_info_s *decoded, const char *filename) +int mm_util_encode_bmp_to_file(mm_util_image_h decoded, const char *file_path) { - int ret = MM_UTIL_ERROR_NONE; - - mm_util_retvm_if(!MMUTIL_STRING_VALID(filename), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid bmp image"); - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - - mm_util_fenter(); - - ret = _write_bmp(decoded, filename, NULL, NULL); - if (ret != MM_UTIL_ERROR_NONE) - mm_util_error("_write_bmp failed (%d)", ret); - - mm_util_fleave(); + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid file_path"); - return ret; + return __write_bmp(decoded, file_path, NULL, NULL); } -int mm_util_encode_bmp_to_memory(mm_image_info_s *decoded, void **buffer, size_t *size) +int mm_util_encode_bmp_to_memory(mm_util_image_h decoded, void **buffer, size_t *size) { - int ret = MM_UTIL_ERROR_NONE; - - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - mm_util_retvm_if((buffer == NULL || size == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid bmp image"); - - mm_util_fenter(); - - ret = _write_bmp(decoded, NULL, buffer, size); - if (ret != MM_UTIL_ERROR_NONE) - mm_util_error("_write_bmp failed (%d)", ret); - - mm_util_fleave(); + mm_util_retvm_if(!buffer, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid buffer"); + mm_util_retvm_if(!size, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid size"); - return ret; + return __write_bmp(decoded, NULL, buffer, size); } diff --git a/bmp/test/mm_util_bmp_testsuite.c b/bmp/test/mm_util_bmp_testsuite.c index f3a371c..af2bad3 100644 --- a/bmp/test/mm_util_bmp_testsuite.c +++ b/bmp/test/mm_util_bmp_testsuite.c @@ -296,13 +296,13 @@ gboolean _test_encode(const bmp_test_mode_e mode) /* test encoding bmp */ if (mode == TEST_ENCODE_FILE) { - ret = mm_util_encode_bmp_to_file((mm_image_info_s *)g_decoded_data, ENCODE_FILE_PATH); + ret = mm_util_encode_bmp_to_file(g_decoded_data, ENCODE_FILE_PATH); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[BMP_testsuite] mm_util_encode_bmp_to_file failed : %d\n", ret); return FALSE; } } else if (mode == TEST_ENCODE_MEMORY) { - ret = mm_util_encode_bmp_to_memory((mm_image_info_s *)g_decoded_data, &encoded_data, &encoded_size); + ret = mm_util_encode_bmp_to_memory(g_decoded_data, &encoded_data, &encoded_size); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[BMP_testsuite] mm_util_encode_bmp_to_memory failed : %d\n", ret); SAFE_FREE(encoded_data); diff --git a/bmp/unittest/libmm_bmp_unittest.cpp b/bmp/unittest/libmm_bmp_unittest.cpp index e17de0c..4caf459 100644 --- a/bmp/unittest/libmm_bmp_unittest.cpp +++ b/bmp/unittest/libmm_bmp_unittest.cpp @@ -106,7 +106,7 @@ TEST(libmm_bmp_Test, mm_util_encode_bmp_to_file_p) EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_bmp_to_file((mm_image_info_s *)decode_image, ENCODE_FILE_PATH); + ret = mm_util_encode_bmp_to_file(decode_image, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); mm_image_destroy_image(decode_image); @@ -115,13 +115,19 @@ TEST(libmm_bmp_Test, mm_util_encode_bmp_to_file_p) TEST(libmm_bmp_Test, mm_util_encode_bmp_to_file_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; + + ret = mm_util_decode_from_bmp_file(DECODE_FILE_PATH, &decode_image); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); ret = mm_util_encode_bmp_to_file(NULL, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_bmp_to_file(&decode_image, NULL); + ret = mm_util_encode_bmp_to_file(decode_image, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + + mm_image_destroy_image(decode_image); } TEST(libmm_bmp_Test, mm_util_encode_bmp_to_memory_p) @@ -135,7 +141,7 @@ TEST(libmm_bmp_Test, mm_util_encode_bmp_to_memory_p) EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_bmp_to_memory((mm_image_info_s *)decode_image, &buffer, &size); + ret = mm_util_encode_bmp_to_memory(decode_image, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(buffer != NULL); EXPECT_NE(size, 0); @@ -149,18 +155,24 @@ TEST(libmm_bmp_Test, mm_util_encode_bmp_to_memory_p) TEST(libmm_bmp_Test, mm_util_encode_bmp_to_memory_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; void *buffer = NULL; size_t size = 0; + ret = mm_util_decode_from_bmp_file(DECODE_FILE_PATH, &decode_image); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); + ret = mm_util_encode_bmp_to_memory(NULL, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_bmp_to_memory(&decode_image, NULL, &size); + ret = mm_util_encode_bmp_to_memory(decode_image, NULL, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_bmp_to_memory(&decode_image, &buffer, NULL); + ret = mm_util_encode_bmp_to_memory(decode_image, &buffer, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + + mm_image_destroy_image(decode_image); } int main(int argc, char **argv) diff --git a/common/include/mm_util_image.h b/common/include/mm_util_image.h index be668f1..01701cf 100755 --- a/common/include/mm_util_image.h +++ b/common/include/mm_util_image.h @@ -18,12 +18,15 @@ #define __MM_UTIL_IMAGE_H__ #include +#include #include "mm_util_type.h" #ifdef __cplusplus extern "C" { #endif +#define TEMP_DATA_SIZE SIZE_MAX //To be removed + gboolean mm_image_is_valid_image(mm_util_image_h image); void mm_image_debug_image(mm_util_image_h image, const char *message); diff --git a/common/mm_util_image.c b/common/mm_util_image.c index 8a9fd15..8e52f04 100755 --- a/common/mm_util_image.c +++ b/common/mm_util_image.c @@ -60,14 +60,20 @@ int mm_image_create_image(unsigned int width, unsigned int height, _image = (mm_image_info_s *)calloc(1, sizeof(mm_image_info_s)); mm_util_retvm_if((_image == NULL), MM_UTIL_ERROR_OUT_OF_MEMORY, "Memory allocation failed"); - _image->data = calloc(1, size); - if (_image->data == NULL) { - mm_util_error("Memory allocation failed"); - mm_image_destroy_image(_image); - return MM_UTIL_ERROR_OUT_OF_MEMORY; + /* Just TEMP_DATA_SIZE has been used internally. + * It will be removed after removing deprecated CAPIs. */ + if (size == TEMP_DATA_SIZE) { + _image->data = (unsigned char *)data; + } else { + _image->data = calloc(1, size); + if (_image->data == NULL) { + mm_util_error("Memory allocation failed"); + mm_image_destroy_image(_image); + return MM_UTIL_ERROR_OUT_OF_MEMORY; + } + + memcpy(_image->data, data, size); } - - memcpy(_image->data, data, size); _image->size = size; _image->width = width; _image->height = height; @@ -111,6 +117,9 @@ int mm_image_get_image(mm_util_image_h image, unsigned int *width, unsigned char *_data = NULL; mm_util_retvm_if(!IS_VALID_IMAGE(image), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid image"); + /* Just TEMP_DATA_SIZE has been used internally. + * It will be removed after removing deprecated CAPIs. */ + mm_util_retvm_if(_image->size == TEMP_DATA_SIZE, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid size"); if (width) *width = _image->width; @@ -138,6 +147,9 @@ void mm_image_destroy_image(mm_util_image_h image) mm_util_retm_if(image == NULL, "Invalid image"); - MMUTIL_SAFE_FREE(_image->data); + /* Just TEMP_DATA_SIZE has been used internally. + * It will be removed after removing deprecated CAPIs. */ + if (_image->size != TEMP_DATA_SIZE) + MMUTIL_SAFE_FREE(_image->data); MMUTIL_SAFE_FREE(_image); } diff --git a/gif/include/mm_util_gif.h b/gif/include/mm_util_gif.h index 7d8aa86..6e2ac71 100755 --- a/gif/include/mm_util_gif.h +++ b/gif/include/mm_util_gif.h @@ -51,8 +51,8 @@ typedef void* mm_gif_file_h; int mm_util_decode_from_gif_file(const char *file_path, mm_util_image_h *decoded); int mm_util_decode_from_gif_memory(void *memory, const size_t src_size, mm_util_image_h *decoded); -int mm_util_encode_to_gif_file(mm_image_info_s **images, const unsigned int image_count, const char *path); -int mm_util_encode_to_gif_memory(mm_image_info_s **images, const unsigned int image_count, void **buffer, size_t *size); +int mm_util_encode_to_gif_file(mm_util_image_h *images, const unsigned int image_count, const char *file_path); +int mm_util_encode_to_gif_memory(mm_util_image_h *images, const unsigned int image_count, void **buffer, size_t *size); /* a-gif extras */ int mm_util_gif_encode_create(mm_gif_file_h *gif_file_h); diff --git a/gif/mm_util_gif.c b/gif/mm_util_gif.c index 1bb6f30..d2c6c48 100755 --- a/gif/mm_util_gif.c +++ b/gif/mm_util_gif.c @@ -610,7 +610,7 @@ int mm_util_gif_encode_set_mem(mm_gif_file_h gif_file_h, void **data, size_t *da return MM_UTIL_ERROR_NONE; } -static int _mm_util_gif_encode_start(mm_gif_file_h gif_file_h, unsigned long width, unsigned long height) +static int __mm_util_gif_encode_start(mm_gif_file_h gif_file_h, unsigned int width, unsigned int height) { int ret = MM_UTIL_ERROR_NONE; gif_file_s *gif_file = (gif_file_s *)gif_file_h; @@ -656,11 +656,12 @@ int mm_util_gif_encode_add_image(mm_gif_file_h gif_file_h, mm_image_info_s *gif_ mm_util_retvm_if(gif_image == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter"); mm_util_retvm_if((gif_image->width == 0) || (gif_image->height == 0), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter"); mm_util_retvm_if(gif_image->data == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter"); + mm_util_retvm_if(gif_image->color != MM_UTIL_COLOR_RGBA, MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported color [%d]", gif_image->color); if (gif_file->GifFile == NULL) { - mm_util_warn("first added image, _mm_util_gif_encode_start is needed"); - ret = _mm_util_gif_encode_start(gif_file_h, gif_image->width, gif_image->height); - mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "_mm_util_gif_encode_start failed"); + mm_util_warn("first added image, __mm_util_gif_encode_start is needed"); + ret = __mm_util_gif_encode_start(gif_file_h, gif_image->width, gif_image->height); + mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "__mm_util_gif_encode_start failed"); } /* Write graphic control block */ @@ -705,37 +706,38 @@ int mm_util_gif_encode_save(mm_gif_file_h gif_file_h) return MM_UTIL_ERROR_NONE; } -int mm_util_encode_to_gif_file(mm_image_info_s **images, const unsigned int image_count, const char *path) +int mm_util_encode_to_gif_file(mm_util_image_h *images, const unsigned int image_count, const char *file_path) { int ret = MM_UTIL_ERROR_NONE; + mm_image_info_s **_images = (mm_image_info_s **)images; int i = 0; mm_gif_file_h gif_file_h = NULL; mm_util_fenter(); - mm_util_retvm_if(images == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter"); - mm_util_retvm_if(image_count == 0, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter"); - mm_util_retvm_if(path == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter"); + mm_util_retvm_if(images == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid images"); + mm_util_retvm_if(image_count == 0, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid image_count"); + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid file_path"); ret = mm_util_gif_encode_create(&gif_file_h); mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "mm_util_gif_encode_create failed %d", ret); - ret = mm_util_gif_encode_set_file(gif_file_h, path); + ret = mm_util_gif_encode_set_file(gif_file_h, file_path); if (ret != MM_UTIL_ERROR_NONE) { mm_util_error("mm_util_gif_encode_set_file failed"); mm_util_gif_encode_destroy(gif_file_h); return ret; } - ret = _mm_util_gif_encode_start(gif_file_h, images[0]->width, images[0]->height); + ret = __mm_util_gif_encode_start(gif_file_h, _images[0]->width, _images[0]->height); if (ret != MM_UTIL_ERROR_NONE) { - mm_util_error("_mm_util_gif_encode_start failed"); + mm_util_error("__mm_util_gif_encode_start failed"); mm_util_gif_encode_destroy(gif_file_h); return ret; } for (i = 0; i < image_count; i++) { - ret = mm_util_gif_encode_add_image(gif_file_h, images[i]); + ret = mm_util_gif_encode_add_image(gif_file_h, _images[i]); if (ret != MM_UTIL_ERROR_NONE) { mm_util_error("mm_util_gif_encode_add_image failed"); mm_util_gif_encode_destroy(gif_file_h); @@ -755,16 +757,17 @@ int mm_util_encode_to_gif_file(mm_image_info_s **images, const unsigned int imag return MM_UTIL_ERROR_NONE; } -int mm_util_encode_to_gif_memory(mm_image_info_s **images, const unsigned int image_count, void **buffer, size_t *size) +int mm_util_encode_to_gif_memory(mm_util_image_h *images, const unsigned int image_count, void **buffer, size_t *size) { int ret = MM_UTIL_ERROR_NONE; + mm_image_info_s **_images = (mm_image_info_s **)images; int i = 0; mm_gif_file_h gif_file_h = NULL; mm_util_fenter(); - mm_util_retvm_if(images == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter"); - mm_util_retvm_if(image_count == 0, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter"); + mm_util_retvm_if(images == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid images"); + mm_util_retvm_if(image_count == 0, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid image_count"); mm_util_retvm_if(buffer == NULL || size == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter"); ret = mm_util_gif_encode_create(&gif_file_h); @@ -777,15 +780,15 @@ int mm_util_encode_to_gif_memory(mm_image_info_s **images, const unsigned int im return ret; } - ret = _mm_util_gif_encode_start(gif_file_h, images[0]->width, images[0]->height); + ret = __mm_util_gif_encode_start(gif_file_h, _images[0]->width, _images[0]->height); if (ret != MM_UTIL_ERROR_NONE) { - mm_util_error("_mm_util_gif_encode_start failed"); + mm_util_error("__mm_util_gif_encode_start failed"); mm_util_gif_encode_destroy(gif_file_h); return ret; } for (i = 0; i < image_count; i++) { - ret = mm_util_gif_encode_add_image(gif_file_h, images[i]); + ret = mm_util_gif_encode_add_image(gif_file_h, _images[i]); if (ret != MM_UTIL_ERROR_NONE) { mm_util_error("mm_util_gif_encode_add_image failed"); mm_util_gif_encode_destroy(gif_file_h); diff --git a/gif/test/mm_util_gif_testsuite.c b/gif/test/mm_util_gif_testsuite.c index a878fff..60bb4a2 100644 --- a/gif/test/mm_util_gif_testsuite.c +++ b/gif/test/mm_util_gif_testsuite.c @@ -295,13 +295,13 @@ gboolean _test_encode(const bmp_test_mode_e mode) /* test encoding gif */ if (mode == TEST_ENCODE_FILE) { - ret = mm_util_encode_to_gif_file((mm_image_info_s **)&g_decoded_data, 1, ENCODE_FILE_PATH); + ret = mm_util_encode_to_gif_file(&g_decoded_data, 1, ENCODE_FILE_PATH); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[GIF_testsuite] mm_util_encode_gif_to_file failed : %d\n", ret); return FALSE; } } else if (mode == TEST_ENCODE_MEMORY) { - ret = mm_util_encode_to_gif_memory((mm_image_info_s **)&g_decoded_data, 1, &encoded_data, &encoded_size); + ret = mm_util_encode_to_gif_memory(&g_decoded_data, 1, &encoded_data, &encoded_size); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[GIF_testsuite] mm_util_encode_gif_to_memory failed : %d\n", ret); SAFE_FREE(encoded_data); diff --git a/gif/unittest/libmm_gif_unittest.cpp b/gif/unittest/libmm_gif_unittest.cpp index 296f09f..dc6333f 100644 --- a/gif/unittest/libmm_gif_unittest.cpp +++ b/gif/unittest/libmm_gif_unittest.cpp @@ -106,7 +106,7 @@ TEST(libmm_gif_Test, mm_util_encode_to_gif_file_p) EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_gif_file((mm_image_info_s **)&decode_image, 1, ENCODE_FILE_PATH); + ret = mm_util_encode_to_gif_file(&decode_image, 1, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); mm_image_destroy_image(decode_image); @@ -115,14 +115,19 @@ TEST(libmm_gif_Test, mm_util_encode_to_gif_file_p) TEST(libmm_gif_Test, mm_util_encode_to_gif_file_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; - mm_image_info_s *ptr_decode_image = &decode_image; + mm_util_image_h decode_image = NULL; + + ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); ret = mm_util_encode_to_gif_file(NULL, 1, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_to_gif_file(&ptr_decode_image, 1, NULL); + ret = mm_util_encode_to_gif_file(&decode_image, 1, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + + mm_image_destroy_image(decode_image); } TEST(libmm_gif_Test, mm_util_encode_to_gif_memory_p) @@ -136,7 +141,7 @@ TEST(libmm_gif_Test, mm_util_encode_to_gif_memory_p) EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_gif_memory((mm_image_info_s **)&decode_image, 1, &buffer, &size); + ret = mm_util_encode_to_gif_memory(&decode_image, 1, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(buffer != NULL); EXPECT_NE(size, 0); @@ -150,19 +155,24 @@ TEST(libmm_gif_Test, mm_util_encode_to_gif_memory_p) TEST(libmm_gif_Test, mm_util_encode_to_gif_memory_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; - mm_image_info_s *ptr_decode_image = &decode_image; + mm_util_image_h decode_image = NULL; void *buffer = NULL; size_t size = 0; + ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); + ret = mm_util_encode_to_gif_memory(NULL, 1, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_to_gif_memory(&ptr_decode_image, 1, NULL, &size); + ret = mm_util_encode_to_gif_memory(&decode_image, 1, NULL, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_to_gif_memory(&ptr_decode_image, 1, &buffer, NULL); + ret = mm_util_encode_to_gif_memory(&decode_image, 1, &buffer, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + + mm_image_destroy_image(decode_image); } int main(int argc, char **argv) diff --git a/jpeg/include/mm_util_jpeg.h b/jpeg/include/mm_util_jpeg.h index b6a9a42..b7febc0 100755 --- a/jpeg/include/mm_util_jpeg.h +++ b/jpeg/include/mm_util_jpeg.h @@ -46,9 +46,9 @@ typedef enum { MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8 = 8, /** 1/8 downscale decode */ } mm_util_jpeg_decode_downscale; -int mm_util_jpeg_encode_to_file(mm_image_info_s *decoded, int quality, const char *filename); -int mm_util_jpeg_encode_to_memory(void **mem, unsigned int *size, unsigned char *src, unsigned int width, unsigned int height, mm_util_color_format_e color, int quality); -int mm_util_encode_to_jpeg_memory(mm_image_info_s *decoded, int quality, void **mem, size_t *size); +int mm_util_jpeg_encode_to_file(mm_util_image_h decoded, int quality, const char *file_path); +int mm_util_jpeg_encode_to_memory(void **buffer, unsigned int *size, unsigned char *src, unsigned int width, unsigned int height, mm_util_color_format_e color, int quality); +int mm_util_encode_to_jpeg_memory(mm_util_image_h decoded, int quality, void **buffer, size_t *size); int mm_util_decode_from_jpeg_file(const char *file_path, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_util_image_h *decoded); int mm_util_decode_from_jpeg_memory(void *memory, const size_t src_size, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_util_image_h *decoded); diff --git a/jpeg/mm_util_jpeg.c b/jpeg/mm_util_jpeg.c index 82b9300..4d2ead5 100644 --- a/jpeg/mm_util_jpeg.c +++ b/jpeg/mm_util_jpeg.c @@ -88,28 +88,29 @@ static gboolean _mm_util_is_supported_color_format(mm_util_color_format_e color_ return _bool; } -static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_format, void *rawdata, unsigned int width, unsigned int height, mm_util_color_format_e color_format, int quality, FILE *fp, void **mem, size_t *csize) +static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_format, mm_util_image_h decoded, int quality, FILE *fp, void **mem, size_t *csize) { - int iErrorCode = MM_UTIL_ERROR_NONE; + int ret = MM_UTIL_ERROR_NONE; + mm_image_info_s *_decoded = (mm_image_info_s *)decoded; mm_util_retvm_if((control_format != MM_UTIL_JPEG_FILE) && (control_format != MM_UTIL_JPEG_MEM), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid control_format [%u]", control_format); mm_util_retvm_if((control_format == MM_UTIL_JPEG_FILE) && (fp == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid fp"); mm_util_retvm_if((control_format == MM_UTIL_JPEG_MEM) && ((mem == NULL) || (csize == NULL)), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src or csize"); - mm_util_retvm_if(rawdata == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid rawdata"); + mm_util_retvm_if(!IS_VALID_IMAGE(decoded), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image"); JSAMPROW y[16], cb[16], cr[16]; /* y[2][5] = color sample of row 2 and pixel column 5; (one plane) */ JSAMPARRAY data[3]; /* t[0][2][5] = color sample 0 of row 2 and column 5 */ struct jpeg_compress_struct cinfo; struct jpeg_error_mgr jerr; - int i, j, flag, _height; + int i, j, flag, _width, _height; unsigned long size = 0; data[0] = y; data[1] = cb; data[2] = cr; - mm_util_debug("rawdata[%p] width[%u] height[%u] color_format[%u] quality[%d]", rawdata, width, height, color_format, quality); + mm_util_debug("quality[%d]", quality); cinfo.err = jpeg_std_error(&jerr); /* Errors get written to stderr */ @@ -123,11 +124,10 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for mm_util_debug("jpeg_mem_dest"); } - cinfo.image_width = width; - cinfo.image_height = height; - if (color_format == MM_UTIL_COLOR_YUV420 || color_format == MM_UTIL_COLOR_YUV422 || color_format == MM_UTIL_COLOR_UYVY) { - _height = MM_UTIL_ROUND_DOWN_16(height); - flag = height - _height; + _width = cinfo.image_width = _decoded->width; + _height = cinfo.image_height = _decoded->height; + if (_decoded->color == MM_UTIL_COLOR_YUV420 || _decoded->color == MM_UTIL_COLOR_YUV422 || _decoded->color == MM_UTIL_COLOR_UYVY) { + flag = cinfo.image_height - MM_UTIL_ROUND_DOWN_16(_height); cinfo.input_components = 3; cinfo.in_color_space = JCS_YCbCr; @@ -138,9 +138,9 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for cinfo.do_fancy_downsampling = FALSE; cinfo.comp_info[0].h_samp_factor = 2; - if (color_format == MM_UTIL_COLOR_YUV420) + if (_decoded->color == MM_UTIL_COLOR_YUV420) cinfo.comp_info[0].v_samp_factor = 2; - else if (color_format == MM_UTIL_COLOR_YUV422 || color_format == MM_UTIL_COLOR_UYVY) + else if (_decoded->color == MM_UTIL_COLOR_YUV422 || _decoded->color == MM_UTIL_COLOR_UYVY) cinfo.comp_info[0].v_samp_factor = 1; cinfo.comp_info[1].h_samp_factor = 1; cinfo.comp_info[1].v_samp_factor = 1; @@ -155,17 +155,17 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for mm_util_debug("jpeg_start_compress"); if (flag) { - void *large_rect = calloc(1, width); - void *small_rect = calloc(1, width); + void *large_rect = calloc(1, _width); + void *small_rect = calloc(1, _width); if (large_rect) { - memset(large_rect, 0x10, width); + memset(large_rect, 0x10, _width); } else { MMUTIL_SAFE_FREE(small_rect); mm_util_error("large rectangle memory"); return MM_UTIL_ERROR_INVALID_PARAMETER; } if (small_rect) { - memset(small_rect, 0x80, width); + memset(small_rect, 0x80, _width); } else { MMUTIL_SAFE_FREE(large_rect); mm_util_error("small rectangle memory"); @@ -174,19 +174,19 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for for (j = 0; j < _height; j += 16) { for (i = 0; i < 16; i++) { - y[i] = (JSAMPROW)rawdata + width * (i + j); + y[i] = (JSAMPROW)_decoded->data + _width * (i + j); if (i % 2 == 0) { - cb[i / 2] = (JSAMPROW)rawdata + width * height + width / 2 * ((i + j) / 2); - cr[i / 2] = (JSAMPROW)rawdata + width * height + width * height / 4 + width / 2 * ((i + j) / 2); + cb[i / 2] = (JSAMPROW)_decoded->data + _width * _height + _width / 2 * ((i + j) / 2); + cr[i / 2] = (JSAMPROW)_decoded->data + _width * _height + _width * _height / 4 + _width / 2 * ((i + j) / 2); } } jpeg_write_raw_data(&cinfo, data, 16); } for (i = 0; i < flag; i++) { - y[i] = (JSAMPROW)rawdata + width * (i + j); + y[i] = (JSAMPROW)_decoded->data + _width * (i + j); if (i % 2 == 0) { - cb[i / 2] = (JSAMPROW)rawdata + width * height + width / 2 * ((i + j) / 2); - cr[i / 2] = (JSAMPROW)rawdata + width * height + width * height / 4 + width / 2 * ((i + j) / 2); + cb[i / 2] = (JSAMPROW)_decoded->data + _width * _height + _width / 2 * ((i + j) / 2); + cr[i / 2] = (JSAMPROW)_decoded->data + _width * _height + _width * _height / 4 + _width / 2 * ((i + j) / 2); } } for (; i < 16; i++) { @@ -200,12 +200,12 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for MMUTIL_SAFE_FREE(large_rect); MMUTIL_SAFE_FREE(small_rect); } else { - for (j = 0; j < height; j += 16) { + for (j = 0; j < _height; j += 16) { for (i = 0; i < 16; i++) { - y[i] = (JSAMPROW)rawdata + width * (i + j); + y[i] = (JSAMPROW)_decoded->data + _width * (i + j); if (i % 2 == 0) { - cb[i / 2] = (JSAMPROW)rawdata + width * height + width / 2 * ((i + j) / 2); - cr[i / 2] = (JSAMPROW)rawdata + width * height + width * height / 4 + width / 2 * ((i + j) / 2); + cb[i / 2] = (JSAMPROW)_decoded->data + _width * _height + _width / 2 * ((i + j) / 2); + cr[i / 2] = (JSAMPROW)_decoded->data + _width * _height + _width * _height / 4 + _width / 2 * ((i + j) / 2); } } jpeg_write_raw_data(&cinfo, data, 16); @@ -220,27 +220,27 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for mm_util_debug("jpeg_destroy_compress"); } - else if (color_format == MM_UTIL_COLOR_RGB24 || color_format == MM_UTIL_COLOR_GRAYSCALE || color_format == MM_UTIL_COLOR_RGBA || color_format == MM_UTIL_COLOR_BGRA || color_format == MM_UTIL_COLOR_ARGB) { + else if (_decoded->color == MM_UTIL_COLOR_RGB24 || _decoded->color == MM_UTIL_COLOR_GRAYSCALE || _decoded->color == MM_UTIL_COLOR_RGBA || _decoded->color == MM_UTIL_COLOR_BGRA || _decoded->color == MM_UTIL_COLOR_ARGB) { JSAMPROW row_pointer[1]; unsigned int iRowStride = 0; - if (color_format == MM_UTIL_COLOR_RGB24) { + if (_decoded->color == MM_UTIL_COLOR_RGB24) { cinfo.input_components = 3; cinfo.in_color_space = JCS_RGB; mm_util_debug("JCS_RGB"); - } else if (color_format == MM_UTIL_COLOR_GRAYSCALE) { + } else if (_decoded->color == MM_UTIL_COLOR_GRAYSCALE) { cinfo.input_components = 1; /* one colour component */ cinfo.in_color_space = JCS_GRAYSCALE; mm_util_debug("JCS_GRAYSCALE"); - } else if (color_format == MM_UTIL_COLOR_RGBA) { + } else if (_decoded->color == MM_UTIL_COLOR_RGBA) { cinfo.input_components = 4; cinfo.in_color_space = JCS_EXT_RGBA; mm_util_debug("JCS_EXT_RGBA"); - } else if (color_format == MM_UTIL_COLOR_BGRA) { + } else if (_decoded->color == MM_UTIL_COLOR_BGRA) { cinfo.input_components = 4; cinfo.in_color_space = JCS_EXT_BGRA; mm_util_debug("JCS_EXT_BGRA"); - } else if (color_format == MM_UTIL_COLOR_ARGB) { + } else if (_decoded->color == MM_UTIL_COLOR_ARGB) { cinfo.input_components = 4; cinfo.in_color_space = JCS_EXT_ARGB; mm_util_debug("JCS_EXT_ARGB"); @@ -252,14 +252,14 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for mm_util_debug("jpeg_set_quality"); jpeg_start_compress(&cinfo, TRUE); mm_util_debug("jpeg_start_compress"); - if (color_format == MM_UTIL_COLOR_RGB24) - iRowStride = width * 3; - else if (color_format == MM_UTIL_COLOR_GRAYSCALE) - iRowStride = width; - else if (color_format == MM_UTIL_COLOR_RGBA || color_format == MM_UTIL_COLOR_BGRA || color_format == MM_UTIL_COLOR_ARGB) - iRowStride = width * 4; - - JSAMPLE *image_buffer = (JSAMPLE *)rawdata; + if (_decoded->color == MM_UTIL_COLOR_RGB24) + iRowStride = _width * 3; + else if (_decoded->color == MM_UTIL_COLOR_GRAYSCALE) + iRowStride = _width; + else if (_decoded->color == MM_UTIL_COLOR_RGBA || _decoded->color == MM_UTIL_COLOR_BGRA || _decoded->color == MM_UTIL_COLOR_ARGB) + iRowStride = _width * 4; + + JSAMPLE *image_buffer = (JSAMPLE *)_decoded->data; while (cinfo.next_scanline < cinfo.image_height) { row_pointer[0] = &image_buffer[cinfo.next_scanline * iRowStride]; jpeg_write_scanlines(&cinfo, row_pointer, 1); @@ -279,7 +279,7 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for if (control_format == MM_UTIL_JPEG_MEM) *csize = (size_t)size; - return iErrorCode; + return ret; } static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_format, FILE *fp, void *src, size_t size, mm_util_color_format_e color_format, mm_util_jpeg_decode_downscale downscale, mm_util_image_h *decoded) @@ -465,66 +465,57 @@ static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_for return ret; } -int mm_util_jpeg_encode_to_file(mm_image_info_s *decoded, int quality, const char *filename) +int mm_util_jpeg_encode_to_file(mm_util_image_h decoded, int quality, const char *file_path) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s *_converted_image = NULL; + mm_image_info_s *_decoded = (mm_image_info_s *)decoded; + mm_util_image_h _converted_image = NULL; mm_util_fenter(); - mm_util_retvm_if(filename == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid filename"); - mm_util_retvm_if(decoded == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src"); - mm_util_retvm_if(decoded->data == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src data"); - mm_util_retvm_if((decoded->width <= 0) || (decoded->height <= 0), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid width[%u] height[%u]", decoded->width, decoded->height); - mm_util_retvm_if((IS_VALID_COLOR(decoded->color) == FALSE), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid fmt [%d]", decoded->color); - mm_util_retvm_if((!_mm_util_is_supported_color_format(decoded->color)), MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported fmt [%d]", decoded->color); + mm_util_retvm_if(!file_path, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid file_path"); + mm_util_retvm_if(!IS_VALID_IMAGE(decoded), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image"); + mm_util_retvm_if((!_mm_util_is_supported_color_format(_decoded->color)), MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported fmt [%d]", _decoded->color); mm_util_retvm_if((quality < 1) || (quality > 100), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid quality [%d]", quality); - mm_util_debug("#START# LIBJPEG"); FILE *fp = NULL; - ret = mm_util_safe_fopen(filename, "wb", &fp); + ret = mm_util_safe_fopen(file_path, "wb", &fp); mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "mm_util_safe_fopen fail (%d)", ret); - if (decoded->color == MM_UTIL_COLOR_NV12) { - ret = mm_util_convert_colorspace(decoded, MM_UTIL_COLOR_YUV420, (mm_util_image_h *)&_converted_image); + if (_decoded->color == MM_UTIL_COLOR_NV12) { + ret = mm_util_convert_colorspace(decoded, MM_UTIL_COLOR_YUV420, &_converted_image); if (ret != MM_UTIL_ERROR_NONE) { mm_util_error("mm_util_convert_image failed (%d)", ret); mm_util_safe_fclose(fp); return ret; } - ret = __mm_image_encode_with_libjpeg(MM_UTIL_JPEG_FILE, _converted_image->data, _converted_image->width, _converted_image->height, MM_UTIL_COLOR_YUV420, quality, fp, NULL, NULL); + ret = __mm_image_encode_with_libjpeg(MM_UTIL_JPEG_FILE, _converted_image, quality, fp, NULL, NULL); mm_image_destroy_image(_converted_image); } else { - ret = __mm_image_encode_with_libjpeg(MM_UTIL_JPEG_FILE, decoded->data, decoded->width, decoded->height, decoded->color, quality, fp, NULL, NULL); + ret = __mm_image_encode_with_libjpeg(MM_UTIL_JPEG_FILE, decoded, quality, fp, NULL, NULL); } fsync((int)(fp->_fileno)); mm_util_safe_fclose(fp); - mm_util_debug("#End# libjpeg, Success!! ret: %d", ret); - mm_util_fleave(); return ret; } -int mm_util_jpeg_encode_to_memory(void **mem, unsigned int *size, unsigned char *src, unsigned int width, unsigned int height, mm_util_color_format_e color, int quality) +int mm_util_jpeg_encode_to_memory(void **buffer, unsigned int *size, unsigned char *src, unsigned int width, unsigned int height, mm_util_color_format_e color, int quality) { int ret = MM_UTIL_ERROR_NONE; size_t encoded_size = 0; + mm_util_image_h decoded = NULL; - mm_image_info_s decoded; - memset(&decoded, 0, sizeof(mm_image_info_s)); - - mm_util_retvm_if(size == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid size"); + mm_util_retvm_if(!size, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid size"); - decoded.width = width; - decoded.height = height; - decoded.color = color; - decoded.data = src; + ret = mm_image_create_image(width, height, color, src, TEMP_DATA_SIZE, &decoded); + mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "mm_image_create_image fail (%d)", ret); - ret = mm_util_encode_to_jpeg_memory(&decoded, quality, mem, &encoded_size); + ret = mm_util_encode_to_jpeg_memory(decoded, quality, buffer, &encoded_size); mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "mm_util_encode_to_jpeg_memory fail (%d)", ret); *size = (unsigned int)encoded_size; @@ -532,33 +523,29 @@ int mm_util_jpeg_encode_to_memory(void **mem, unsigned int *size, unsigned char return ret; } -int mm_util_encode_to_jpeg_memory(mm_image_info_s *decoded, int quality, void **mem, size_t *size) +int mm_util_encode_to_jpeg_memory(mm_util_image_h decoded, int quality, void **buffer, size_t *size) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s *_converted_image = NULL; + mm_image_info_s *_decoded = (mm_image_info_s *)decoded; + mm_util_image_h _converted_image = NULL; mm_util_fenter(); - mm_util_retvm_if(mem == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid filename"); - mm_util_retvm_if(size == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid size"); - mm_util_retvm_if(decoded == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src"); - mm_util_retvm_if(decoded->data == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src data"); - mm_util_retvm_if((decoded->width <= 0) || (decoded->height <= 0), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid width[%u] height[%u]", decoded->width, decoded->height); - mm_util_retvm_if((IS_VALID_COLOR(decoded->color) == FALSE), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid fmt [%d]", decoded->color); - mm_util_retvm_if((!_mm_util_is_supported_color_format(decoded->color)), MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported fmt [%d]", decoded->color); + mm_util_retvm_if(!buffer, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid buffer"); + mm_util_retvm_if(!size, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid size"); + mm_util_retvm_if(!IS_VALID_IMAGE(decoded), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image"); + mm_util_retvm_if((!_mm_util_is_supported_color_format(_decoded->color)), MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported color [%d]", _decoded->color); mm_util_retvm_if((quality < 1) || (quality > 100), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid quality [%d]", quality); - mm_util_debug("#START# libjpeg"); - if (decoded->color == MM_UTIL_COLOR_NV12) { - ret = mm_util_convert_colorspace(decoded, MM_UTIL_COLOR_YUV420, (mm_util_image_h *)&_converted_image); + if (_decoded->color == MM_UTIL_COLOR_NV12) { + ret = mm_util_convert_colorspace(decoded, MM_UTIL_COLOR_YUV420, &_converted_image); mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "mm_util_convert_image fail (%d)", ret); - ret = __mm_image_encode_with_libjpeg(MM_UTIL_JPEG_MEM, _converted_image->data, _converted_image->width, _converted_image->height, MM_UTIL_COLOR_YUV420, quality, NULL, mem, size); + ret = __mm_image_encode_with_libjpeg(MM_UTIL_JPEG_MEM, _converted_image, quality, NULL, buffer, size); mm_image_destroy_image(_converted_image); } else { - ret = __mm_image_encode_with_libjpeg(MM_UTIL_JPEG_MEM, decoded->data, decoded->width, decoded->height, decoded->color, quality, NULL, mem, size); + ret = __mm_image_encode_with_libjpeg(MM_UTIL_JPEG_MEM, decoded, quality, NULL, buffer, size); } - mm_util_debug("#END# libjpeg, Success!! ret: %d", ret); mm_util_fleave(); diff --git a/jpeg/test/mm_util_jpeg_testsuite.c b/jpeg/test/mm_util_jpeg_testsuite.c index 9a8be07..ee99e04 100644 --- a/jpeg/test/mm_util_jpeg_testsuite.c +++ b/jpeg/test/mm_util_jpeg_testsuite.c @@ -321,13 +321,13 @@ gboolean _test_encode(const jpeg_test_mode_e mode) /* test encoding jpeg */ if (mode == TEST_ENCODE_FILE) { - ret = mm_util_jpeg_encode_to_file((mm_image_info_s *)g_decoded_data, g_quality, ENCODE_FILE_PATH); + ret = mm_util_jpeg_encode_to_file(g_decoded_data, g_quality, ENCODE_FILE_PATH); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[JPEG_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); return FALSE; } } else if (mode == TEST_ENCODE_MEMORY) { - ret = mm_util_encode_to_jpeg_memory((mm_image_info_s *)g_decoded_data, g_quality, &encoded_data, &encoded_size); + ret = mm_util_encode_to_jpeg_memory(g_decoded_data, g_quality, &encoded_data, &encoded_size); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[JPEG_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); SAFE_FREE(encoded_data); diff --git a/jpeg/unittest/libmm_jpeg_unittest.cpp b/jpeg/unittest/libmm_jpeg_unittest.cpp index 2e35028..659a3f5 100644 --- a/jpeg/unittest/libmm_jpeg_unittest.cpp +++ b/jpeg/unittest/libmm_jpeg_unittest.cpp @@ -113,7 +113,7 @@ TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_file_p) EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_jpeg_encode_to_file((mm_image_info_s *)decode_image, 100, ENCODE_FILE_PATH); + ret = mm_util_jpeg_encode_to_file(decode_image, 100, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); mm_image_destroy_image(decode_image); @@ -127,10 +127,10 @@ TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_file_n) ret = mm_util_jpeg_encode_to_file(NULL, 100, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_jpeg_encode_to_file(&decode_image, 0, ENCODE_FILE_PATH); + ret = mm_util_jpeg_encode_to_file((mm_util_image_h)&decode_image, 0, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_jpeg_encode_to_file(&decode_image, 100, NULL); + ret = mm_util_jpeg_encode_to_file((mm_util_image_h)&decode_image, 100, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); } @@ -146,7 +146,7 @@ TEST(libmm_jpeg_Test, mm_util_encode_to_jpeg_memory_p) EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_jpeg_memory((mm_image_info_s *)decode_image, 100, &buffer, &size); + ret = mm_util_encode_to_jpeg_memory(decode_image, 100, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(buffer != NULL); EXPECT_NE(size, 0); @@ -167,10 +167,10 @@ TEST(libmm_jpeg_Test, mm_util_encode_to_jpeg_memory_n) ret = mm_util_encode_to_jpeg_memory(NULL, 100, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_to_jpeg_memory(&decode_image, 100, NULL, &size); + ret = mm_util_encode_to_jpeg_memory((mm_util_image_h)&decode_image, 100, NULL, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_to_jpeg_memory(&decode_image, 100, &buffer, NULL); + ret = mm_util_encode_to_jpeg_memory((mm_util_image_h)&decode_image, 100, &buffer, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); } diff --git a/png/include/mm_util_png.h b/png/include/mm_util_png.h index 6a10874..b326447 100755 --- a/png/include/mm_util_png.h +++ b/png/include/mm_util_png.h @@ -52,8 +52,8 @@ typedef enum { int mm_util_decode_from_png_file(const char *file_path, mm_util_image_h *decoded); int mm_util_decode_from_png_memory(void *memory, const size_t src_size, mm_util_image_h *decoded); -int mm_util_encode_to_png_file(mm_image_info_s *decoded, mm_util_png_compression compression_level, const char *fpath); -int mm_util_encode_to_png_memory(mm_image_info_s *decoded, mm_util_png_compression compression_level, void **data, size_t *size); +int mm_util_encode_to_png_file(mm_util_image_h decoded, mm_util_png_compression compression_level, const char *file_path); +int mm_util_encode_to_png_memory(mm_util_image_h decoded, mm_util_png_compression compression_level, void **buffer, size_t *size); #ifdef __cplusplus } diff --git a/png/mm_util_png.c b/png/mm_util_png.c index d5fc22d..1ba36c2 100755 --- a/png/mm_util_png.c +++ b/png/mm_util_png.c @@ -231,8 +231,9 @@ static int __read_png(FILE *fp, void *memory, const size_t memory_size, mm_util_ return ret; } -int _write_png(mm_image_info_s *decoded, mm_util_png_compression compression_level, FILE *fp, void **buffer, size_t *size) +static int __write_png(mm_util_image_h *decoded, mm_util_png_compression compression_level, FILE *fp, void **buffer, size_t *size) { + mm_image_info_s *_decoded = (mm_image_info_s *)decoded; png_structp png_ptr; png_infop info_ptr; guint row_index; @@ -241,8 +242,11 @@ int _write_png(mm_image_info_s *decoded, mm_util_png_compression compression_lev png_mem_s png_mem_ptr = {NULL, 0}; png_property_s png_prop; - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - mm_util_retvm_if(((fp == NULL) && (buffer == NULL || size == NULL)), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid png image"); + mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image src"); + mm_util_retvm_if(!fp && (!buffer || !size), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid parameter"); + mm_util_retvm_if(_decoded->color != MM_UTIL_COLOR_RGBA, MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported color [%d]", _decoded->color); + + mm_util_fenter(); /* initialize png_prop */ png_prop.filter = PNG_FILTER_NONE; @@ -282,11 +286,11 @@ int _write_png(mm_image_info_s *decoded, mm_util_png_compression compression_lev /* set properties(header) from png_prop */ png_set_filter(png_ptr, 0, png_prop.filter); png_set_compression_level(png_ptr, compression_level); - png_set_IHDR(png_ptr, info_ptr, decoded->width, decoded->height, png_prop.bit_depth, png_prop.color_type, png_prop.interlace_type, png_prop.compression_type, png_prop.filter_type); + png_set_IHDR(png_ptr, info_ptr, _decoded->width, _decoded->height, png_prop.bit_depth, png_prop.color_type, png_prop.interlace_type, png_prop.compression_type, png_prop.filter_type); rowbytes = (size_t)png_get_rowbytes(png_ptr, info_ptr); - row_pointers = png_malloc(png_ptr, sizeof(png_bytep) * decoded->height); + row_pointers = png_malloc(png_ptr, sizeof(png_bytep) * _decoded->height); if (row_pointers == NULL) { mm_util_error("out of memory"); png_destroy_write_struct(&png_ptr, &info_ptr); @@ -294,8 +298,8 @@ int _write_png(mm_image_info_s *decoded, mm_util_png_compression compression_lev } /* write png data */ - for (row_index = 0; row_index < decoded->height; row_index++) - row_pointers[row_index] = decoded->data + (row_index * rowbytes); + for (row_index = 0; row_index < _decoded->height; row_index++) + row_pointers[row_index] = _decoded->data + (row_index * rowbytes); png_write_info(png_ptr, info_ptr); png_write_image(png_ptr, row_pointers); @@ -310,6 +314,8 @@ int _write_png(mm_image_info_s *decoded, mm_util_png_compression compression_lev *size = png_mem_ptr.size; } + mm_util_fleave(); + return MM_UTIL_ERROR_NONE; } @@ -341,17 +347,17 @@ int mm_util_decode_from_png_memory(void *memory, const size_t src_size, mm_util_ return __read_png(NULL, memory, src_size, decoded); } -int mm_util_encode_to_png_file(mm_image_info_s *decoded, mm_util_png_compression compression_level, const char *fpath) +int mm_util_encode_to_png_file(mm_util_image_h decoded, mm_util_png_compression compression_level, const char *file_path) { int ret = MM_UTIL_ERROR_NONE; FILE *fp = NULL; mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - mm_util_retvm_if(!MMUTIL_STRING_VALID(fpath), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid path"); + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid file_path"); - mm_util_fenter(); + mm_util_sec_debug("Save to file [%s]", file_path); - ret = mm_util_safe_fopen(fpath, "w", &fp); + ret = mm_util_safe_fopen(file_path, "w", &fp); if (ret != MM_UTIL_ERROR_NONE) { mm_util_error("mm_util_safe_fopen failed (%d)", ret); mm_util_safe_fclose(fp); @@ -359,31 +365,17 @@ int mm_util_encode_to_png_file(mm_image_info_s *decoded, mm_util_png_compression return ret; } - ret = _write_png(decoded, compression_level, fp, NULL, NULL); - if (ret != MM_UTIL_ERROR_NONE) - mm_util_error("_write_png failed (%d)", ret); + ret = __write_png(decoded, compression_level, fp, NULL, NULL); mm_util_safe_fclose(fp); - mm_util_fleave(); - return ret; } -int mm_util_encode_to_png_memory(mm_image_info_s *decoded, mm_util_png_compression compression_level, void **data, size_t *size) +int mm_util_encode_to_png_memory(mm_util_image_h decoded, mm_util_png_compression compression_level, void **buffer, size_t *size) { - int ret = MM_UTIL_ERROR_NONE; - - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - mm_util_retvm_if((data == NULL || size == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid png image"); - - mm_util_fenter(); + mm_util_retvm_if(!buffer, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid buffer"); + mm_util_retvm_if(!size, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid size"); - ret = _write_png(decoded, compression_level, NULL, data, size); - if (ret != MM_UTIL_ERROR_NONE) - mm_util_error("_write_png failed (%d)", ret); - - mm_util_fleave(); - - return ret; + return __write_png(decoded, compression_level, NULL, buffer, size); } diff --git a/png/test/mm_util_png_testsuite.c b/png/test/mm_util_png_testsuite.c index 5ebc60c..8fc4259 100644 --- a/png/test/mm_util_png_testsuite.c +++ b/png/test/mm_util_png_testsuite.c @@ -302,13 +302,13 @@ gboolean _test_encode(const png_test_mode_e mode) /* test encoding png */ if (mode == TEST_ENCODE_FILE) { - ret = mm_util_encode_to_png_file((mm_image_info_s *)g_decoded_data, g_compression, ENCODE_FILE_PATH); + ret = mm_util_encode_to_png_file(g_decoded_data, g_compression, ENCODE_FILE_PATH); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[PNG_testsuite] mm_util_encode_to_png_file failed : %d\n", ret); return FALSE; } } else if (mode == TEST_ENCODE_MEMORY) { - ret = mm_util_encode_to_png_memory((mm_image_info_s *)g_decoded_data, g_compression, &encoded_data, &encoded_size); + ret = mm_util_encode_to_png_memory(g_decoded_data, g_compression, &encoded_data, &encoded_size); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[PNG_testsuite] mm_util_encode_to_png_memory failed : %d\n", ret); SAFE_FREE(encoded_data); diff --git a/png/unittest/libmm_png_unittest.cpp b/png/unittest/libmm_png_unittest.cpp index e67e7ba..11e6551 100644 --- a/png/unittest/libmm_png_unittest.cpp +++ b/png/unittest/libmm_png_unittest.cpp @@ -106,7 +106,7 @@ TEST(libmm_png_Test, mm_util_encode_to_png_file_p) EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_png_file((mm_image_info_s *)decode_image, MM_UTIL_COMPRESSION_6, ENCODE_FILE_PATH); + ret = mm_util_encode_to_png_file(decode_image, MM_UTIL_COMPRESSION_6, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); mm_image_destroy_image(decode_image); @@ -115,13 +115,19 @@ TEST(libmm_png_Test, mm_util_encode_to_png_file_p) TEST(libmm_png_Test, mm_util_encode_to_png_file_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; + + ret = mm_util_decode_from_png_file(DECODE_FILE_PATH, &decode_image); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); ret = mm_util_encode_to_png_file(NULL, MM_UTIL_COMPRESSION_6, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_to_png_file(&decode_image, MM_UTIL_COMPRESSION_6, NULL); + ret = mm_util_encode_to_png_file(decode_image, MM_UTIL_COMPRESSION_6, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + + mm_image_destroy_image(decode_image); } TEST(libmm_png_Test, mm_util_encode_to_png_memory_p) @@ -135,7 +141,7 @@ TEST(libmm_png_Test, mm_util_encode_to_png_memory_p) EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_png_memory((mm_image_info_s *)decode_image, MM_UTIL_COMPRESSION_6, &buffer, &size); + ret = mm_util_encode_to_png_memory(decode_image, MM_UTIL_COMPRESSION_6, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(buffer != NULL); EXPECT_NE(size, 0); @@ -149,18 +155,24 @@ TEST(libmm_png_Test, mm_util_encode_to_png_memory_p) TEST(libmm_png_Test, mm_util_encode_to_png_memory_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; void *buffer = NULL; size_t size = 0; + ret = mm_util_decode_from_png_file(DECODE_FILE_PATH, &decode_image); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); + ret = mm_util_encode_to_png_memory(NULL, MM_UTIL_COMPRESSION_6, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_to_png_memory(&decode_image, MM_UTIL_COMPRESSION_6, NULL, &size); + ret = mm_util_encode_to_png_memory(decode_image, MM_UTIL_COMPRESSION_6, NULL, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_encode_to_png_memory(&decode_image, MM_UTIL_COMPRESSION_6, &buffer, NULL); + ret = mm_util_encode_to_png_memory(decode_image, MM_UTIL_COMPRESSION_6, &buffer, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + + mm_image_destroy_image(decode_image); } int main(int argc, char **argv) -- 2.7.4