Cleanup code 18/248218/6
authorMinje Ahn <minje.ahn@samsung.com>
Tue, 24 Nov 2020 03:06:09 +0000 (12:06 +0900)
committerMinje Ahn <minje.ahn@samsung.com>
Wed, 25 Nov 2020 07:15:48 +0000 (16:15 +0900)
Change-Id: Ib6051aef935a02cd7a4868f58a488641828968d6
Signed-off-by: Minje Ahn <minje.ahn@samsung.com>
src/metadata_extractor.c

index 032a177..cb1db76 100644 (file)
@@ -39,7 +39,7 @@ static int __metadata_extractor_get_artwork(metadata_extractor_s *metadata, void
 static int __metadata_extractor_get_video_thumbnail(metadata_extractor_s *metadata, void **thumbnail, int *thumbnail_len);
 static int __metadata_extractor_get_audio_track_count(metadata_extractor_s *metadata, int *track_cnt);
 static int __metadata_extractor_get_video_track_count(metadata_extractor_s *metadata, int *track_cnt);
-static int __metadata_extractor_destroy_handle(metadata_extractor_s *metadata);
+static void __metadata_extractor_destroy_internal(metadata_extractor_s *metadata);
 static int __metadata_extractor_get_audio_codec(metadata_extractor_s *metadata, char **audio_codec);
 static int __metadata_extractor_get_video_codec(metadata_extractor_s *metadata, char **video_codec);
 
@@ -368,26 +368,24 @@ static int __metadata_extractor_get_audio_codec(metadata_extractor_s *metadata,
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
        int audio_codec_idx = 0;
-       int audio_codec_cnt = 45;
-
-       const char *AudioCodecTypeString[] = {
-               "AMR", "G723.1", "MP3", "OGG", "AAC", "WMA", "MMF", "ADPCM", "WAVE", "WAVE NEW", "MIDI", "IMELODY", "MXMF", "MPEG1-Layer1 codec", "MPEG1-Layer2 codec",
-               "G711", "G722", "G722.1",       "G722.2  (AMR-WB)", "G723 wideband speech", "G726 (ADPCM)", "G728 speech",      "G729", "G729a",        "G729.1",
-               "Real",
-               "AAC-Low complexity",   "AAC-Main profile", "AAC-Scalable sample rate", "AAC-Long term prediction", "AAC-High Efficiency v1",   "AAC-High efficiency v2",
-               "DolbyDigital", "Apple Lossless",       "Sony proprietary", "SPEEX",    "Vorbis",       "AIFF", "AU",   "None (will be deprecated)",
-               "PCM",  "ALAW", "MULAW",        "MS ADPCM", "FLAC"
+
+       static const char *AudioCodecTypeString[] = {
+               "AMR", "G723.1", "MP3", "OGG", "AAC", "WMA", "MMF", "ADPCM", "WAVE", "WAVE NEW", "MIDI", "IMELODY", "MXMF",
+               "MPEG1-Layer1 codec", "MPEG1-Layer2 codec",
+               "G711", "G722", "G722.1", "G722.2 (AMR-WB)", "G723 wideband speech", "G726 (ADPCM)", "G728 speech",
+               "G729", "G729a", "G729.1", "Real",
+               "AAC-Low complexity", "AAC-Main profile", "AAC-Scalable sample rate",
+               "AAC-Long term prediction", "AAC-High Efficiency v1", "AAC-High efficiency v2",
+               "DolbyDigital", "Apple Lossless", "Sony proprietary", "SPEEX", "Vorbis", "AIFF", "AU", "None (will be deprecated)",
+               "PCM", "ALAW", "MULAW", "MS ADPCM", "FLAC"
        };
 
        ret = __metadata_extractor_get_audio_attr_int(metadata, MM_FILE_CONTENT_AUDIO_CODEC, &audio_codec_idx);
        metadata_extractor_retvm_if(ret != METADATA_EXTRACTOR_ERROR_NONE, ret, "Fail to get codec idx");
+       metadata_extractor_retvm_if(audio_codec_idx < 0 || audio_codec_idx >= (int)(sizeof(AudioCodecTypeString) / sizeof(char *)),
+               METADATA_EXTRACTOR_ERROR_OPERATION_FAILED, "Invalid Audio Codec [%d]", audio_codec_idx);
 
-       if (audio_codec_idx >= 0 && audio_codec_idx < audio_codec_cnt)
-               *audio_codec = g_strdup(AudioCodecTypeString[audio_codec_idx]);
-       else {
-               metadata_extractor_error("Invalid Audio Codec [%d]", audio_codec_idx);
-               *audio_codec = NULL;
-       }
+       *audio_codec = (char *)AudioCodecTypeString[audio_codec_idx];
 
        return ret;
 }
@@ -396,44 +394,42 @@ static int __metadata_extractor_get_video_codec(metadata_extractor_s *metadata,
 {
        int ret = METADATA_EXTRACTOR_ERROR_NONE;
        int video_codec_idx = 0;
-       int video_codec_cnt = 29;
 
-       const char *VideoCodecTypeString[] = {
+       static const char *VideoCodecTypeString[] = {
                "None (will be deprecated)",
-               "H263", "H264", "H26L", "MPEG4", "MPEG1", "WMV", "DIVX", "XVID", "H261", "H262/MPEG2-part2", "H263v2",  "H263v3",
-               "Motion JPEG", "MPEG2", "MPEG4 part-2 Simple profile",  "MPEG4 part-2 Advanced Simple profile", "MPEG4 part-2 Main profile",
-               "MPEG4 part-2 Core profile", "MPEG4 part-2 Adv Coding Eff profile", "MPEG4 part-2 Adv RealTime Simple profile",
-               "MPEG4 part-10 (h.264)",        "Real", "VC-1", "AVS",  "Cinepak",      "Indeo",        "Theora", "Flv"
+               "H263", "H264", "H26L", "MPEG4", "MPEG1", "WMV", "DIVX", "XVID", "H261", "H262/MPEG2-part2", "H263v2", "H263v3",
+               "Motion JPEG", "MPEG2", "MPEG4 part-2 Simple profile", "MPEG4 part-2 Advanced Simple profile",
+               "MPEG4 part-2 Main profile", "MPEG4 part-2 Core profile", "MPEG4 part-2 Adv Coding Eff profile",
+               "MPEG4 part-2 Adv RealTime Simple profile", "MPEG4 part-10 (h.264)",
+               "Real", "VC-1", "AVS", "Cinepak", "Indeo", "Theora", "Flv"
        };
 
        ret = __metadata_extractor_get_video_attr_int(metadata, MM_FILE_CONTENT_AUDIO_CODEC, &video_codec_idx);
        metadata_extractor_retvm_if(ret != METADATA_EXTRACTOR_ERROR_NONE, ret, "Fail to get codec idx");
+       metadata_extractor_retvm_if(video_codec_idx < 0 || video_codec_idx >= (int)(sizeof(VideoCodecTypeString) / sizeof(char *)),
+               METADATA_EXTRACTOR_ERROR_OPERATION_FAILED, "Invalid Video Codec [%d]", video_codec_idx);
 
-       if (video_codec_idx >= 0 && video_codec_idx < video_codec_cnt)
-               *video_codec = g_strdup(VideoCodecTypeString[video_codec_idx]);
-       else {
-               metadata_extractor_error("Invalid Video Codec[%d]", video_codec_idx);
-               *video_codec = NULL;
-       }
+       *video_codec = (char *)VideoCodecTypeString[video_codec_idx];
 
        return ret;
 }
 
-static int __metadata_extractor_destroy_handle(metadata_extractor_s *metadata)
+static void __metadata_extractor_destroy_internal(metadata_extractor_s *metadata)
 {
-       int ret = METADATA_EXTRACTOR_ERROR_NONE;
+       if (metadata->attr_h)
+               mm_file_destroy_content_attrs(metadata->attr_h);
 
-       if (metadata->attr_h) {
-               ret = mm_file_destroy_content_attrs(metadata->attr_h);
-               metadata_extractor_retvm_if(ret != FILEINFO_ERROR_NONE, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED, "Failed to destroy attribute handle");
-       }
+       if (metadata->tag_h)
+               mm_file_destroy_tag_attrs(metadata->tag_h);
 
-       if (metadata->tag_h) {
-               ret = mm_file_destroy_tag_attrs(metadata->tag_h);
-               metadata_extractor_retvm_if(ret != FILEINFO_ERROR_NONE, METADATA_EXTRACTOR_ERROR_OPERATION_FAILED, "Failed to destroy tag handle");
-       }
+       metadata->attr_h = NULL;
+       metadata->tag_h = NULL;
 
-       return ret;
+       g_free(metadata->path);
+       metadata->path = NULL;
+
+       metadata->buffer = NULL;
+       metadata->buffer_size = 0;
 }
 
 int metadata_extractor_create(metadata_extractor_h *metadata)
@@ -444,12 +440,6 @@ int metadata_extractor_create(metadata_extractor_h *metadata)
 
        metadata_extractor_s *_metadata = g_new0(metadata_extractor_s, 1);
 
-       _metadata->path = NULL;
-       _metadata->buffer = NULL;
-       _metadata->buffer_size = 0;
-       _metadata->audio_track_cnt = 0;
-       _metadata->video_track_cnt = 0;
-
        *metadata = (metadata_extractor_h)_metadata;
 
        return ret;
@@ -471,12 +461,7 @@ int metadata_extractor_set_path(metadata_extractor_h metadata, const char *path)
 
        metadata_extractor_secure_info("path [%s]", path);
 
-       if ((_metadata->path != NULL) || (_metadata->buffer != NULL)) {
-               __metadata_extractor_destroy_handle(_metadata);
-               g_free(_metadata->path);
-               _metadata->attr_h = 0;
-               _metadata->tag_h = 0;
-       }
+       __metadata_extractor_destroy_internal(_metadata);
 
        _metadata->path = g_strdup(path);
 
@@ -492,13 +477,7 @@ int metadata_extractor_set_buffer(metadata_extractor_h metadata, const void *buf
        metadata_extractor_retvm_if(!buffer, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "buffer is NULL");
        metadata_extractor_retvm_if(size <= 0, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Invalid size");
 
-       if ((_metadata->path != NULL) || (_metadata->buffer != NULL)) {
-               __metadata_extractor_destroy_handle(_metadata);
-               g_free(_metadata->path);
-               _metadata->path = NULL;
-               _metadata->attr_h = 0;
-               _metadata->tag_h = 0;
-       }
+       __metadata_extractor_destroy_internal(_metadata);
 
        _metadata->buffer = (void *)buffer;
        _metadata->buffer_size = size;
@@ -513,9 +492,7 @@ int metadata_extractor_destroy(metadata_extractor_h metadata)
 
        metadata_extractor_retvm_if(!_metadata, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Invalid parameter");
 
-       ret = __metadata_extractor_destroy_handle(_metadata);
-
-       g_free(_metadata->path);
+       __metadata_extractor_destroy_internal(_metadata);
        g_free(_metadata);
 
        return ret;
@@ -532,9 +509,6 @@ int metadata_extractor_get_synclyrics(metadata_extractor_h metadata, int index,
        metadata_extractor_retvm_if(!_metadata, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Handle is NULL");
        metadata_extractor_retvm_if(!_metadata->path && !_metadata->buffer, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Invalid parameter");
 
-       *lyrics = NULL;
-       *time_stamp = 0;
-
        ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_TAG);
        if (ret != METADATA_EXTRACTOR_ERROR_NONE)
                return ret;
@@ -591,8 +565,8 @@ int metadata_extractor_get_metadata(metadata_extractor_h metadata, metadata_extr
        int i_value = 0;
        double d_value = 0;
        char *s_value = NULL;
-       int is_string = 0;
-       int is_double = 0;
+       bool is_string = false;
+       bool is_double = false;
 
        metadata_extractor_retvm_if(!_metadata, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Handle is NULL");
        metadata_extractor_retvm_if(!_metadata->path && !_metadata->buffer, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Invalid parameter");
@@ -603,349 +577,239 @@ int metadata_extractor_get_metadata(metadata_extractor_h metadata, metadata_extr
        metadata_extractor_retvm_if(ret != METADATA_EXTRACTOR_ERROR_NONE, ret, "fail to __extract_meta [%d]", ret);
 
        switch ((int)attribute) {  /*TODO (m.alieksieie): Remove casting after ACR*/
-       case METADATA_DURATION: {
-               is_string = 0;
+       case METADATA_DURATION:
                ret = __metadata_extractor_get_attr_int(_metadata, MM_FILE_CONTENT_DURATION, &i_value);
                break;
-       }
-       case METADATA_VIDEO_CODEC: {
-               is_string = 1;
+       case METADATA_VIDEO_CODEC:
+               is_string = true;
                ret = __metadata_extractor_get_video_codec(_metadata, &s_value);
                break;
-       }
-       case METADATA_VIDEO_BITRATE: {
-               is_string = 0;
+       case METADATA_VIDEO_BITRATE:
                ret = __metadata_extractor_get_video_attr_int(_metadata, MM_FILE_CONTENT_VIDEO_BITRATE, &i_value);
                break;
-       }
-       case METADATA_VIDEO_FPS: {
-               is_string = 0;
+       case METADATA_VIDEO_FPS:
                ret = __metadata_extractor_get_video_attr_int(_metadata, MM_FILE_CONTENT_VIDEO_FPS, &i_value);
                break;
-       }
-       case METADATA_VIDEO_WIDTH: {
-               is_string = 0;
+       case METADATA_VIDEO_WIDTH:
                ret = __metadata_extractor_get_video_attr_int(_metadata, MM_FILE_CONTENT_VIDEO_WIDTH, &i_value);
                break;
-       }
-       case METADATA_VIDEO_HEIGHT: {
-               is_string = 0;
+       case METADATA_VIDEO_HEIGHT:
                ret = __metadata_extractor_get_video_attr_int(_metadata, MM_FILE_CONTENT_VIDEO_HEIGHT, &i_value);
                break;
-       }
-       case METADATA_HAS_VIDEO: {
-               is_string = 0;
+       case METADATA_HAS_VIDEO:
                ret = __metadata_extractor_get_video_track_count(_metadata, &i_value);
                break;
-       }
-       case METADATA_AUDIO_CODEC: {
-               is_string = 1;
+       case METADATA_AUDIO_CODEC:
+               is_string = true;
                ret = __metadata_extractor_get_audio_codec(_metadata, &s_value);
                break;
-       }
-       case METADATA_AUDIO_BITRATE: {
-               is_string = 0;
+       case METADATA_AUDIO_BITRATE:
                ret = __metadata_extractor_get_audio_attr_int(_metadata, MM_FILE_CONTENT_AUDIO_BITRATE, &i_value);
                break;
-       }
-       case METADATA_AUDIO_CHANNELS: {
-               is_string = 0;
+       case METADATA_AUDIO_CHANNELS:
                ret = __metadata_extractor_get_audio_attr_int(_metadata, MM_FILE_CONTENT_AUDIO_CHANNELS, &i_value);
                break;
-       }
-       case METADATA_AUDIO_SAMPLERATE: {
-               is_string = 0;
+       case METADATA_AUDIO_SAMPLERATE:
                ret = __metadata_extractor_get_audio_attr_int(_metadata, MM_FILE_CONTENT_AUDIO_SAMPLERATE, &i_value);
                break;
-       }
-       case METADATA_AUDIO_BITPERSAMPLE: {
-               is_string = 0;
+       case METADATA_AUDIO_BITPERSAMPLE:
                ret = __metadata_extractor_get_audio_attr_int(_metadata, MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, &i_value);
                break;
-       }
-       case METADATA_HAS_AUDIO: {
-               is_string = 0;
+       case METADATA_HAS_AUDIO:
                ret = __metadata_extractor_get_audio_track_count(_metadata, &i_value);
                break;
-       }
-       case METADATA_ARTIST: {
-               is_string = 1;
+       case METADATA_ARTIST:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_ARTIST, &s_value);
                break;
-       }
-       case METADATA_TITLE: {
-               is_string = 1;
+       case METADATA_TITLE:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_TITLE, &s_value);
                break;
-       }
-       case METADATA_ALBUM: {
-               is_string = 1;
+       case METADATA_ALBUM:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_ALBUM, &s_value);
                break;
-       }
-       case METADATA_ALBUM_ARTIST: {
-               is_string = 1;
+       case METADATA_ALBUM_ARTIST:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_ALBUM_ARTIST, &s_value);
                break;
-       }
-       case METADATA_GENRE: {
-               is_string = 1;
+       case METADATA_GENRE:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_GENRE, &s_value);
                break;
-       }
-       case METADATA_COMPOSER: {
-               is_string = 1;
+       case METADATA_COMPOSER:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_AUTHOR, &s_value);
                break;
-       }
-       case METADATA_COPYRIGHT: {
-               is_string = 1;
+       case METADATA_COPYRIGHT:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_COPYRIGHT, &s_value);
                break;
-       }
-       case METADATA_DATE: {
-               is_string = 1;
+       case METADATA_DATE:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_DATE, &s_value);
                break;
-       }
-       case METADATA_DESCRIPTION: {
-               is_string = 1;
+       case METADATA_DESCRIPTION:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_DESCRIPTION, &s_value);
                break;
-       }
-       case METADATA_COMMENT: {
-               is_string = 1;
+       case METADATA_COMMENT:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_COMMENT, &s_value);
                break;
-       }
-       case METADATA_TRACK_NUM: {
-               is_string = 1;
+       case METADATA_TRACK_NUM:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_TRACK_NUM, &s_value);
                break;
-       }
-       case METADATA_CLASSIFICATION: {
-               is_string = 1;
+       case METADATA_CLASSIFICATION:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_CLASSIFICATION, &s_value);
                break;
-       }
-       case METADATA_RATING: {
-               is_string = 1;
+       case METADATA_RATING:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_RATING, &s_value);
                break;
-       }
-       case METADATA_LONGITUDE: {
-               is_double = 1;
+       case METADATA_LONGITUDE:
+               is_double = true;
                ret = __metadata_extractor_get_tag_double(_metadata, MM_FILE_TAG_LONGITUDE, &d_value);
                break;
-       }
-       case METADATA_LATITUDE: {
-               is_double = 1;
+       case METADATA_LATITUDE:
+               is_double = true;
                ret = __metadata_extractor_get_tag_double(_metadata, MM_FILE_TAG_LATIDUE, &d_value);
                break;
-       }
-       case METADATA_ALTITUDE: {
-               is_double = 1;
+       case METADATA_ALTITUDE:
+               is_double = true;
                ret = __metadata_extractor_get_tag_double(_metadata, MM_FILE_TAG_ALTIDUE, &d_value);
                break;
-       }
-       case METADATA_CONDUCTOR: {
-               is_string = 1;
+       case METADATA_CONDUCTOR:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_CONDUCTOR, &s_value);
                break;
-       }
-       case METADATA_UNSYNCLYRICS: {
-               is_string = 1;
+       case METADATA_UNSYNCLYRICS:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_UNSYNCLYRICS, &s_value);
                break;
-       }
-       case METADATA_SYNCLYRICS_NUM: {
-               is_string = 0;
+       case METADATA_SYNCLYRICS_NUM:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SYNCLYRICS_NUM, &i_value);
                break;
-       }
-       case METADATA_RECDATE: {
-               is_string = 1;
+       case METADATA_RECDATE:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_RECDATE, &s_value);
                break;
-       }
-       case METADATA_ROTATE: {
-               is_string = 1;
+       case METADATA_ROTATE:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_ROTATE, &s_value);
                break;
-       }
-       case METADATA_360: {
-               is_string = 0;
+       case METADATA_360:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL, &i_value);
                break;
-       }
 #ifdef SUPPORT_GSPHERICAL_METADATA
-       case METADATA_360_V1_STITCHED: {
-               is_string = 0;
+       case METADATA_360_V1_STITCHED:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_STITCHED, &i_value);
                break;
-       }
-       case METADATA_360_V1_PROJECTION_TYPE: {
-               is_string = 1;
+       case METADATA_360_V1_PROJECTION_TYPE:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_SPHERICAL_PROJECTION_TYPE, &s_value);
                break;
-       }
-       case METADATA_360_V1_STITCHING_SOFTWARE: {
-               is_string = 1;
+       case METADATA_360_V1_STITCHING_SOFTWARE:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_SPHERICAL_STITCHING_SOFTWARE, &s_value);
                break;
-       }
-       case METADATA_360_V1_STEREO_MODE: {
-               is_string = 1;
+       case METADATA_360_V1_STEREO_MODE:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_SPHERICAL_STEREO_MODE, &s_value);
                break;
-       }
-       case METADATA_360_V1_SOURCE_COUNT: {
-               is_string = 0;
+       case METADATA_360_V1_SOURCE_COUNT:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_SOURCE_COUNT, &i_value);
                break;
-       }
-       case METADATA_360_V1_INIT_VIEW_HEADING: {
-               is_string = 0;
+       case METADATA_360_V1_INIT_VIEW_HEADING:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_INIT_VIEW_HEADING, &i_value);
                break;
-       }
-       case METADATA_360_V1_INIT_VIEW_PITCH: {
-               is_string = 0;
+       case METADATA_360_V1_INIT_VIEW_PITCH:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_INIT_VIEW_PITCH, &i_value);
                break;
-       }
-       case METADATA_360_V1_INIT_VIEW_ROLL: {
-               is_string = 0;
+       case METADATA_360_V1_INIT_VIEW_ROLL:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_INIT_VIEW_ROLL, &i_value);
                break;
-       }
-       case METADATA_360_V1_TIMESTAMP: {
-               is_string = 0;
+       case METADATA_360_V1_TIMESTAMP:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_TIMESTAMP, &i_value);
                break;
-       }
-       case METADATA_360_V1_FULL_PANO_WIDTH: {
-               is_string = 0;
+       case METADATA_360_V1_FULL_PANO_WIDTH:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_FULL_PANO_WIDTH, &i_value);
                break;
-       }
-       case METADATA_360_V1_FULL_PANO_HEIGHT: {
-               is_string = 0;
+       case METADATA_360_V1_FULL_PANO_HEIGHT:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_FULL_PANO_HEIGHT, &i_value);
                break;
-       }
-       case METADATA_360_V1_CROPPED_AREA_IMAGE_WIDTH: {
-               is_string = 0;
+       case METADATA_360_V1_CROPPED_AREA_IMAGE_WIDTH:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_WIDTH, &i_value);
                break;
-       }
-       case METADATA_360_V1_CROPPED_AREA_IMAGE_HEIGHT: {
-               is_string = 0;
+       case METADATA_360_V1_CROPPED_AREA_IMAGE_HEIGHT:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_HEIGHT, &i_value);
                break;
-       }
-       case METADATA_360_V1_CROPPED_AREA_LEFT: {
-               is_string = 0;
+       case METADATA_360_V1_CROPPED_AREA_LEFT:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_LEFT, &i_value);
                break;
-       }
-       case METADATA_360_V1_CROPPED_AREA_TOP: {
-               is_string = 0;
+       case METADATA_360_V1_CROPPED_AREA_TOP:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_TOP, &i_value);
                break;
-       }
-       case METADATA_360_V2_STEREO_MODE: {
-               is_string = 0;
+       case METADATA_360_V2_STEREO_MODE:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_STEREO_MODE, &i_value);
                break;
-       }
-       case METADATA_360_V2_METADATA_SOURCE: {
-               is_string = 1;
+       case METADATA_360_V2_METADATA_SOURCE:
+               is_string = true;
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_SPHERICAL_V2_METADATA_SOURCE, &s_value);
                break;
-       }
-       case METADATA_360_V2_PROJ_TYPE: {
-               is_string = 0;
+       case METADATA_360_V2_PROJ_TYPE:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_PROJ_TYPE, &i_value);
                break;
-       }
-       case METADATA_360_V2_POSE_YAW: {
-               is_string = 0;
+       case METADATA_360_V2_POSE_YAW:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_POSE_YAW, &i_value);
                break;
-       }
-       case METADATA_360_V2_POSE_PITCH: {
-               is_string = 0;
+       case METADATA_360_V2_POSE_PITCH:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_POSE_PITCH, &i_value);
                break;
-       }
-       case METADATA_360_V2_POSE_ROLL: {
-               is_string = 0;
+       case METADATA_360_V2_POSE_ROLL:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_POSE_ROLL, &i_value);
                break;
-       }
-       case METADATA_360_V2_CBMP_LAYOUT: {
-               is_string = 0;
+       case METADATA_360_V2_CBMP_LAYOUT:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_CBMP_LAYOUT, &i_value);
                break;
-       }
-       case METADATA_360_V2_CBMP_PADDING: {
-               is_string = 0;
+       case METADATA_360_V2_CBMP_PADDING:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_CBMP_PADDING, &i_value);
                break;
-       }
-       case METADATA_360_V2_EQUI_BOUNDS_TOP: {
-               is_string = 0;
+       case METADATA_360_V2_EQUI_BOUNDS_TOP:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_TOP, &i_value);
                break;
-       }
-       case METADATA_360_V2_EQUI_BOUNDS_BOTTOM: {
-               is_string = 0;
+       case METADATA_360_V2_EQUI_BOUNDS_BOTTOM:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_BOTTOM, &i_value);
                break;
-       }
-       case METADATA_360_V2_EQUI_BOUNDS_LEFT: {
-               is_string = 0;
+       case METADATA_360_V2_EQUI_BOUNDS_LEFT:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_LEFT, &i_value);
                break;
-       }
-       case METADATA_360_V2_EQUI_BOUNDS_RIGHT: {
-               is_string = 0;
+       case METADATA_360_V2_EQUI_BOUNDS_RIGHT:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_RIGHT, &i_value);
                break;
-       }
-       case METADATA_AMBISONIC_TYPE: {
-               is_string = 0;
+       case METADATA_AMBISONIC_TYPE:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_AMBISONIC_TYPE, &i_value);
                break;
-       }
-       case METADATA_AMBISONIC_FORMAT: {
-               is_string = 0;
+       case METADATA_AMBISONIC_FORMAT:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_AMBISONIC_FORMAT, &i_value);
                break;
-       }
-       case METADATA_AMBISONIC_ORDER: {
-               is_string = 0;
+       case METADATA_AMBISONIC_ORDER:
                ret = __metadata_extractor_get_tag_int(_metadata, MM_FILE_TAG_AMBISONIC_ORDER, &i_value);
                break;
-       }
 #endif
        default:
-               break;
+               metadata_extractor_error("Invalid attribute [%d]", attribute);
+               return METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER;
        }
 
-       if (ret != METADATA_EXTRACTOR_ERROR_NONE) {
-               *value = NULL;
-               return ret;
-       }
+       metadata_extractor_retvm_if(ret != METADATA_EXTRACTOR_ERROR_NONE, ret, "Fail to get tag");
 
        if (is_string) {
                if (s_value && strlen(s_value) > 0)
                        *value = g_strdup(s_value);
-
-               /*Only use strdup in video_codec and audio_codec */
-               if (attribute == METADATA_VIDEO_CODEC || attribute == METADATA_AUDIO_CODEC)
-                       g_free(s_value);
        } else {
                if (is_double)
                        *value = g_strdup_printf("%f", d_value);
@@ -967,17 +831,13 @@ int metadata_extractor_get_artwork(metadata_extractor_h metadata, void **artwork
        metadata_extractor_retvm_if(!_metadata, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Handle is NULL");
        metadata_extractor_retvm_if(!_metadata->path && !_metadata->buffer, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Invalid parameter");
 
-       *artwork = NULL;
-       *mime_type = NULL;
-       *size = 0;
-
        ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_TAG);
        metadata_extractor_retvm_if(ret != METADATA_EXTRACTOR_ERROR_NONE, ret, "Fail: __metadata_extractor_check_and_extract_meta");
 
        ret = __metadata_extractor_get_artwork(_metadata, &_artwork, &_artwork_size);
        metadata_extractor_retvm_if(ret != METADATA_EXTRACTOR_ERROR_NONE, ret, "Fail: __metadata_extractor_get_artwork");
 
-       if (_artwork_size > 0 && _artwork) {
+       if (_artwork && _artwork_size > 0) {
                ret = __metadata_extractor_get_tag_str(_metadata, MM_FILE_TAG_ARTWORK_MIME, &_artwork_mime);
                metadata_extractor_retvm_if(ret != METADATA_EXTRACTOR_ERROR_NONE, ret, "Fail: __metadata_extractor_get_tag_str");
 
@@ -1000,9 +860,6 @@ int metadata_extractor_get_frame(metadata_extractor_h metadata, void **frame, in
        metadata_extractor_retvm_if(!_metadata->path && !_metadata->buffer, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Invalid parameter");
        metadata_extractor_retvm_if(!size, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Invalid parameter");
 
-       *frame = NULL;
-       *size = 0;
-
        ret = __metadata_extractor_check_and_extract_meta(_metadata, METADATA_TYPE_ATTR);
        if (ret != METADATA_EXTRACTOR_ERROR_NONE)
                return ret;
@@ -1011,7 +868,7 @@ int metadata_extractor_get_frame(metadata_extractor_h metadata, void **frame, in
        if (ret != METADATA_EXTRACTOR_ERROR_NONE)
                return ret;
 
-       if (_frame_size > 0 && _frame) {
+       if (_frame && _frame_size > 0) {
                *frame = g_memdup(_frame, _frame_size);
                *size = _frame_size;
        }
@@ -1034,8 +891,6 @@ int metadata_extractor_get_frame_at_time(metadata_extractor_h metadata, unsigned
        metadata_extractor_retvm_if(!size, METADATA_EXTRACTOR_ERROR_INVALID_PARAMETER, "Invalid parameter");
 
        micro_timestamp = (long long)timestamp * 1000;
-       *frame = NULL;
-       *size = 0;
 
        metadata_extractor_debug("accurate [%d] timestamp[%lu] micro_timestamp[%lld]", is_accurate, timestamp, micro_timestamp);