Modify simple bugs and internal function name

Change-Id: I7ae768144840b4c8ec895372215e9efe2fd84059

diff --git a/jpeg/mm_util_jpeg.c b/jpeg/mm_util_jpeg.c
index e117682..01633bb 100644 (file)
--- a/jpeg/mm_util_jpeg.c
+++ b/jpeg/mm_util_jpeg.c
@@ -33,6 +33,11 @@
 /* maximum width of encoding */
 #define ENC_MAX_LEN 8192
 
+typedef enum {
+       MM_UTIL_JPEG_FILE,
+       MM_UTIL_JPEG_MEM,
+} mm_util_jpeg_cont_format_e;
+
 struct my_error_mgr_s {
        struct jpeg_error_mgr pub; /* "public" fields */
        jmp_buf setjmp_buffer; /* for return to caller */
@@ -47,11 +52,6 @@ static void __my_error_exit(j_common_ptr cinfo)
        longjmp(myerr->setjmp_buffer, 1); /* Return control to the setjmp point */
 }
 
-typedef enum {
-       MM_UTIL_JPEG_FILE,
-       MM_UTIL_JPEG_MEM,
-} mm_util_jpeg_cont_format_e;
-
 static gboolean __is_supported_color_format_with_libjpeg(mm_util_color_format_e color_format)
 {
        gboolean _bool = FALSE;
@@ -88,21 +88,15 @@ 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, mm_util_image_h decoded, int quality, FILE *fp, void **mem, size_t *csize)
+static int _mm_util_jpeg_encode(mm_util_jpeg_cont_format_e control_format, mm_util_image_h decoded, int quality, FILE *fp, void **mem, size_t *csize)
 {
        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(!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;
+       struct my_error_mgr_s jerr;
        int i, j, flag, _width, _height;
        unsigned long size = 0;
 
@@ -110,9 +104,25 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for
        data[1] = cb;
        data[2] = cr;
 
+       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), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid fp");
+       mm_util_retvm_if((control_format == MM_UTIL_JPEG_MEM) && ((!mem) || (!csize)), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src or csize");
+       mm_util_retvm_if(!IS_VALID_IMAGE(decoded), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image");
+
        mm_util_debug("quality[%d]", quality);
 
-       cinfo.err = jpeg_std_error(&jerr); /*  Errors get written to stderr */
+       /*      Errors get written to stderr */
+       cinfo.err = jpeg_std_error(&jerr.pub);
+       mm_util_debug("jpeg_std_error ");
+       jerr.pub.error_exit = __my_error_exit;
+       mm_util_debug("jerr.pub.error_exit ");
+
+       /* Establish the setjmp return context for __my_error_exit to use. */
+       if (setjmp(jerr.setjmp_buffer)) {
+               /* If we get here, the JPEG code has signaled an error.  We need to clean up the JPEG object, close the input file, and return.*/
+               mm_util_error("ERROR setjmp");
+               return MM_UTIL_ERROR_INVALID_OPERATION;
+       }
 
        jpeg_create_compress(&cinfo);
 
@@ -282,7 +292,7 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for
        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)
+static int _mm_util_jpeg_decode(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)
 {
        int ret = MM_UTIL_ERROR_NONE;
        struct jpeg_decompress_struct dinfo;
@@ -297,8 +307,8 @@ static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_for
        mm_util_fenter();
 
        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) && ((src == NULL) || (size == 0)), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src or size");
+       mm_util_retvm_if((control_format == MM_UTIL_JPEG_FILE) && (!fp), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid fp");
+       mm_util_retvm_if((control_format == MM_UTIL_JPEG_MEM) && ((!src) || (size == 0)), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src or size");
        mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image handle");
 
        /* allocate and initialize JPEG decompression object   We set up the normal JPEG error routines, then override error_exit. */
@@ -311,8 +321,7 @@ static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_for
        if (setjmp(jerr.setjmp_buffer)) {
                /* If we get here, the JPEG code has signaled an error.  We need to clean up the JPEG object, close the input file, and return.*/
                mm_util_error("ERROR setjmp");
-               jpeg_destroy_decompress(&dinfo);
-               return MM_UTIL_ERROR_NO_SUCH_FILE;
+               return MM_UTIL_ERROR_INVALID_OPERATION;
        }
 
        mm_util_debug("if (setjmp)");
@@ -490,10 +499,10 @@ int mm_util_jpeg_encode_to_file(mm_util_image_h decoded, int quality, const char
                        return ret;
                }
 
-               ret = __mm_image_encode_with_libjpeg(MM_UTIL_JPEG_FILE, _converted_image, quality, fp, NULL, NULL);
+               ret = _mm_util_jpeg_encode(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, quality, fp, NULL, NULL);
+               ret = _mm_util_jpeg_encode(MM_UTIL_JPEG_FILE, decoded, quality, fp, NULL, NULL);
        }
 
        fsync((int)(fp->_fileno));
@@ -542,10 +551,10 @@ int mm_util_encode_to_jpeg_memory(mm_util_image_h decoded, int quality, void **b
                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, quality, NULL, buffer, size);
+               ret = _mm_util_jpeg_encode(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, quality, NULL, buffer, size);
+               ret = _mm_util_jpeg_encode(MM_UTIL_JPEG_MEM, decoded, quality, NULL, buffer, size);
        }
 
        mm_util_fleave();
@@ -576,12 +585,12 @@ int mm_util_decode_from_jpeg_file(const char *file_path, mm_util_color_format_e
        mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "mm_util_safe_fopen fail (%d)", ret);
 
        if (fmt == MM_UTIL_COLOR_NV12) {
-               ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_FILE, fp, NULL, 0, MM_UTIL_COLOR_YUV420, downscale, &_decoded);
+               ret = _mm_util_jpeg_decode(MM_UTIL_JPEG_FILE, fp, NULL, 0, MM_UTIL_COLOR_YUV420, downscale, &_decoded);
                if (ret == MM_UTIL_ERROR_NONE)
                        ret = mm_util_convert_colorspace(_decoded, MM_UTIL_COLOR_NV12, decoded);
                mm_image_destroy_image(_decoded);
        } else {
-               ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_FILE, fp, NULL, 0, fmt, downscale, decoded);
+               ret = _mm_util_jpeg_decode(MM_UTIL_JPEG_FILE, fp, NULL, 0, fmt, downscale, decoded);
        }
 
        mm_util_safe_fclose(fp);
@@ -611,12 +620,12 @@ int mm_util_decode_from_jpeg_memory(void *memory, const size_t src_size, mm_util
        }
 
        if (fmt == MM_UTIL_COLOR_NV12) {
-               ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_MEM, NULL, memory, src_size, MM_UTIL_COLOR_YUV420, downscale, &_decoded);
+               ret = _mm_util_jpeg_decode(MM_UTIL_JPEG_MEM, NULL, memory, src_size, MM_UTIL_COLOR_YUV420, downscale, &_decoded);
                if (ret == MM_UTIL_ERROR_NONE)
                        ret = mm_util_convert_colorspace(_decoded, MM_UTIL_COLOR_NV12, decoded);
                mm_image_destroy_image(_decoded);
        } else {
-               ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_MEM, NULL, memory, src_size, fmt, downscale, decoded);
+               ret = _mm_util_jpeg_decode(MM_UTIL_JPEG_MEM, NULL, memory, src_size, fmt, downscale, decoded);
        }
 
        mm_util_fleave();