Improve '_get_contents_info' function to reduce Cyclomatic Complexity

Change-Id: I9b86b5432904d9475bc28a4f7e18ad42a1e42ea5

diff --git a/mm_file.c b/mm_file.c
index 1f48cd7..532c314 100644 (file)
--- a/mm_file.c
+++ b/mm_file.c
@@ -446,22 +446,133 @@ _info_set_attr_media(MMHandleType attrs, MMFileFormatContext *formatContext)
        return ret;
 }
 
+/**
+ * @param      frameContext    [in]    frame for decoding.
+ * @param      videoStream             [in]    information of video codec for frameContext.
+ * @param      decodedFrame    [inout] frame after decoding frameContext.
+ */
+static int
+__decode_contents_frame(MMFileFormatFrame *frameContext, MMFileFormatStream *videoStream, MMFileCodecFrame *decodedFrame)
+{
+       int ret = FILEINFO_ERROR_NONE;
+       MMFileCodecContext *codecContext = NULL;
+       MMFileCodecFrame codecFrame = {0, };
+
+       if (!frameContext || !videoStream || !decodedFrame) {
+               debug_error(DEBUG, "error: invalid parameters (%p %p %p)\n", frameContext, videoStream, decodedFrame);
+               return FILEINFO_ERROR_FILE_INTERNAL;
+       }
+
+       codecFrame.frameDataSize = frameContext->frameSize;
+       codecFrame.width = frameContext->frameWidth;
+       codecFrame.height = frameContext->frameHeight;
+       codecFrame.frameData = frameContext->frameData;
+       codecFrame.configLen = frameContext->configLenth;
+       codecFrame.configData = frameContext->configData;
+       codecFrame.version = videoStream->version;
+
+       if (MMFILE_FORMAT_FAIL == mmfile_codec_open(&codecContext, MMFILE_VIDEO_DECODE, videoStream->codecId, &codecFrame)) {
+               debug_error(DEBUG, "error: mmfile_codec_open\n");
+               mmfile_codec_close(codecContext);
+               return FILEINFO_ERROR_FILE_INTERNAL;
+       }
+
+       if (MMFILE_FORMAT_FAIL == mmfile_codec_decode(codecContext, decodedFrame)) {
+               debug_error(DEBUG, "error: mmfile_codec_decode\n");
+               ret = FILEINFO_ERROR_FILE_INTERNAL;
+       }
+
+       mmfile_codec_close(codecContext);
+
+       return ret;
+}
+
+static int
+__get_contents_thumbnail(MMFileFormatContext *formatContext)
+{
+       int ret = FILEINFO_ERROR_NONE;
+       MMFileFormatFrame frameContext = {0, };
+       MMFileCodecFrame decodedFrame = {0, };
+       MMFileFormatFrame *thumbnail = NULL;
+
+       if (!formatContext) {
+               debug_error(DEBUG, "error: invalid parameter (%p)\n", formatContext);
+               return FILEINFO_ERROR_FILE_INTERNAL;
+       }
+
+       if (MMFILE_FORMAT_FAIL == mmfile_format_read_frame(formatContext, _SEEK_POINT_, &frameContext)) {
+               debug_error(DEBUG, "error: mmfile_format_read_frame\n");
+               ret = FILEINFO_ERROR_FILE_INTERNAL;
+               goto exception;
+       }
+
+       /* set video thumbnail */
+       thumbnail = mmfile_malloc(sizeof(MMFileFormatFrame));
+       if (!thumbnail) {
+               debug_error(DEBUG, "error: mmfile_malloc\n");
+               ret = FILEINFO_ERROR_FILE_INTERNAL;
+               goto exception;
+       }
+
+       if (frameContext.bCompressed) {
+               ret = __decode_contents_frame(&frameContext, formatContext->streams[MMFILE_VIDEO_STREAM], &decodedFrame);
+               if (FILEINFO_ERROR_NONE != ret) {
+                       debug_error(DEBUG, "error: __decode_contents_thumbnail\n");
+                       goto exception;
+               }
+
+               /* after decoding frameContext is done, it is no needed */
+               mmfile_free(frameContext.frameData);
+               mmfile_free(frameContext.configData);
+
+               thumbnail->frameSize = decodedFrame.frameDataSize;
+               thumbnail->frameWidth = decodedFrame.width;
+               thumbnail->frameHeight = decodedFrame.height;
+               thumbnail->frameData = decodedFrame.frameData;
+               thumbnail->configLenth = 0;
+               thumbnail->configData = NULL;
+       } else {
+               thumbnail->frameSize = frameContext.frameSize;
+               thumbnail->frameWidth = frameContext.frameWidth;
+               thumbnail->frameHeight = frameContext.frameHeight;
+               thumbnail->frameData = frameContext.frameData;
+               thumbnail->configLenth = 0;
+               thumbnail->configData = NULL;
+       }
+
+#ifdef __MMFILE_TEST_MODE__
+       mmfile_format_print_frame(thumbnail);
+#endif
+
+       formatContext->thumbNail = thumbnail;
+
+       /* because #MMFILE_FORMAT_SUCCESS is different with #FILEINFO_ERROR_NONE */
+       return FILEINFO_ERROR_NONE;
+exception:
+       if (frameContext.bCompressed) {
+               mmfile_free(decodedFrame.frameData);
+               mmfile_free(decodedFrame.configData);
+       }
+
+       mmfile_free(thumbnail);
+       mmfile_free(frameContext.frameData);
+       mmfile_free(frameContext.configData);
+
+       return ret;
+}
+
 static int
 _get_contents_info(MMHandleType attrs, MMFileSourceType *src, MMFILE_PARSE_INFO *parse)
 {
        MMFileFormatContext *formatContext = NULL;
-       MMFileCodecContext  *codecContext = NULL;
-       MMFileFormatFrame    frameContext = {0, };
-       MMFileCodecFrame     codecFrame = {0, };
-       MMFileCodecFrame     decodedFrame = {0, };
-
        int ret = 0;
 
-       if (!src || !parse)
+       if (!src || !parse) {
+               debug_error(DEBUG, "error: invalid parameters (%p, %p)\n", src, parse);
                return FILEINFO_ERROR_FILE_INTERNAL;
+       }
 
-       ret = mmfile_format_open(&formatContext, src);
-       if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
+       if (MMFILE_FORMAT_FAIL == mmfile_format_open(&formatContext, src) || formatContext == NULL) {
                debug_error(DEBUG, "error: mmfile_format_open\n");
                ret = FILEINFO_ERROR_FILE_INTERNAL;
                goto exception;
@@ -470,8 +581,8 @@ _get_contents_info(MMHandleType attrs, MMFileSourceType *src, MMFILE_PARSE_INFO
        if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL) {
                if (parse->type == MM_FILE_PARSE_TYPE_SAFE)
                        formatContext->cdis = 1;
-               ret = mmfile_format_read_stream(formatContext);
-               if (MMFILE_FORMAT_FAIL == ret) {
+
+               if (MMFILE_FORMAT_FAIL == mmfile_format_read_stream(formatContext)) {
                        debug_error(DEBUG, "error: mmfile_format_read_stream\n");
                        ret = FILEINFO_ERROR_FILE_INTERNAL;
                        goto exception;
@@ -481,87 +592,26 @@ _get_contents_info(MMHandleType attrs, MMFileSourceType *src, MMFILE_PARSE_INFO
                parse->video_track_num = formatContext->videoTotalTrackNum;
 
                /* check uhqa content*/
-               if (formatContext->streams[MMFILE_AUDIO_STREAM] != NULL) {
+               if (formatContext->streams[MMFILE_AUDIO_STREAM] != NULL)
                        parse->is_uhqa = formatContext->streams[MMFILE_AUDIO_STREAM]->is_uhqa;
-               } else {
+               else
                        parse->is_uhqa = FALSE;
-               }
-
-               if (parse->type >= MM_FILE_PARSE_TYPE_ALL) {
-                       if (formatContext->videoTotalTrackNum > 0) {
 
+               if (parse->type >= MM_FILE_PARSE_TYPE_ALL && formatContext->videoTotalTrackNum > 0) {
 /*why below code needed?
 This API is for extracting some attributes not metadata(TAG). mm_file_create_content_attrs() use this API.
 but MMFileUtilGetMetaDataFromMP4() Extract just TAG info. That is needed for mm_file_create_tag_attrs()*/
 #if 0
-                               if (parse->type != MM_FILE_PARSE_TYPE_SAFE) {
-                                       if (formatContext->formatType == MM_FILE_FORMAT_3GP || formatContext->formatType == MM_FILE_FORMAT_MP4) {
-                                               MMFileUtilGetMetaDataFromMP4(formatContext);
-                                       }
+                       if (parse->type != MM_FILE_PARSE_TYPE_SAFE) {
+                               if (formatContext->formatType == MM_FILE_FORMAT_3GP || formatContext->formatType == MM_FILE_FORMAT_MP4) {
+                                       MMFileUtilGetMetaDataFromMP4(formatContext);
                                }
+                       }
 #endif
-                               MMFileFormatStream *videoStream = formatContext->streams[MMFILE_VIDEO_STREAM];
-                               unsigned int timestamp = _SEEK_POINT_;
-
-                               ret = mmfile_format_read_frame(formatContext, timestamp, &frameContext);
-                               if (MMFILE_FORMAT_FAIL == ret) {
-                                       debug_error(DEBUG, "error: mmfile_format_read_frame\n");
-                                       ret = FILEINFO_ERROR_FILE_INTERNAL;
-                                       goto warning;
-                               }
-
-                               if (frameContext.bCompressed) {
-                                       codecFrame.frameDataSize = frameContext.frameSize;
-                                       codecFrame.width = frameContext.frameWidth;
-                                       codecFrame.height = frameContext.frameHeight;
-                                       codecFrame.frameData = frameContext.frameData;
-                                       codecFrame.configLen = frameContext.configLenth;
-                                       codecFrame.configData = frameContext.configData;
-                                       codecFrame.version = videoStream->version;
-
-                                       ret = mmfile_codec_open(&codecContext, MMFILE_VIDEO_DECODE, videoStream->codecId, &codecFrame);
-                                       if (MMFILE_FORMAT_FAIL == ret) {
-                                               debug_error(DEBUG, "error: mmfile_codec_open\n");
-                                               ret = FILEINFO_ERROR_FILE_INTERNAL;
-                                               goto warning;
-                                       }
-
-                                       ret = mmfile_codec_decode(codecContext, &decodedFrame);
-                                       if (MMFILE_FORMAT_FAIL == ret) {
-                                               debug_error(DEBUG, "error: mmfile_codec_decode\n");
-                                               ret = FILEINFO_ERROR_FILE_INTERNAL;
-                                               goto warning;
-                                       }
-
-                                       /* set video thumbnail */
-                                       formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
-                                       if (NULL == formatContext->thumbNail) {
-                                               debug_error(DEBUG, "error: mmfile_malloc\n");
-                                               ret = FILEINFO_ERROR_FILE_INTERNAL;
-                                               goto warning;
-                                       }
-
-                                       formatContext->thumbNail->frameSize = decodedFrame.frameDataSize;
-                                       formatContext->thumbNail->frameWidth = decodedFrame.width;
-                                       formatContext->thumbNail->frameHeight = decodedFrame.height;
-                                       formatContext->thumbNail->frameData = decodedFrame.frameData;
-                                       formatContext->thumbNail->configLenth = 0;
-                                       formatContext->thumbNail->configData = NULL;
-                               } else {
-                                       formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
-                                       if (NULL == formatContext->thumbNail) {
-                                               debug_error(DEBUG, "error: mmfile_format_read_frame\n");
-                                               ret = FILEINFO_ERROR_FILE_INTERNAL;
-                                               goto warning;
-                                       }
-
-                                       formatContext->thumbNail->frameSize = frameContext.frameSize;
-                                       formatContext->thumbNail->frameWidth = frameContext.frameWidth;
-                                       formatContext->thumbNail->frameHeight = frameContext.frameHeight;
-                                       formatContext->thumbNail->frameData = frameContext.frameData;
-                                       formatContext->thumbNail->configLenth = 0;
-                                       formatContext->thumbNail->configData = NULL;
-                               }
+                       ret = __get_contents_thumbnail(formatContext);
+                       if (FILEINFO_ERROR_NONE != ret) {
+                               debug_error(DEBUG, "error: __get_contents_thumbnail\n");
+                               ret = FILEINFO_ERROR_NONE;
                        }
                }
        } else {
@@ -572,125 +622,20 @@ but MMFileUtilGetMetaDataFromMP4() Extract just TAG info. That is needed for mm_
                parse->video_track_num = formatContext->videoTotalTrackNum;
        }
 
-#ifdef __MMFILE_TEST_MODE__
-       mmfile_format_print_frame(&frameContext);
-#endif
-
        formatContext->commandType = MM_FILE_CONTENTS;
 
        if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
                _info_set_attr_media(attrs, formatContext);
 
-       if (frameContext.bCompressed) {
-               mmfile_free(frameContext.frameData);
-               mmfile_free(frameContext.configData);
-
-               if (decodedFrame.frameData) {
-                       mmfile_free(decodedFrame.frameData);
-                       formatContext->thumbNail->frameData = NULL;
-               }
-               if (decodedFrame.configData) {
-                       mmfile_free(decodedFrame.configData);
-                       formatContext->thumbNail->configData = NULL;
-               }
-       } else {
-               if (frameContext.frameData) {
-                       mmfile_free(frameContext.frameData);
-                       formatContext->thumbNail->frameData = NULL;
-               }
-               if (frameContext.configData) {
-                       mmfile_free(frameContext.configData);
-                       formatContext->thumbNail->configData = NULL;
-               }
-       }
-
-       if (formatContext)  {
-               mmfile_format_close(formatContext);
-       }
-       if (codecContext)   {
-               mmfile_codec_close(codecContext);
+       if (formatContext->thumbNail) {
+               mmfile_free(formatContext->thumbNail->frameData);
+               mmfile_free(formatContext->thumbNail->configData);
+               mmfile_free(formatContext->thumbNail);
        }
 
-       return FILEINFO_ERROR_NONE;
-
-warning:
-       formatContext->commandType = MM_FILE_CONTENTS;
-
-       if (frameContext.bCompressed) {
-               mmfile_free(frameContext.frameData);
-               mmfile_free(frameContext.configData);
-
-               if (decodedFrame.frameData) {
-                       mmfile_free(decodedFrame.frameData);
-                       if (formatContext->thumbNail)
-                               formatContext->thumbNail->frameData = NULL;
-               }
-
-               if (decodedFrame.configData) {
-                       mmfile_free(decodedFrame.configData);
-                       if (formatContext->thumbNail)
-                               formatContext->thumbNail->configData = NULL;
-               }
-       } else {
-               if (frameContext.frameData) {
-                       mmfile_free(frameContext.frameData);
-                       if (formatContext->thumbNail)
-                               formatContext->thumbNail->frameData = NULL;
-               }
-
-               if (frameContext.configData) {
-                       mmfile_free(frameContext.configData);
-                       if (formatContext->thumbNail)
-                               formatContext->thumbNail->configData = NULL;
-               }
-       }
-
-       if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
-               _info_set_attr_media(attrs, formatContext);
-
-       if (formatContext)  {
-               mmfile_format_close(formatContext);
-       }
-       if (codecContext)   {
-               mmfile_codec_close(codecContext);
-       }
-       return FILEINFO_ERROR_NONE;
-
-
 exception:
-       if (frameContext.bCompressed) {
-                       mmfile_free(frameContext.frameData);
-                       mmfile_free(frameContext.configData);
-
-               if (decodedFrame.frameData) {
-                       mmfile_free(decodedFrame.frameData);
-                       if (formatContext->thumbNail)
-                               formatContext->thumbNail->frameData = NULL;
-               }
-
-               if (decodedFrame.configData) {
-                       mmfile_free(decodedFrame.configData);
-                       if (formatContext->thumbNail)
-                               formatContext->thumbNail->configData = NULL;
-               }
-       } else {
-               if (frameContext.frameData) {
-                       mmfile_free(frameContext.frameData);
-                       if (formatContext->thumbNail)
-                               formatContext->thumbNail->frameData = NULL;
-               }
-
-               if (frameContext.configData) {
-                       mmfile_free(frameContext.configData);
-                       if (formatContext->thumbNail)
-                               formatContext->thumbNail->configData = NULL;
-               }
-       }
-
-       if (formatContext)  {
+       if (formatContext)
                mmfile_format_close(formatContext);
-       }
-       /* if (codecContext)   { mmfile_codec_close(codecContext); } */ /*dead code*/
 
        return ret;
 }