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
}
}
/* 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];
}
}
- /* 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;
}
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);
}
/* 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);
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);
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)
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);
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)
#define __MM_UTIL_IMAGE_H__
#include <glib.h>
+#include <stdint.h>
#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);
_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;
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;
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);
}
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);
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;
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 */
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);
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);
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);
/* 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);
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);
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)
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);
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)
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);
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 */
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;
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;
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");
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++) {
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);
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");
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);
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)
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;
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();
/* 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);
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);
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);
}
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);
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);
}
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
}
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;
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;
/* 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);
}
/* 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);
*size = png_mem_ptr.size;
}
+ mm_util_fleave();
+
return MM_UTIL_ERROR_NONE;
}
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);
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);
}
/* 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);
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);
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)
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);
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)
projects / platform / core / multimedia / libmm-utility.git / commitdiff