mm_file.c

   1 /*
   2  * libmm-fileinfo
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Haejeong Kim <backto.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>     /*for access*/
  25 #include <string.h>     /*for strXXX*/
  26 #include <dlfcn.h>
  27
  28 /* exported MM header files */
  29 #include <mm_file.h>
  30 #include <mm_attrs.h>
  31
  32 /* internal MM File headers */
  33 #include "mm_file_debug.h"
  34 #include "mm_file_formats.h"
  35 #include "mm_file_format_frame.h"
  36 #include "mm_file_codecs.h"
  37 #include "mm_file_utils.h"
  38
  39
  40 #include <sys/time.h>
  41
  42 /*#define CHECK_TIME */
  43
  44 #ifdef CHECK_TIME
  45 int64_t gettime(void)
  46 {
  47         struct timeval tv;
  48         gettimeofday(&tv, NULL);
  49         return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
  50 }
  51 #endif
  52
  53
  54 /**
  55  * Defines.
  56  */
  57
  58 #ifndef ARRAY_SIZE
  59 #define ARRAY_SIZE(arr)         (sizeof(arr) / sizeof((arr)[0]))
  60 #endif
  61
  62 #define _SEEK_POINT_    3000            /*1000 = 1 seconds*/
  63
  64 #define MM_FILE_TAG_SYNCLYRICS  "tag-synclyrics"        /**< Synchronized Lyrics Information*/
  65
  66
  67 enum {
  68         MM_FILE_TAG,
  69         MM_FILE_CONTENTS,
  70         MM_FILE_INVALID,
  71 };
  72
  73 enum {
  74         MM_FILE_PARSE_TYPE_SIMPLE,              /*parse audio/video track num only*/
  75         MM_FILE_PARSE_TYPE_NORMAL,              /*parse infomation without thumbnail*/
  76         MM_FILE_PARSE_TYPE_ALL,                 /*parse all infomation*/
  77         MM_FILE_PARSE_TYPE_SAFE,                /*parse infomation without both thumbnail and stream full-searching*/
  78 };
  79
  80 typedef struct {
  81         int     type;
  82         int     audio_track_num;
  83         int     video_track_num;
  84         bool is_uhqa;
  85 } MMFILE_PARSE_INFO;
  86
  87 typedef struct {
  88         void *formatFuncHandle;
  89         void *codecFuncHandle;
  90 } MMFILE_FUNC_HANDLE;
  91
  92
  93
  94 /**
  95  * global values.
  96  */
  97 static MMAttrsConstructInfo g_tag_attrs[] = {
  98         {(char *)"tag-artist",                  MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
  99         {(char *)"tag-title",                   MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 100         {(char *)"tag-album",                   MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 101         {(char *)"tag-album-artist",    MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 102         {(char *)"tag-genre",                   MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 103         {(char *)"tag-author",                  MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 104         {(char *)"tag-copyright",               MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 105         {(char *)"tag-date",                    MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 106         {(char *)"tag-description",             MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 107         {(char *)"tag-comment",         MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 108         {(char *)"tag-artwork",         MM_ATTRS_TYPE_DATA,     MM_ATTRS_FLAG_RW, (void *)NULL},
 109         {(char *)"tag-artwork-size",    MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 110         {(char *)"tag-artwork-mime",    MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 111         {(char *)"tag-track-num",               MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 112         {(char *)"tag-classification",  MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 113         {(char *)"tag-rating",                  MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 114         {(char *)"tag-longitude",               MM_ATTRS_TYPE_DOUBLE,   MM_ATTRS_FLAG_RW, (void *)0},
 115         {(char *)"tag-latitude",                MM_ATTRS_TYPE_DOUBLE,   MM_ATTRS_FLAG_RW, (void *)0},
 116         {(char *)"tag-altitude",                MM_ATTRS_TYPE_DOUBLE,   MM_ATTRS_FLAG_RW, (void *)0},
 117         {(char *)"tag-conductor",               MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 118         {(char *)"tag-unsynclyrics",    MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 119         {(char *)"tag-synclyrics-num",  MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 120         {(char *)"tag-synclyrics",              MM_ATTRS_TYPE_DATA,     MM_ATTRS_FLAG_RW, (void *)NULL},
 121         {(char *)"tag-recdate",         MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 122         {(char *)"tag-part-of-set",             MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 123         {(char *)"tag-rotate",                  MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 124         {(char *)"tag-cdis",                    MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 125         {(char *)"tag-smta",                    MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 126         {(char *)"tag-spherical",                                       MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 127         {(char *)"tag-stitched",                                        MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 128         {(char *)"tag-stitching-software",                      MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 129         {(char *)"tag-projection-type",                         MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 130         {(char *)"tag-stereo-mode",                                     MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 131         {(char *)"tag-source-count",                            MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 132         {(char *)"tag-init-view-heading",                       MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 133         {(char *)"tag-init-view-pitch",                         MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 134         {(char *)"tag-init-view-roll",                          MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 135         {(char *)"tag-timestamp",                                       MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 136         {(char *)"tag-full-pano-width",                         MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 137         {(char *)"tag-full-pano-height",                        MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 138         {(char *)"tag-cropped-area-image-width",        MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 139         {(char *)"tag-cropped-area-image-height",       MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 140         {(char *)"tag-cropped-area-left",                       MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 141         {(char *)"tag-cropped-area-top",                        MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 142         {(char *)"tag-ambisonic-type",                          MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 143         {(char *)"tag-ambisonic-format",                        MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 144         {(char *)"tag-ambisonic-order",                         MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 145         {(char *)"stereo-mode-v2",                                              MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 146         {(char *)"metadata-source-v2",                                  MM_ATTRS_TYPE_STRING,   MM_ATTRS_FLAG_RW, (void *)NULL},
 147         {(char *)"proj-type-v2",                                                MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 148         {(char *)"pose-yaw-degrees-v2",                                 MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 149         {(char *)"pose-pitch-degrees-v2",                               MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 150         {(char *)"pose-roll-degrees-v2",                                MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 151         {(char *)"cbmp-layout-v2",                                              MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 152         {(char *)"cbmp-padding-v2",                                             MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 153         {(char *)"equi-projection-bounds-top-v2",               MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 154         {(char *)"equi-projection-bounds-bottom-v2",    MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 155         {(char *)"equi-projection-bounds-left-v2",              MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 156         {(char *)"equi-projection-bounds-right-v2",             MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 157 };
 158
 159 static MMAttrsConstructInfo g_content_attrs[] = {
 160         {(char *)"content-duration",                    MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 161         {(char *)"content-video-codec",         MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 162         {(char *)"content-video-format",                MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 163         {(char *)"content-video-bitrate",               MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 164         {(char *)"content-video-fps",                   MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 165         {(char *)"content-video-width",         MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 166         {(char *)"content-video-height",                MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 167         {(char *)"content-video-thumbnail",             MM_ATTRS_TYPE_DATA,     MM_ATTRS_FLAG_RW, (void *)NULL},
 168         {(char *)"content-video-track-index",   MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 169         {(char *)"content-video-track-count",   MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 170         {(char *)"content-audio-codec",         MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 171         {(char *)"content-audio-bitrate",               MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 172         {(char *)"content-audio-channels",              MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 173         {(char *)"content-audio-samplerate",    MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 174         {(char *)"content-audio-track-index",   MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 175         {(char *)"content-audio-track-count",   MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 176         {(char *)"content-audio-bitpersample",  MM_ATTRS_TYPE_INT,              MM_ATTRS_FLAG_RW, (void *)0},
 177 };
 178
 179 #ifdef __MMFILE_DYN_LOADING__
 180 #define MMFILE_FORMAT_SO_FILE_NAME  LIBDIR"/libmmfile_formats.so"
 181 #define MMFILE_CODEC_SO_FILE_NAME   LIBDIR"/libmmfile_codecs.so"
 182
 183 static int (*mmfile_format_open)(MMFileFormatContext **formatContext, MMFileSourceType *fileSrc);
 184 static int (*mmfile_format_read_stream)(MMFileFormatContext *formatContext);
 185 static int (*mmfile_format_read_frame)(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
 186 static int (*mmfile_format_read_tag)(MMFileFormatContext *formatContext);
 187 static int (*mmfile_format_close)(MMFileFormatContext *formatContext);
 188 static int (*mmfile_codec_open)(MMFileCodecContext **codecContext, int codecType, int codecId, MMFileCodecFrame *input);
 189 static int (*mmfile_codec_decode)(MMFileCodecContext *codecContext, MMFileCodecFrame *output);
 190 static int (*mmfile_codec_close)(MMFileCodecContext *codecContext);
 191 static int (*mmfile_format_get_frame)(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
 192 static int (*mmfile_format_get_frame_from_memory)(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
 193 #endif
 194
 195 #ifdef __MMFILE_DYN_LOADING__
 196 static int _load_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
 197 {
 198 /*      static int dll_func_initialized = 0; //disabled */
 199
 200         int ret = 0;
 201
 202         /* Get from function argument */
 203         void *formatFuncHandle = NULL;
 204         void *codecFuncHandle = NULL;
 205
 206         /* disabled
 207         if (dll_func_initialized) {
 208                 return 1;
 209         }
 210         */
 211
 212         formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
 213         if (!formatFuncHandle) {
 214                 debug_error(DEBUG, "error: %s %s\n", "libmmfile_formats.so open error", dlerror());
 215                 ret = 0;
 216                 goto exception;
 217         }
 218
 219         mmfile_format_open                      = dlsym(formatFuncHandle, "mmfile_format_open");
 220         mmfile_format_read_stream       = dlsym(formatFuncHandle, "mmfile_format_read_stream");
 221         mmfile_format_read_frame        = dlsym(formatFuncHandle, "mmfile_format_read_frame");
 222         mmfile_format_read_tag          = dlsym(formatFuncHandle, "mmfile_format_read_tag");
 223         mmfile_format_close                     = dlsym(formatFuncHandle, "mmfile_format_close");
 224
 225         if (!mmfile_format_open ||
 226             !mmfile_format_read_stream ||
 227             !mmfile_format_read_frame ||
 228             !mmfile_format_read_tag ||
 229             !mmfile_format_close) {
 230
 231                 debug_error(DEBUG, "error: %s\n", "format function load error");
 232                 ret = 0;
 233                 goto exception;
 234         }
 235
 236         /*closed at app termination.*/
 237         /*dlclose (formatFuncHandle); */
 238
 239         codecFuncHandle = dlopen(MMFILE_CODEC_SO_FILE_NAME, RTLD_LAZY | RTLD_GLOBAL);
 240         if (!codecFuncHandle) {
 241                 debug_error(DEBUG, "error: %s\n", "libmmfile_codecs.so open error");
 242                 ret = 0;
 243                 goto exception;
 244         }
 245
 246         mmfile_codec_open               = dlsym(codecFuncHandle, "mmfile_codec_open");
 247         mmfile_codec_decode     = dlsym(codecFuncHandle, "mmfile_codec_decode");
 248         mmfile_codec_close              = dlsym(codecFuncHandle, "mmfile_codec_close");
 249
 250         if (!mmfile_codec_open || !mmfile_codec_decode || !mmfile_codec_close) {
 251                 debug_error(DEBUG, "error: %s\n", "codec function load error");
 252                 ret = 0;
 253                 goto exception;
 254         }
 255
 256         /*closed at app termination.*/
 257         /*dlclose (codecFuncHandle); */
 258
 259 /*      dll_func_initialized = 1; // disabled */
 260
 261         pHandle->codecFuncHandle = codecFuncHandle;
 262         pHandle->formatFuncHandle = formatFuncHandle;
 263
 264         return 1;
 265
 266 exception:
 267         if (formatFuncHandle) dlclose(formatFuncHandle);
 268         if (codecFuncHandle)  dlclose(codecFuncHandle);
 269
 270         return ret;
 271 }
 272
 273 static void _unload_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
 274 {
 275         debug_fenter(RELEASE);
 276
 277         if (pHandle->formatFuncHandle) {
 278                 dlclose(pHandle->formatFuncHandle);
 279         }
 280         if (pHandle->codecFuncHandle) {
 281                 dlclose(pHandle->codecFuncHandle);
 282         }
 283
 284         debug_fleave(RELEASE);
 285 }
 286
 287
 288 #endif /* __MMFILE_DYN_LOADING__ */
 289
 290 /**
 291  * local functions.
 292  */
 293 static int
 294 _is_file_exist(const char *filename)
 295 {
 296         int ret = FILEINFO_ERROR_NONE;
 297         if (filename) {
 298                 const char *to_access = (strstr(filename, "file://") != NULL) ? filename + 7 : filename;
 299                 ret = access(to_access, R_OK);
 300                 if (ret < 0) {
 301                         if (errno == EACCES || errno == EPERM) {
 302                                 debug_error(DEBUG, "Permission denied [%s]", to_access);
 303                                 ret = FILEINFO_ERROR_PERMISSION_DENIED;
 304                         } else {
 305                                 debug_error(DEBUG, "Not exist file [%s]", to_access);
 306                                 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
 307                         }
 308                 }
 309         }
 310         return ret;
 311 }
 312
 313 static int
 314 _info_set_attr_media(MMHandleType attrs, MMFileFormatContext *formatContext)
 315 {
 316         int ret = 0;
 317
 318         if (formatContext->commandType == MM_FILE_TAG) {
 319                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_TITLE, formatContext->title);
 320                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ARTIST, formatContext->artist);
 321                 if (formatContext->author)
 322                         mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_AUTHOR, formatContext->author);
 323                 else
 324                         mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_AUTHOR, formatContext->composer);
 325                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ALBUM, formatContext->album);
 326                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ALBUM_ARTIST, formatContext->album_artist);
 327                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_COPYRIGHT, formatContext->copyright);
 328                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_DESCRIPTION, formatContext->description);
 329                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_COMMENT, formatContext->comment);
 330                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_GENRE, formatContext->genre);
 331                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_CLASSIFICATION, formatContext->classification);
 332                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_DATE, formatContext->year);
 333                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_TRACK_NUM, formatContext->tagTrackNum);
 334                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_RATING, formatContext->rating);
 335                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_CONDUCTOR, formatContext->conductor);
 336                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_RECDATE, formatContext->recDate);
 337                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_POS, formatContext->part_of_set);
 338
 339                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ROTATE, formatContext->rotate);
 340                 mm_attrs_set_double_by_name(attrs, MM_FILE_TAG_LONGITUDE, formatContext->longitude);
 341                 mm_attrs_set_double_by_name(attrs, MM_FILE_TAG_LATIDUE, formatContext->latitude);
 342                 mm_attrs_set_double_by_name(attrs, MM_FILE_TAG_ALTIDUE, formatContext->altitude);
 343                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SYNCLYRICS_NUM, formatContext->syncLyricsNum);
 344                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_CDIS, formatContext->cdis);
 345                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SMTA, formatContext->smta);
 346
 347                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL, formatContext->isSpherical);
 348                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_STITCHED, formatContext->isStitched);
 349                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_SPHERICAL_STITCHING_SOFTWARE, formatContext->stitchingSoftware);
 350                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_SPHERICAL_PROJECTION_TYPE, formatContext->projectionType);
 351                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_SPHERICAL_STEREO_MODE, formatContext->stereoMode);
 352                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_SOURCE_COUNT, formatContext->sourceCount);
 353                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_INIT_VIEW_HEADING, formatContext->initViewHeading);
 354                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_INIT_VIEW_PITCH, formatContext->initViewPitch);
 355                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_INIT_VIEW_ROLL, formatContext->initViewRoll);
 356                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_TIMESTAMP, formatContext->timestamp);
 357                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_FULL_PANO_WIDTH, formatContext->fullPanoWidth);
 358                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_FULL_PANO_HEIGHT, formatContext->fullPanoHeight);
 359                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_WIDTH, formatContext->croppedAreaImageWidth);
 360                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_HEIGHT, formatContext->croppedAreaImageHeight);
 361                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_LEFT, formatContext->croppedAreaLeft);
 362                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_TOP, formatContext->croppedAreaTop);
 363
 364                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_AMBISONIC_TYPE, formatContext->ambisonicType);
 365                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_AMBISONIC_FORMAT, formatContext->ambisonicFormat);
 366                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_AMBISONIC_ORDER, formatContext->ambisonicOrder);
 367
 368                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_STEREO_MODE, formatContext->stereoModeV2);
 369                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_METADATA_SOURCE, formatContext->metadataSourceV2);
 370                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_PROJ_TYPE, formatContext->projTypeV2);
 371                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_POSE_YAW, formatContext->poseYawV2);
 372                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_POSE_PITCH, formatContext->posePitchV2);
 373                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_POSE_ROLL, formatContext->poseRollV2);
 374                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_CBMP_LAYOUT, formatContext->cbmpLayoutV2);
 375                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_CBMP_PADDING, formatContext->cbmpPaddingV2);
 376                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_TOP, formatContext->equiBoundsTopV2);
 377                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_BOTTOM, formatContext->equiBoundsBottomV2);
 378                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_LEFT, formatContext->equiBoundsLeftV2);
 379                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_RIGHT, formatContext->equiBoundsRightV2);
 380
 381                 mm_attrs_set_data_by_name(attrs, MM_FILE_TAG_SYNCLYRICS, formatContext->syncLyrics, formatContext->syncLyricsNum);
 382
 383                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_UNSYNCLYRICS, formatContext->unsyncLyrics);
 384
 385                 if (formatContext->artwork && formatContext->artworkSize > 0) {
 386                         void *artworkCopy = NULL;
 387                         artworkCopy = mmfile_malloc((formatContext->artworkSize));
 388                         if (artworkCopy) {
 389                                 memcpy(artworkCopy, formatContext->artwork, formatContext->artworkSize);
 390                                 mm_attrs_set_data_by_name(attrs, MM_FILE_TAG_ARTWORK, artworkCopy, formatContext->artworkSize);
 391                                 mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_ARTWORK_SIZE, formatContext->artworkSize);
 392                                 mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ARTWORK_MIME, formatContext->artworkMime);
 393                         }
 394                 }
 395         } else if (formatContext->commandType == MM_FILE_CONTENTS) {
 396                 /*get duration*/
 397                 mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_DURATION, formatContext->duration);
 398                 mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_TRACK_COUNT, formatContext->audioTotalTrackNum);
 399                 mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_TRACK_COUNT, formatContext->videoTotalTrackNum);
 400
 401                 if (formatContext->videoTotalTrackNum > 0 &&
 402                     formatContext->nbStreams > 0 &&
 403                     formatContext->streams[MMFILE_VIDEO_STREAM]) {
 404
 405                         MMFileFormatStream *videoStream = formatContext->streams[MMFILE_VIDEO_STREAM];
 406
 407                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_FORMAT, formatContext->formatType);
 408                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_CODEC, videoStream->codecId);
 409                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_BITRATE, videoStream->bitRate);
 410                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_FPS, videoStream->framePerSec);
 411                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_WIDTH, videoStream->width);
 412                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_HEIGHT, videoStream->height);
 413
 414                         if (formatContext->thumbNail && formatContext->thumbNail->frameData) {
 415                                 void *thumbNailCopy = NULL;
 416                                 thumbNailCopy = mmfile_malloc(formatContext->thumbNail->frameSize);
 417
 418                                 if (thumbNailCopy) {
 419                                         memcpy(thumbNailCopy, formatContext->thumbNail->frameData, formatContext->thumbNail->frameSize);
 420                                         mm_attrs_set_data_by_name(attrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, thumbNailCopy, formatContext->thumbNail->frameSize);
 421                                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_WIDTH, formatContext->thumbNail->frameWidth);
 422                                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_HEIGHT, formatContext->thumbNail->frameHeight);
 423                                 }
 424                         }
 425                 }
 426
 427                 if (formatContext->audioTotalTrackNum > 0 &&
 428                     formatContext->nbStreams > 0 &&
 429                     formatContext->streams[MMFILE_AUDIO_STREAM]) {
 430
 431                         MMFileFormatStream *audioStream = formatContext->streams[MMFILE_AUDIO_STREAM];
 432
 433                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_CODEC, audioStream->codecId);
 434                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_CHANNELS, audioStream->nbChannel);
 435                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_BITRATE, audioStream->bitRate);
 436                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_SAMPLERATE, audioStream->samplePerSec);
 437                         mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, audioStream->bitPerSample);
 438                 }
 439         } else {
 440                 ret = -1;
 441         }
 442
 443         /*commit attrs*/
 444         mm_attrs_commit_all(attrs);
 445
 446         return ret;
 447 }
 448
 449 /**
 450  * @param       frameContext    [in]    frame for decoding.
 451  * @param       videoStream             [in]    information of video codec for frameContext.
 452  * @param       decodedFrame    [inout] frame after decoding frameContext.
 453  */
 454 static int
 455 __decode_contents_frame(MMFileFormatFrame *frameContext, MMFileFormatStream *videoStream, MMFileCodecFrame *decodedFrame)
 456 {
 457         int ret = FILEINFO_ERROR_NONE;
 458         MMFileCodecContext *codecContext = NULL;
 459         MMFileCodecFrame codecFrame = {0, };
 460
 461         if (!frameContext || !videoStream || !decodedFrame) {
 462                 debug_error(DEBUG, "error: invalid parameters (%p %p %p)\n", frameContext, videoStream, decodedFrame);
 463                 return FILEINFO_ERROR_FILE_INTERNAL;
 464         }
 465
 466         codecFrame.frameDataSize = frameContext->frameSize;
 467         codecFrame.width = frameContext->frameWidth;
 468         codecFrame.height = frameContext->frameHeight;
 469         codecFrame.frameData = frameContext->frameData;
 470         codecFrame.configLen = frameContext->configLenth;
 471         codecFrame.configData = frameContext->configData;
 472         codecFrame.version = videoStream->version;
 473
 474         if (MMFILE_FORMAT_FAIL == mmfile_codec_open(&codecContext, MMFILE_VIDEO_DECODE, videoStream->codecId, &codecFrame)) {
 475                 debug_error(DEBUG, "error: mmfile_codec_open\n");
 476                 mmfile_codec_close(codecContext);
 477                 return FILEINFO_ERROR_FILE_INTERNAL;
 478         }
 479
 480         if (MMFILE_FORMAT_FAIL == mmfile_codec_decode(codecContext, decodedFrame)) {
 481                 debug_error(DEBUG, "error: mmfile_codec_decode\n");
 482                 ret = FILEINFO_ERROR_FILE_INTERNAL;
 483         }
 484
 485         mmfile_codec_close(codecContext);
 486
 487         return ret;
 488 }
 489
 490 static int
 491 __get_contents_thumbnail(MMFileFormatContext *formatContext)
 492 {
 493         int ret = FILEINFO_ERROR_NONE;
 494         MMFileFormatFrame frameContext = {0, };
 495         MMFileCodecFrame decodedFrame = {0, };
 496         MMFileFormatFrame *thumbnail = NULL;
 497
 498         if (!formatContext) {
 499                 debug_error(DEBUG, "error: invalid parameter (%p)\n", formatContext);
 500                 return FILEINFO_ERROR_FILE_INTERNAL;
 501         }
 502
 503         if (MMFILE_FORMAT_FAIL == mmfile_format_read_frame(formatContext, _SEEK_POINT_, &frameContext)) {
 504                 debug_error(DEBUG, "error: mmfile_format_read_frame\n");
 505                 ret = FILEINFO_ERROR_FILE_INTERNAL;
 506                 goto exception;
 507         }
 508
 509         /* set video thumbnail */
 510         thumbnail = mmfile_malloc(sizeof(MMFileFormatFrame));
 511         if (!thumbnail) {
 512                 debug_error(DEBUG, "error: mmfile_malloc\n");
 513                 ret = FILEINFO_ERROR_FILE_INTERNAL;
 514                 goto exception;
 515         }
 516
 517         if (frameContext.bCompressed) {
 518                 ret = __decode_contents_frame(&frameContext, formatContext->streams[MMFILE_VIDEO_STREAM], &decodedFrame);
 519                 if (FILEINFO_ERROR_NONE != ret) {
 520                         debug_error(DEBUG, "error: __decode_contents_thumbnail\n");
 521                         goto exception;
 522                 }
 523
 524                 /* after decoding frameContext is done, it is no needed */
 525                 mmfile_free(frameContext.frameData);
 526                 mmfile_free(frameContext.configData);
 527
 528                 thumbnail->frameSize = decodedFrame.frameDataSize;
 529                 thumbnail->frameWidth = decodedFrame.width;
 530                 thumbnail->frameHeight = decodedFrame.height;
 531                 thumbnail->frameData = decodedFrame.frameData;
 532                 thumbnail->configLenth = 0;
 533                 thumbnail->configData = NULL;
 534         } else {
 535                 thumbnail->frameSize = frameContext.frameSize;
 536                 thumbnail->frameWidth = frameContext.frameWidth;
 537                 thumbnail->frameHeight = frameContext.frameHeight;
 538                 thumbnail->frameData = frameContext.frameData;
 539                 thumbnail->configLenth = 0;
 540                 thumbnail->configData = NULL;
 541         }
 542
 543 #ifdef __MMFILE_TEST_MODE__
 544         mmfile_format_print_frame(thumbnail);
 545 #endif
 546
 547         formatContext->thumbNail = thumbnail;
 548
 549         /* because #MMFILE_FORMAT_SUCCESS is different with #FILEINFO_ERROR_NONE */
 550         return FILEINFO_ERROR_NONE;
 551 exception:
 552         if (frameContext.bCompressed) {
 553                 mmfile_free(decodedFrame.frameData);
 554                 mmfile_free(decodedFrame.configData);
 555         }
 556
 557         mmfile_free(thumbnail);
 558         mmfile_free(frameContext.frameData);
 559         mmfile_free(frameContext.configData);
 560
 561         return ret;
 562 }
 563
 564 static int
 565 _get_contents_info(MMHandleType attrs, MMFileSourceType *src, MMFILE_PARSE_INFO *parse)
 566 {
 567         MMFileFormatContext *formatContext = NULL;
 568         int ret = 0;
 569
 570         if (!src || !parse) {
 571                 debug_error(DEBUG, "error: invalid parameters (%p, %p)\n", src, parse);
 572                 return FILEINFO_ERROR_FILE_INTERNAL;
 573         }
 574
 575         if (MMFILE_FORMAT_FAIL == mmfile_format_open(&formatContext, src) || formatContext == NULL) {
 576                 debug_error(DEBUG, "error: mmfile_format_open\n");
 577                 ret = FILEINFO_ERROR_FILE_INTERNAL;
 578                 goto exception;
 579         }
 580
 581         if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL) {
 582                 if (parse->type == MM_FILE_PARSE_TYPE_SAFE)
 583                         formatContext->cdis = 1;
 584
 585                 if (MMFILE_FORMAT_FAIL == mmfile_format_read_stream(formatContext)) {
 586                         debug_error(DEBUG, "error: mmfile_format_read_stream\n");
 587                         ret = FILEINFO_ERROR_FILE_INTERNAL;
 588                         goto exception;
 589                 }
 590
 591                 parse->audio_track_num = formatContext->audioTotalTrackNum;
 592                 parse->video_track_num = formatContext->videoTotalTrackNum;
 593
 594                 /* check uhqa content*/
 595                 if (formatContext->streams[MMFILE_AUDIO_STREAM] != NULL)
 596                         parse->is_uhqa = formatContext->streams[MMFILE_AUDIO_STREAM]->is_uhqa;
 597                 else
 598                         parse->is_uhqa = FALSE;
 599
 600                 if (parse->type >= MM_FILE_PARSE_TYPE_ALL && formatContext->videoTotalTrackNum > 0) {
 601 /*why below code needed?
 602 This API is for extracting some attributes not metadata(TAG). mm_file_create_content_attrs() use this API.
 603 but MMFileUtilGetMetaDataFromMP4() Extract just TAG info. That is needed for mm_file_create_tag_attrs()*/
 604 #if 0
 605                         if (parse->type != MM_FILE_PARSE_TYPE_SAFE) {
 606                                 if (formatContext->formatType == MM_FILE_FORMAT_3GP || formatContext->formatType == MM_FILE_FORMAT_MP4) {
 607                                         MMFileUtilGetMetaDataFromMP4(formatContext);
 608                                 }
 609                         }
 610 #endif
 611                         ret = __get_contents_thumbnail(formatContext);
 612                         if (FILEINFO_ERROR_NONE != ret) {
 613                                 debug_error(DEBUG, "error: __get_contents_thumbnail\n");
 614                                 ret = FILEINFO_ERROR_NONE;
 615                         }
 616                 }
 617         } else {
 618                 /**
 619                  * if MM_FILE_PARSE_TYPE_SIMPLE, just get number of each stream.
 620                  */
 621                 parse->audio_track_num = formatContext->audioTotalTrackNum;
 622                 parse->video_track_num = formatContext->videoTotalTrackNum;
 623         }
 624
 625         formatContext->commandType = MM_FILE_CONTENTS;
 626
 627         if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
 628                 _info_set_attr_media(attrs, formatContext);
 629
 630         if (formatContext->thumbNail) {
 631                 mmfile_free(formatContext->thumbNail->frameData);
 632                 mmfile_free(formatContext->thumbNail->configData);
 633                 mmfile_free(formatContext->thumbNail);
 634         }
 635
 636 exception:
 637         if (formatContext)
 638                 mmfile_format_close(formatContext);
 639
 640         return ret;
 641 }
 642
 643
 644 static int
 645 _get_tag_info(MMHandleType attrs, MMFileSourceType *src)
 646 {
 647         MMFileFormatContext *formatContext = NULL;
 648         int ret = 0;
 649
 650         ret = mmfile_format_open(&formatContext, src);
 651         if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
 652                 debug_error(DEBUG, "error: mmfile_format_open\n");
 653                 ret = FILEINFO_ERROR_FILE_INTERNAL;
 654                 goto exception;
 655         }
 656
 657         ret = mmfile_format_read_tag(formatContext);
 658         if (MMFILE_FORMAT_FAIL == ret) {
 659                 debug_warning(DEBUG, "reading tag is fail\n");
 660                 ret = FILEINFO_ERROR_FILE_INTERNAL;
 661                 goto exception;
 662         }
 663
 664         formatContext->commandType = MM_FILE_TAG;
 665
 666         _info_set_attr_media(attrs, formatContext);
 667
 668         if (formatContext)  {
 669                 mmfile_format_close(formatContext);
 670         }
 671
 672         return FILEINFO_ERROR_NONE;
 673
 674
 675 exception:
 676         if (formatContext)  {
 677                 mmfile_format_close(formatContext);
 678         }
 679
 680         return FILEINFO_ERROR_FILE_INTERNAL;
 681 }
 682
 683
 684 /**
 685  * global functions.
 686  */
 687 int mm_file_get_attrs(MMHandleType attrs, char **err_attr_name, const char *first_attribute_name, ...)
 688 {
 689         int ret = FILEINFO_ERROR_NONE;
 690         va_list var_args;
 691
 692         if (!attrs) {
 693                 debug_error(DEBUG, "Invalid arguments [attrs 0]\n");
 694                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 695         }
 696
 697         if (first_attribute_name == NULL) {
 698                 debug_error(DEBUG, "Invalid arguments [first_attribute_name null]\n");
 699                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 700         }
 701
 702         /* get requested attributes */
 703         va_start(var_args, first_attribute_name);
 704         ret = mm_attrs_get_valist(attrs, err_attr_name, first_attribute_name, var_args);
 705         va_end(var_args);
 706
 707         if (ret != FILEINFO_ERROR_NONE) {
 708                 if (err_attr_name) {
 709                         debug_error(DEBUG, "failed to get %s\n", *err_attr_name);
 710                 }
 711         }
 712
 713         return ret;
 714 }
 715
 716 int mm_file_get_synclyrics_info(MMHandleType tag_attrs, int index, unsigned long *time_info, char **lyrics)
 717 {
 718         int ret = FILEINFO_ERROR_NONE;
 719         AvSynclyricsInfo *sync_lyric_item = NULL;
 720         GList *synclyrics_list = NULL;
 721
 722         debug_fenter(RELEASE);
 723
 724         if (tag_attrs == NULL) {
 725                 debug_error(DEBUG, "invalid handle");
 726                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 727         }
 728
 729         ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
 730         if (ret != FILEINFO_ERROR_NONE) {
 731                 debug_warning(RELEASE, "get data fail");
 732                 return ret;
 733         }
 734
 735         if (synclyrics_list != NULL) {
 736
 737                 sync_lyric_item = (AvSynclyricsInfo *)g_list_nth_data(synclyrics_list, index);
 738
 739                 if (sync_lyric_item == NULL) {
 740                         debug_warning(RELEASE, "synclyric item is NULL");
 741                         return FILEINFO_ERROR_ATTR_NOT_EXIST;
 742                 }
 743
 744                 *time_info = sync_lyric_item->time_info;
 745                 *lyrics = sync_lyric_item->lyric_info;
 746
 747         } else {
 748                 debug_warning(RELEASE, "synclyrics_list is NULL");
 749                 return FILEINFO_ERROR_ATTR_NOT_EXIST;
 750         }
 751
 752         return ret;
 753
 754 }
 755
 756 int mm_file_create_tag_attrs(MMHandleType *tag_attrs, const char *filename)
 757 {
 758         int ret = FILEINFO_ERROR_NONE;
 759         MMHandleType attrs = NULL;
 760         MMFileSourceType src;
 761
 762         debug_fenter(RELEASE);
 763
 764         /* Check argument here */
 765         if (tag_attrs == NULL) {
 766                 debug_error(DEBUG, "Invalid arguments [tag null]\n");
 767                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 768         }
 769         if (filename == NULL) {
 770                 debug_error(DEBUG, "Invalid arguments [filename null]\n");
 771                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 772         }
 773         if (strlen(filename) == 0)      {
 774                 debug_error(DEBUG, "Invalid arguments [filename size 0]\n");
 775                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 776         }
 777
 778
 779 #ifdef __MMFILE_DYN_LOADING__
 780         MMFILE_FUNC_HANDLE func_handle;
 781
 782         ret = _load_dynamic_functions(&func_handle);
 783         if (ret == 0) {
 784                 debug_error(DEBUG, "load library error\n");
 785                 return FILEINFO_ERROR_FILE_INTERNAL;
 786         }
 787 #endif
 788
 789         /*set source file infomation*/
 790         MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
 791
 792         ret = _is_file_exist(filename);
 793         if (ret != FILEINFO_ERROR_NONE) {
 794                 goto END;
 795         }
 796
 797         /*set attrs*/
 798         ret = mm_attrs_new(g_tag_attrs, ARRAY_SIZE(g_tag_attrs), "tag", NULL, NULL, &attrs);
 799         if (ret) {
 800                 debug_error(DEBUG, "attribute internal error.\n");
 801                 ret = FILEINFO_ERROR_FILE_INTERNAL;
 802                 goto END;
 803         }
 804
 805         ret = _get_tag_info(attrs, &src);
 806         if (ret != FILEINFO_ERROR_NONE) {
 807                 mm_attrs_free(attrs);
 808                 attrs = NULL;
 809                 debug_error(DEBUG, "failed to get tag: %s\n", filename);
 810         }
 811
 812         *tag_attrs = attrs;
 813
 814 END:
 815 #ifdef __MMFILE_DYN_LOADING__
 816         _unload_dynamic_functions(&func_handle);
 817 #endif
 818
 819         debug_fleave(RELEASE);
 820
 821         return ret;
 822 }
 823
 824
 825 EXPORT_API
 826 int mm_file_destroy_tag_attrs(MMHandleType tag_attrs)
 827 {
 828         void *artwork = NULL;
 829         GList *synclyrics_list = NULL;
 830         int ret = FILEINFO_ERROR_NONE;
 831
 832         debug_fenter(RELEASE);
 833
 834         if (tag_attrs == NULL) {
 835                 debug_error(DEBUG, "invalid handle.\n");
 836                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 837         }
 838
 839         ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_ARTWORK, &artwork);
 840         mmfile_free(artwork);
 841
 842         ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
 843         mm_file_free_synclyrics_list(synclyrics_list);
 844         mm_attrs_free(tag_attrs);
 845
 846         debug_fleave(RELEASE);
 847
 848         return ret;
 849 }
 850
 851 EXPORT_API
 852 int mm_file_create_content_attrs(MMHandleType *contents_attrs, const char *filename)
 853 {
 854         MMHandleType attrs = NULL;
 855         MMFileSourceType src = {0, };
 856         MMFILE_PARSE_INFO parse = {0, };
 857         int ret = 0;
 858
 859         debug_fenter(RELEASE);
 860
 861         /* Check argument here */
 862         if (contents_attrs == NULL) {
 863                 debug_error(DEBUG, "Invalid arguments [contents null]\n");
 864                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 865         }
 866         if (filename == NULL) {
 867                 debug_error(DEBUG, "Invalid arguments [filename null]\n");
 868                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 869         }
 870         if (strlen(filename) == 0)      {
 871                 debug_error(DEBUG, "Invalid arguments [filename size 0]\n");
 872                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 873         }
 874
 875
 876 #ifdef __MMFILE_DYN_LOADING__
 877         MMFILE_FUNC_HANDLE func_handle;
 878
 879 #ifdef CHECK_TIME
 880         int64_t ti;
 881         ti = gettime();
 882 #endif
 883
 884         ret = _load_dynamic_functions(&func_handle);
 885         if (ret == 0) {
 886                 debug_error(DEBUG, "load library error\n");
 887                 return FILEINFO_ERROR_FILE_INTERNAL;
 888         }
 889
 890 #ifdef CHECK_TIME
 891         debug_msg(DEBUG, "_load_dynamic_functions() = %lld\n", gettime() - ti);
 892 #endif
 893
 894 #endif
 895
 896         /*set source file infomation*/
 897         MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
 898
 899         ret = _is_file_exist(filename);
 900         if (ret != FILEINFO_ERROR_NONE) {
 901                 goto END;
 902         }
 903
 904         /*set attrs*/
 905         ret = mm_attrs_new(g_content_attrs, ARRAY_SIZE(g_content_attrs), "content", NULL, NULL, &attrs);
 906         if (ret) {
 907                 debug_error(DEBUG, "attribute internal error.\n");
 908                 ret = FILEINFO_ERROR_FILE_INTERNAL;
 909                 goto END;
 910         }
 911
 912
 913         parse.type = MM_FILE_PARSE_TYPE_ALL;
 914         ret = _get_contents_info(attrs, &src, &parse);
 915         if (ret != FILEINFO_ERROR_NONE) {
 916                 mm_attrs_free(attrs);
 917                 attrs = NULL;
 918                 debug_error(DEBUG, "failed to get contents: %s\n", filename);
 919         }
 920
 921         *contents_attrs = attrs;
 922
 923
 924 END:
 925 #ifdef __MMFILE_DYN_LOADING__
 926
 927 #ifdef CHECK_TIME
 928         ti = gettime();
 929 #endif
 930
 931         _unload_dynamic_functions(&func_handle);
 932
 933 #ifdef CHECK_TIME
 934         debug_msg(DEBUG, "_unload_dynamic_functions() = %lld\n", gettime() - ti);
 935 #endif
 936
 937 #endif
 938
 939         debug_fleave(RELEASE);
 940
 941         return ret;
 942 }
 943
 944
 945 EXPORT_API
 946 int mm_file_create_tag_attrs_from_memory(MMHandleType *tag_attrs, const void *data, unsigned int size, int format)
 947 {
 948         MMHandleType attrs = NULL;
 949         MMFileSourceType src;
 950         /*MMFILE_PARSE_INFO parse = {0, };*/
 951         int ret = 0;
 952
 953         debug_fenter(RELEASE);
 954
 955         /* Check argument here */
 956         if (tag_attrs == NULL || data == NULL) {
 957                 debug_error(DEBUG, "Invalid arguments\n");
 958                 return FILEINFO_ERROR_INVALID_ARGUMENT;
 959         }
 960
 961 #ifdef __MMFILE_DYN_LOADING__
 962         MMFILE_FUNC_HANDLE func_handle;
 963
 964         ret = _load_dynamic_functions(&func_handle);
 965         if (ret == 0) {
 966                 debug_error(DEBUG, "load library error\n");
 967                 return FILEINFO_ERROR_FILE_INTERNAL;
 968         }
 969 #endif
 970
 971         MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);
 972
 973         /*set attrs*/
 974         ret = mm_attrs_new(g_tag_attrs, ARRAY_SIZE(g_tag_attrs), "tag", NULL, NULL, &attrs);
 975         if (ret) {
 976                 debug_error(DEBUG, "attribute internal error.\n");
 977                 ret = FILEINFO_ERROR_FILE_INTERNAL;
 978                 goto END;
 979         }
 980
 981         /*parse.type = MM_FILE_PARSE_TYPE_ALL;*/
 982         ret = _get_tag_info(attrs, &src);
 983         if (ret != FILEINFO_ERROR_NONE) {
 984                 mm_attrs_free(attrs);
 985                 attrs = NULL;
 986                 debug_error(DEBUG, "failed to get tag");
 987         }
 988
 989         *tag_attrs = attrs;
 990
 991 END:
 992 #ifdef __MMFILE_DYN_LOADING__
 993         _unload_dynamic_functions(&func_handle);
 994 #endif
 995
 996         debug_fleave(RELEASE);
 997
 998         return ret;
 999 }
1000
1001
1002 EXPORT_API
1003 int mm_file_create_content_attrs_from_memory(MMHandleType *contents_attrs, const void *data, unsigned int size, int format)
1004 {
1005         MMHandleType attrs = NULL;
1006         MMFileSourceType src;
1007         MMFILE_PARSE_INFO parse = {0, };
1008         int ret = 0;
1009
1010         debug_fenter(RELEASE);
1011
1012         /* Check argument here */
1013         if (contents_attrs == NULL || data == NULL) {
1014                 debug_error(DEBUG, "Invalid arguments\n");
1015                 return FILEINFO_ERROR_INVALID_ARGUMENT;
1016         }
1017
1018 #ifdef __MMFILE_DYN_LOADING__
1019         MMFILE_FUNC_HANDLE func_handle;
1020
1021         ret = _load_dynamic_functions(&func_handle);
1022         if (ret == 0) {
1023                 debug_error(DEBUG, "load library error\n");
1024                 return FILEINFO_ERROR_FILE_INTERNAL;
1025         }
1026 #endif
1027
1028         MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);
1029
1030         /*set attrs*/
1031         ret = mm_attrs_new(g_content_attrs, ARRAY_SIZE(g_content_attrs), "content", NULL, NULL, &attrs);
1032         if (ret) {
1033                 debug_error(DEBUG, "attribute internal error.\n");
1034                 ret = FILEINFO_ERROR_FILE_INTERNAL;
1035                 goto END;
1036         }
1037
1038         parse.type = MM_FILE_PARSE_TYPE_ALL;
1039         ret = _get_contents_info(attrs, &src, &parse);
1040         if (ret != FILEINFO_ERROR_NONE) {
1041                 mm_attrs_free(attrs);
1042                 attrs = NULL;
1043                 debug_error(DEBUG, "failed to get contents");
1044         }
1045
1046         *contents_attrs = attrs;
1047
1048 END:
1049 #ifdef __MMFILE_DYN_LOADING__
1050         _unload_dynamic_functions(&func_handle);
1051 #endif
1052
1053         debug_fleave(RELEASE);
1054
1055         return ret;
1056 }
1057
1058
1059 EXPORT_API
1060 int mm_file_destroy_content_attrs(MMHandleType contents_attrs)
1061 {
1062         void *thumbnail = NULL;
1063         int ret = FILEINFO_ERROR_NONE;
1064
1065         debug_fenter(RELEASE);
1066
1067         if (contents_attrs == NULL) {
1068                 debug_error(DEBUG, "invalid handle.\n");
1069                 return FILEINFO_ERROR_INVALID_ARGUMENT;
1070         }
1071
1072         ret = mm_attrs_get_data_by_name(contents_attrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, &thumbnail);
1073         mmfile_free(thumbnail);
1074
1075         mm_attrs_free(contents_attrs);
1076
1077         debug_fleave(RELEASE);
1078
1079         return ret;
1080 }
1081
1082
1083 EXPORT_API
1084 int mm_file_get_stream_info(const char *filename, int *audio_stream_num, int *video_stream_num)
1085 {
1086         MMFileSourceType     src = {0, };
1087         MMFILE_PARSE_INFO    parse = {0, };
1088
1089         int ret = 0;
1090
1091         debug_fenter(RELEASE);
1092
1093         if (filename == NULL || strlen(filename) == 0 || audio_stream_num == NULL || video_stream_num == NULL) {
1094                 debug_error(DEBUG, "Invalid arguments\n");
1095                 return FILEINFO_ERROR_INVALID_ARGUMENT;
1096         }
1097
1098 #ifdef __MMFILE_DYN_LOADING__
1099         MMFILE_FUNC_HANDLE func_handle;
1100
1101         ret = _load_dynamic_functions(&func_handle);
1102         if (ret == 0) {
1103                 debug_error(DEBUG, "load library error\n");
1104                 return FILEINFO_ERROR_FILE_INTERNAL;
1105         }
1106 #endif
1107
1108         /*set source file infomation*/
1109         MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1110
1111         ret = _is_file_exist(filename);
1112         if (ret != FILEINFO_ERROR_NONE) {
1113                 goto END;
1114         }
1115
1116         parse.type = MM_FILE_PARSE_TYPE_SIMPLE;
1117         ret = _get_contents_info(NULL, &src, &parse);
1118         if (ret != FILEINFO_ERROR_NONE) {
1119                 debug_error(DEBUG, "failed to get stream info: %s\n", filename);
1120         } else {
1121                 if (parse.audio_track_num == 0 && parse.video_track_num == 0) {
1122                         debug_error(DEBUG, "empty header. retry to get stream info: %s\n", filename);
1123                         parse.type = MM_FILE_PARSE_TYPE_NORMAL;
1124                         ret = _get_contents_info(NULL, &src, &parse);
1125                 }
1126         }
1127
1128         /*set number of each stream*/
1129         *audio_stream_num = parse.audio_track_num;
1130         *video_stream_num = parse.video_track_num;
1131
1132 END:
1133 #ifdef __MMFILE_DYN_LOADING__
1134         _unload_dynamic_functions(&func_handle);
1135 #endif
1136
1137         debug_fleave(RELEASE);
1138
1139         return ret;
1140 }
1141
1142 EXPORT_API
1143 int mm_file_create_content_attrs_simple(MMHandleType *contents_attrs, const char *filename)
1144 {
1145         MMHandleType attrs = NULL;
1146         MMFileSourceType src = {0, };
1147         MMFILE_PARSE_INFO parse = {0, };
1148         int ret = 0;
1149
1150         debug_fenter(RELEASE);
1151
1152 #ifdef __MMFILE_DYN_LOADING__
1153         MMFILE_FUNC_HANDLE func_handle;
1154
1155         ret = _load_dynamic_functions(&func_handle);
1156         if (ret == 0) {
1157                 debug_error(DEBUG, "load library error\n");
1158                 return FILEINFO_ERROR_FILE_INTERNAL;
1159         }
1160 #endif
1161         if (filename == NULL) {
1162                 ret =  FILEINFO_ERROR_INVALID_ARGUMENT;
1163                 goto END;
1164         } else {
1165                 if (strlen(filename) == 0) {
1166                         ret =  FILEINFO_ERROR_INVALID_ARGUMENT;
1167                         goto END;
1168                 }
1169         }
1170
1171         /*set source file infomation*/
1172         MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1173
1174         ret = _is_file_exist(filename);
1175         if (ret != FILEINFO_ERROR_NONE) {
1176                 goto END;
1177         }
1178
1179         /*set attrs*/
1180         ret = mm_attrs_new(g_content_attrs, ARRAY_SIZE(g_content_attrs), "content", NULL, NULL, &attrs);
1181         if (ret) {
1182                 debug_error(DEBUG, "attribute internal error.\n");
1183                 ret = FILEINFO_ERROR_FILE_INTERNAL;
1184                 goto END;
1185         }
1186
1187         parse.type = MM_FILE_PARSE_TYPE_NORMAL;
1188         ret = _get_contents_info(attrs, &src, &parse);
1189         if (ret != FILEINFO_ERROR_NONE) {
1190                 mm_attrs_free(attrs);
1191                 attrs = NULL;
1192                 debug_error(DEBUG, "failed to get contents: %s\n", filename);
1193         }
1194
1195         *contents_attrs = attrs;
1196
1197 END:
1198 #ifdef __MMFILE_DYN_LOADING__
1199         _unload_dynamic_functions(&func_handle);
1200 #endif
1201
1202         debug_fleave(RELEASE);
1203
1204         return ret;
1205 }
1206
1207 EXPORT_API
1208 int mm_file_create_content_attrs_safe(MMHandleType *contents_attrs, const char *filename)
1209 {
1210         MMHandleType attrs = NULL;
1211         MMFileSourceType src = {0, };
1212         MMFILE_PARSE_INFO parse = {0, };
1213         int ret = 0;
1214
1215         debug_fenter(RELEASE);
1216
1217 #ifdef __MMFILE_DYN_LOADING__
1218         MMFILE_FUNC_HANDLE func_handle;
1219
1220         ret = _load_dynamic_functions(&func_handle);
1221         if (ret == 0) {
1222                 debug_error(DEBUG, "load library error\n");
1223                 return FILEINFO_ERROR_FILE_INTERNAL;
1224         }
1225 #endif
1226         if (filename == NULL) {
1227                 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1228                 goto END;
1229         } else {
1230                 if (strlen(filename) == 0) {
1231                         ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1232                         goto END;
1233                 }
1234         }
1235
1236         /*set source file infomation*/
1237         MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1238
1239         ret = _is_file_exist(filename);
1240         if (ret != FILEINFO_ERROR_NONE) {
1241                 goto END;
1242         }
1243
1244         /*set attrs*/
1245         ret = mm_attrs_new(g_content_attrs, ARRAY_SIZE(g_content_attrs), "content", NULL, NULL, &attrs);
1246         if (ret) {
1247                 debug_error(DEBUG, "attribute internal error.\n");
1248                 ret = FILEINFO_ERROR_FILE_INTERNAL;
1249                 goto END;
1250         }
1251
1252         parse.type = MM_FILE_PARSE_TYPE_SAFE;
1253         ret = _get_contents_info(attrs, &src, &parse);
1254         if (ret != FILEINFO_ERROR_NONE) {
1255                 mm_attrs_free(attrs);
1256                 attrs = NULL;
1257                 debug_error(DEBUG, "failed to get contents: %s\n", filename);
1258         }
1259
1260         *contents_attrs = attrs;
1261
1262 END:
1263 #ifdef __MMFILE_DYN_LOADING__
1264         _unload_dynamic_functions(&func_handle);
1265 #endif
1266
1267         debug_fleave(RELEASE);
1268
1269         return ret;
1270 }
1271
1272 EXPORT_API
1273 int mm_file_get_video_frame(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
1274 {
1275         int ret = 0;
1276         void *formatFuncHandle = NULL;
1277
1278         if (path == NULL) {
1279                 debug_error(DEBUG, "Invalid arguments [Path is Null]\n");
1280                 return FILEINFO_ERROR_INVALID_ARGUMENT;
1281         }
1282
1283 #ifdef __MMFILE_DYN_LOADING__
1284         /* Get from function argument */
1285         formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
1286         if (!formatFuncHandle) {
1287                 debug_error(DEBUG, "error : dlopen");
1288                 goto exception;
1289         }
1290
1291         mmfile_format_get_frame = dlsym(formatFuncHandle, "mmfile_format_get_frame");
1292         if (!mmfile_format_get_frame) {
1293                 debug_error(DEBUG, "error : load library");
1294                 goto exception;
1295         }
1296 #endif
1297
1298         debug_msg(RELEASE, "file path [%s] is_accurate [%d]", path, is_accurate);
1299
1300         ret = mmfile_format_get_frame(path, timestamp, is_accurate, frame, size, width, height);
1301         if (ret  == MMFILE_FORMAT_FAIL) {
1302                 debug_error(DEBUG, "error : get frame");
1303                 goto exception;
1304         }
1305
1306         if (formatFuncHandle) dlclose(formatFuncHandle);
1307
1308         return FILEINFO_ERROR_NONE;
1309
1310 exception:
1311         if (formatFuncHandle) dlclose(formatFuncHandle);
1312
1313         return FILEINFO_ERROR_FILE_INTERNAL;
1314 }
1315
1316 EXPORT_API
1317 int mm_file_get_video_frame_from_memory(const void *data, unsigned int datasize,  double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
1318 {
1319         int ret = 0;
1320         void *formatFuncHandle = NULL;
1321
1322         if (data == NULL) {
1323                 debug_error(DEBUG, "Invalid arguments [data is Null]\n");
1324                 return FILEINFO_ERROR_INVALID_ARGUMENT;
1325         }
1326
1327         if (datasize == 0) {
1328                 debug_error(DEBUG, "Invalid arguments [datasize is zero]\n");
1329                 return FILEINFO_ERROR_INVALID_ARGUMENT;
1330         }
1331
1332 #ifdef __MMFILE_DYN_LOADING__
1333         /* Get from function argument */
1334         formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
1335         if (!formatFuncHandle) {
1336                 debug_error(DEBUG, "error : dlopen");
1337                 goto exception;
1338         }
1339
1340         mmfile_format_get_frame_from_memory = dlsym(formatFuncHandle, "mmfile_format_get_frame_from_memory");
1341         if (!mmfile_format_get_frame_from_memory) {
1342                 debug_error(DEBUG, "error : load library");
1343                 goto exception;
1344         }
1345 #endif
1346
1347         debug_msg(RELEASE, "data [%p], data_size[%d], is_accurate [%d]", data, datasize, is_accurate);
1348
1349         ret = mmfile_format_get_frame_from_memory(data, datasize, timestamp, is_accurate, frame, size, width, height);
1350         if (ret  == MMFILE_FORMAT_FAIL) {
1351                 debug_error(DEBUG, "error : get frame");
1352                 goto exception;
1353         }
1354
1355         if (formatFuncHandle) dlclose(formatFuncHandle);
1356
1357         return FILEINFO_ERROR_NONE;
1358
1359 exception:
1360         if (formatFuncHandle) dlclose(formatFuncHandle);
1361
1362         return FILEINFO_ERROR_FILE_INTERNAL;
1363 }
1364
1365 EXPORT_API
1366 int mm_file_check_uhqa(const char *filename, bool *is_uhqa)
1367 {
1368         MMHandleType attrs = NULL;
1369         MMFileSourceType src = {0, };
1370         MMFILE_PARSE_INFO parse = {0, };
1371         int ret = 0;
1372
1373 #ifdef __MMFILE_DYN_LOADING__
1374         MMFILE_FUNC_HANDLE func_handle;
1375
1376         ret = _load_dynamic_functions(&func_handle);
1377         if (ret == 0) {
1378                 debug_error(DEBUG, "load library error\n");
1379                 return FILEINFO_ERROR_FILE_INTERNAL;
1380         }
1381 #endif
1382         if (filename == NULL) {
1383                 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1384                 goto END;
1385         } else {
1386                 if (strlen(filename) == 0) {
1387                         ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1388                         goto END;
1389                 }
1390         }
1391
1392         /*set source file infomation*/
1393         MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1394
1395         ret = _is_file_exist(filename);
1396         if (ret != FILEINFO_ERROR_NONE) {
1397                 goto END;
1398         }
1399
1400         /*set attrs*/
1401         ret = mm_attrs_new(g_content_attrs, ARRAY_SIZE(g_content_attrs), "content", NULL, NULL, &attrs);
1402         if (ret) {
1403                 debug_error(DEBUG, "attribute internal error.\n");
1404                 ret = FILEINFO_ERROR_FILE_INTERNAL;
1405                 goto END;
1406         }
1407
1408         parse.type = MM_FILE_PARSE_TYPE_NORMAL;
1409         ret = _get_contents_info(attrs, &src, &parse);
1410         if (ret == FILEINFO_ERROR_NONE) {
1411                 *is_uhqa = parse.is_uhqa;
1412         } else {
1413                 debug_error(DEBUG, "_get_contents_info failed\n");
1414                 *is_uhqa = FALSE;
1415         }
1416
1417         mm_attrs_free(attrs);
1418         attrs = NULL;
1419
1420 END:
1421 #ifdef __MMFILE_DYN_LOADING__
1422         _unload_dynamic_functions(&func_handle);
1423 #endif
1424
1425         debug_fleave(RELEASE);
1426
1427         return ret;
1428 }