Modify animated gif writing to file and to buffer

 - Encoding checked writing to file or to buffer during working. Encoding is
   no needed to check it because encoding use buffer to get intermediate output.
   After modifying it, it check writing to file or to buffer right before
   saving the final outcome.

Change-Id: I979720f1fe75dcdf9c2a08deb92e50b055cbfe68

diff --git a/common/include/mm_util_private.h b/common/include/mm_util_private.h
old mode 100755 (executable)
new mode 100644 (file)
index 081ba42..475ceb5
--- a/common/include/mm_util_private.h
+++ b/common/include/mm_util_private.h
@@ -55,6 +55,7 @@ extern "C" {
 gboolean mm_util_is_valid_color_format(mm_util_color_format_e color);
 
 int mm_util_safe_fopen(const char *path, const char *mode, FILE **fp);
+int mm_util_safe_fwrite(FILE *fp, const void *data, size_t length);
 void mm_util_safe_fclose(FILE *fp);
 
 #ifdef __cplusplus

diff --git a/common/mm_util_private.c b/common/mm_util_private.c
index 57d9bd8..9525bf3 100644 (file)
--- a/common/mm_util_private.c
+++ b/common/mm_util_private.c
@@ -73,6 +73,20 @@ int mm_util_safe_fopen(const char *path, const char *mode, FILE **fp)
        return MM_UTIL_ERROR_NONE;
 }
 
+int mm_util_safe_fwrite(FILE *fp, const void *data, size_t length)
+{
+       size_t len = 0;
+
+       /* The input path was wrong, it returned no such file. */
+       mm_util_retvm_if((!fp), MM_UTIL_ERROR_NO_SUCH_FILE, "invalid fp");
+       mm_util_retvm_if((!data || length == 0), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid data");
+
+       len = fwrite(data, 1, length, fp);
+       mm_util_retvm_if(len != length, MM_UTIL_ERROR_INVALID_OPERATION, "fwrite failed");
+
+       return MM_UTIL_ERROR_NONE;
+}
+
 void mm_util_safe_fclose(FILE *fp)
 {
        if (fp)

diff --git a/gif/include/mm_util_gif.h b/gif/include/mm_util_gif.h
old mode 100755 (executable)
new mode 100644 (file)
index 6e2ac71..48c0d21
--- a/gif/include/mm_util_gif.h
+++ b/gif/include/mm_util_gif.h
@@ -56,8 +56,8 @@ int mm_util_encode_to_gif_memory(mm_util_image_h *images, const unsigned int ima
 
 /* a-gif extras */
 int mm_util_gif_encode_create(mm_gif_file_h *gif_file_h);
-int mm_util_gif_encode_set_file(mm_gif_file_h gif_file_h, const char *file_name);
-int mm_util_gif_encode_set_mem(mm_gif_file_h gif_file_h, void **data, size_t *data_size);
+int mm_util_gif_encode_set_file(mm_gif_file_h gif_file_h, const char *file_path);
+int mm_util_gif_encode_set_mem(mm_gif_file_h gif_file_h, void **buffer, size_t *buffer_size);
 int mm_util_gif_encode_add_image(mm_gif_file_h gif_file_h, mm_image_info_s * gif_image_h);
 int mm_util_gif_encode_save(mm_gif_file_h gif_file_h);
 void mm_util_gif_encode_destroy(mm_gif_file_h gif_file_h);

diff --git a/gif/mm_util_gif.c b/gif/mm_util_gif.c
old mode 100755 (executable)
new mode 100644 (file)
index 9fbe6b8..8ae750d
--- a/gif/mm_util_gif.c
+++ b/gif/mm_util_gif.c
@@ -28,7 +28,6 @@
 #include "mm_util_private.h"
 
 #include <limits.h>
-#define GIF_TMP_FILE   "/tmp/.libmm_gif.gif"
 
 #define COLORMAP_FREE(map)                     { if (map != NULL) { GifFreeMapObject(map); map = NULL; } }
 #define RGB_ALLOC(r, g, b, number, size)       { r = calloc(1, number * size); g = calloc(1, number * size); b = calloc(1, number * size); }
@@ -371,20 +370,7 @@ SUCCESS:
        return ret;
 }
 
-static int _gif_encode_open_file(GifFileType **gft)
-{
-       mm_util_fenter();
-       mm_util_retvm_if(gft == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
-
-       if ((*gft = EGifOpenFileName(GIF_TMP_FILE, 0, NULL)) == NULL) {
-               mm_util_error("could not open file");
-               return MM_UTIL_ERROR_INVALID_OPERATION;
-       }
-
-       return MM_UTIL_ERROR_NONE;
-}
-
-int _gif_encode_open_mem(gif_file_s *gif_file)
+static int _gif_encode_open_mem(gif_file_s *gif_file)
 {
        mm_util_fenter();
        mm_util_retvm_if(gif_file == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
@@ -414,53 +400,42 @@ static int _gif_encode_close_file(GifFileType *gft)
        return MM_UTIL_ERROR_NONE;
 }
 
-int _gif_encode_move_to_file(const char *dst)
+int __write_gif_to_file(gif_file_s *handle)
 {
        int ret = MM_UTIL_ERROR_NONE;
-       GFile *source = g_file_new_for_path(GIF_TMP_FILE);
-       GFile *destination =  g_file_new_for_path(dst);
-       GError *error = NULL;
-
-       if (source == NULL || destination == NULL) {
-               mm_util_error("could not open file");
-               if (source)
-                       g_object_unref(source);
-               if (destination)
-                       g_object_unref(destination);
-               return MM_UTIL_ERROR_INVALID_OPERATION;
-       }
+       FILE *fp = NULL;
 
-       mm_util_sec_debug("Save to file [%s]", dst);
+       mm_util_retvm_if(!handle, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid handle");
+       mm_util_retvm_if((!handle->io_buf.buf || handle->io_buf.buf_size == 0), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid io_buf");
+       mm_util_retvm_if(!MMUTIL_STRING_VALID(handle->filename), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid filename");
 
-       gboolean result = g_file_copy(source, destination, G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, &error);
-       if (!result) {
-               mm_util_error("g_file_copy failed: %s", error ? error->message : "none");
-               ret = MM_UTIL_ERROR_INVALID_OPERATION;
-       }
+       ret = mm_util_safe_fopen(handle->filename, "wb", &fp);
+       mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "mm_util_safe_fopen fail (%d)", ret);
 
-       if (error)
-               g_error_free(error);
-       g_object_unref(source);
-       g_object_unref(destination);
+       ret = mm_util_safe_fwrite(fp, handle->io_buf.buf, handle->io_buf.buf_size);
+       if (ret != MM_UTIL_ERROR_NONE)
+               mm_util_error("mm_util_safe_fwrite fail (%d)", ret);
+
+       mm_util_safe_fclose(fp);
 
        return ret;
 }
 
-int _gif_encode_move_to_mem(const unsigned char *src, size_t src_size, void **dst, size_t *dst_size)
+int __write_gif_to_buffer(gif_file_s *handle)
 {
-       unsigned char *buffer = NULL;
-       mm_util_retvm_if(src == NULL || dst == NULL || dst_size == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
-       mm_util_retvm_if(src_size == 0, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
+       unsigned char *_buffer = NULL;
 
-       mm_util_debug("src_size: %zu", src_size);
+       mm_util_retvm_if(!handle, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid handle");
+       mm_util_retvm_if(!handle->io_buf.buf || handle->io_buf.buf_size == 0, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid io_buf");
+       mm_util_retvm_if(!handle->enc_buffer || !handle->enc_buffer_size, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid buffer");
 
-       buffer = (unsigned char *)calloc(1, src_size);
-       mm_util_retvm_if(buffer == NULL, MM_UTIL_ERROR_OUT_OF_MEMORY, "memory allocation failed");
+       _buffer = (unsigned char *)calloc(1, handle->io_buf.buf_size);
+       mm_util_retvm_if(!_buffer, MM_UTIL_ERROR_OUT_OF_MEMORY, "memory allocation failed");
 
-       memcpy(buffer, src, src_size);
+       memcpy(_buffer, handle->io_buf.buf, handle->io_buf.buf_size);
 
-       *dst = buffer;
-       *dst_size = src_size;
+       *handle->enc_buffer = _buffer;
+       *handle->enc_buffer_size = handle->io_buf.buf_size;
 
        return MM_UTIL_ERROR_NONE;
 }
@@ -580,32 +555,29 @@ int mm_util_gif_encode_create(mm_gif_file_h *gif_file_h)
        return MM_UTIL_ERROR_NONE;
 }
 
-int mm_util_gif_encode_set_file(mm_gif_file_h gif_file_h, const char *file_name)
+int mm_util_gif_encode_set_file(mm_gif_file_h gif_file_h, const char *file_path)
 {
        gif_file_s *gif_file = (gif_file_s *)gif_file_h;
 
-       mm_util_retvm_if(gif_file == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
-       mm_util_retvm_if(file_name == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
-       mm_util_retvm_if(strlen(file_name) == 0, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
-       mm_util_retvm_if(gif_file->GifFile != NULL, MM_UTIL_ERROR_INVALID_OPERATION, "Encoding has already started");
+       mm_util_retvm_if(!gif_file, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid handle");
+       mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid file_path");
 
-       gif_file->filename = g_strdup(file_name);
+       gif_file->filename = g_strdup(file_path);
        mm_util_retvm_if(gif_file->filename == NULL, MM_UTIL_ERROR_OUT_OF_MEMORY, "Memory allocation failed");
 
        return MM_UTIL_ERROR_NONE;
 }
 
-int mm_util_gif_encode_set_mem(mm_gif_file_h gif_file_h, void **data, size_t *data_size)
+int mm_util_gif_encode_set_mem(mm_gif_file_h gif_file_h, void **buffer, size_t *buffer_size)
 {
        gif_file_s *gif_file = (gif_file_s *)gif_file_h;
 
-       mm_util_retvm_if(gif_file == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
-       mm_util_retvm_if(data == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
-       mm_util_retvm_if(data_size == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
-       mm_util_retvm_if(gif_file->GifFile != NULL, MM_UTIL_ERROR_INVALID_OPERATION, "Encoding has already started");
+       mm_util_retvm_if(!gif_file, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid handle");
+       mm_util_retvm_if(!buffer, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid buffer");
+       mm_util_retvm_if(!buffer_size, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid buffer_size");
 
-       gif_file->enc_buffer = data;
-       gif_file->enc_buffer_size = data_size;
+       gif_file->enc_buffer = buffer;
+       gif_file->enc_buffer_size = buffer_size;
 
        return MM_UTIL_ERROR_NONE;
 }
@@ -620,16 +592,8 @@ static int __mm_util_gif_encode_start(mm_gif_file_h gif_file_h, unsigned int wid
 
        mm_util_fenter();
 
-       if (gif_file->filename != NULL) {
-               ret = _gif_encode_open_file(&gif_file->GifFile);
-               mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "_gif_encode_open_file failed");
-       } else if (gif_file->enc_buffer != NULL && gif_file->enc_buffer_size != NULL) {
-               ret = _gif_encode_open_mem(gif_file);
-               mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "_gif_encode_open_mem failed");
-       } else {
-               mm_util_error("could not find output");
-               return MM_UTIL_ERROR_INVALID_OPERATION;
-       }
+       ret = _gif_encode_open_mem(gif_file);
+       mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "_gif_encode_open_mem failed");
 
        /* To initialize data after GifFile opened */
        EGifSetGifVersion(gif_file->GifFile, TRUE);
@@ -692,18 +656,15 @@ int mm_util_gif_encode_save(mm_gif_file_h gif_file_h)
        gif_file->GifFile = NULL;
        mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "_gif_encode_close_file failed");
 
-       if (gif_file->filename != NULL) {
-               ret = _gif_encode_move_to_file(gif_file->filename);
-               mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "__move_tmp_to_origin failed");
-       } else if (gif_file->io_buf.buf != NULL) {
-               ret = _gif_encode_move_to_mem(gif_file->io_buf.buf, gif_file->io_buf.buf_size,
-                       gif_file->enc_buffer, gif_file->enc_buffer_size);
-               MMUTIL_SAFE_FREE(gif_file->io_buf.buf);
-               gif_file->io_buf.buf_size = 0;
-               mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "_gif_encode_move_to_origin_mem failed");
-       }
+       if (gif_file->filename != NULL)
+               ret = __write_gif_to_file(gif_file);
+       else if (gif_file->enc_buffer != NULL)
+               ret = __write_gif_to_buffer(gif_file);
 
-       return MM_UTIL_ERROR_NONE;
+       MMUTIL_SAFE_FREE(gif_file->io_buf.buf);
+       gif_file->io_buf.buf_size = 0;
+
+       return ret;
 }
 
 int mm_util_encode_to_gif_file(mm_util_image_h *images, const unsigned int image_count, const char *file_path)