formats/ffmpeg/mm_file_formats.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 <string.h>
  24 #include <stdlib.h>
  25
  26 #ifdef DRM_SUPPORT
  27 #include <drm_client.h>
  28 #endif
  29
  30
  31 #include "mm_file_debug.h"
  32 #include "mm_file_format_private.h"
  33 #include "mm_file_utils.h"
  34
  35 #define _MMF_FILE_FILEEXT_MAX 128
  36
  37 #define MMFILE_EXT_MP4          0x6D7034
  38 #define MMFILE_EXT_MPEG4        0x6D70656734
  39 #define MMFILE_EXT_M4A          0x6D3461
  40 #define MMFILE_EXT_MPG          0x6D7067
  41 #define MMFILE_EXT_MPG4         0x6D706734
  42 #define MMFILE_EXT_M4V          0x6D3476
  43 #define MMFILE_EXT_3GP          0x336770
  44 #define MMFILE_EXT_AMR          0x616D72
  45 #define MMFILE_EXT_AWB          0x617762
  46 #define MMFILE_EXT_WAV          0x776176
  47 #define MMFILE_EXT_MID          0x6D6964
  48 #define MMFILE_EXT_MIDI         0x6D696D69
  49 #define MMFILE_EXT_SPM          0x73706D
  50 #define MMFILE_EXT_MP3          0x6D7033
  51 #define MMFILE_EXT_AAC          0x616163
  52 #define MMFILE_EXT_XMF          0x786D66
  53 #define MMFILE_EXT_MXMF         0x6D786D66
  54 #define MMFILE_EXT_MMF          0x6D6D66
  55 #define MMFILE_EXT_MA2          0x6D6132
  56 #define MMFILE_EXT_IMY          0x696D79
  57 #define MMFILE_EXT_AVI          0x617669
  58 #define MMFILE_EXT_DIVX         0x64697678
  59 #define MMFILE_EXT_ASF          0x617366
  60 #define MMFILE_EXT_ASX          0x617378
  61 #define MMFILE_EXT_WMA          0x776D61
  62 #define MMFILE_EXT_WMV          0x776D76
  63 #define MMFILE_EXT_OGG          0x6F6767
  64 #define MMFILE_EXT_MKV          0x6D6B76
  65 #define MMFILE_EXT_MKA          0x6D6B61
  66 #define MMFILE_EXT_MOV          0x6D6F76
  67 #define MMFILE_EXT_FLAC         0x666C6163
  68 #define MMFILE_EXT_FLV          0x666C76
  69 #define MMFILE_EXT_AIF          0x616966
  70 #define MMFILE_EXT_AIFF         0x61696666
  71 #define MMFILE_EXT_RMVB         0x726D7662
  72 #define MMFILE_EXT_RM           0x726D
  73 #define MMFILE_EXT_M2TS         0x6D327473
  74 #define MMFILE_EXT_MTS          0x6D7473
  75 #define MMFILE_EXT_TS           0x7473
  76 #define MMFILE_EXT_TP           0x7470
  77 #define MMFILE_EXT_MPEG         0x6D706567
  78
  79 int (*MMFileOpenFunc[MM_FILE_FORMAT_NUM + 1])(MMFileFormatContext *fileContext) = {
  80         mmfile_format_open_ffmpg,       /* 3GP */
  81         mmfile_format_open_ffmpg,       /* ASF */
  82         mmfile_format_open_ffmpg,       /* AVI */
  83         mmfile_format_open_ffmpg,       /* MATROSAK */
  84         mmfile_format_open_ffmpg,       /* MP4 */
  85         mmfile_format_open_ffmpg,       /* OGG */
  86         NULL,                                           /* NUT */
  87         mmfile_format_open_ffmpg,       /* QT */
  88         mmfile_format_open_ffmpg,       /* REAL */
  89         mmfile_format_open_amr,         /* AMR */
  90         mmfile_format_open_aac,         /* AAC */
  91         mmfile_format_open_mp3,         /* MP3 */
  92         mmfile_format_open_ffmpg,       /* AIFF */
  93         NULL,                                           /* AU */
  94         mmfile_format_open_wav,         /* WAV */
  95         mmfile_format_open_mid,         /* MID */
  96         mmfile_format_open_mmf,         /* MMF */
  97         mmfile_format_open_ffmpg,       /* DIVX */
  98         mmfile_format_open_ffmpg,       /* FLV */
  99         NULL,                                           /* VOB */
 100         mmfile_format_open_imy,         /* IMY */
 101         mmfile_format_open_ffmpg,       /* WMA */
 102         mmfile_format_open_ffmpg,       /* WMV */
 103         NULL,                                           /* JPG */
 104         mmfile_format_open_ffmpg,       /* FLAC */
 105         mmfile_format_open_ffmpg,       /* MPEG-TS */
 106         mmfile_format_open_ffmpg,       /* MPEG-PS */
 107         mmfile_format_open_ffmpg,       /* MPEG 1 VIDEO*/
 108         mmfile_format_open_ffmpg,       /* MPEG 1 AUDIO */
 109         NULL,
 110 };
 111
 112 static int _CleanupFrameContext(MMFileFormatContext *formatContext, bool clean_all)
 113 {
 114         if (formatContext) {
 115
 116                 if (formatContext->ReadStream)  formatContext->ReadStream       = NULL;
 117                 if (formatContext->ReadFrame)           formatContext->ReadFrame        = NULL;
 118                 if (formatContext->ReadTag)             formatContext->ReadTag          = NULL;
 119                 if (formatContext->Close)                       formatContext->Close                    = NULL;
 120
 121                 if (formatContext->uriFileName)         mmfile_free(formatContext->uriFileName);
 122                 if (formatContext->title)                               mmfile_free(formatContext->title);
 123                 if (formatContext->artist)                              mmfile_free(formatContext->artist);
 124                 if (formatContext->author)                      mmfile_free(formatContext->author);
 125                 if (formatContext->composer)                    mmfile_free(formatContext->composer);
 126                 if (formatContext->album)                               mmfile_free(formatContext->album);
 127                 if (formatContext->album_artist)                mmfile_free(formatContext->album_artist);
 128                 if (formatContext->copyright)                   mmfile_free(formatContext->copyright);
 129                 if (formatContext->description)                 mmfile_free(formatContext->description);
 130                 if (formatContext->comment)                     mmfile_free(formatContext->comment);
 131                 if (formatContext->genre)                               mmfile_free(formatContext->genre);
 132                 if (formatContext->classification)              mmfile_free(formatContext->classification);
 133                 if (formatContext->year)                                mmfile_free(formatContext->year);
 134                 if (formatContext->recDate)                     mmfile_free(formatContext->recDate);
 135                 if (formatContext->tagTrackNum)                 mmfile_free(formatContext->tagTrackNum);
 136                 if (formatContext->rating)                              mmfile_free(formatContext->rating);
 137                 if (formatContext->artworkMime)         mmfile_free(formatContext->artworkMime);
 138                 if (formatContext->artwork)                     mmfile_free(formatContext->artwork);
 139                 if (formatContext->conductor)                   mmfile_free(formatContext->conductor);
 140                 if (formatContext->unsyncLyrics)                mmfile_free(formatContext->unsyncLyrics);
 141                 if (formatContext->rotate)                              mmfile_free(formatContext->rotate);
 142
 143                 if (clean_all)  /*syncLyrics has to be freed in mm_file_destroy_tag_attrs() except abnormal status */
 144                         if (formatContext->syncLyrics)                  mm_file_free_synclyrics_list(formatContext->syncLyrics);
 145
 146                 if (formatContext->privateFormatData)   mmfile_free(formatContext->privateFormatData);
 147                 if (formatContext->privateCodecData)    mmfile_free(formatContext->privateCodecData);
 148
 149                 if (formatContext->nbStreams > 0) {
 150                         int i = 0;
 151
 152                         /*formatContext->streams[0] is video, formatContext->streams[1] is audio.*/
 153                         if (formatContext->streams[0]) mmfile_free(formatContext->streams[0]);
 154                         if (formatContext->streams[1]) mmfile_free(formatContext->streams[1]);
 155
 156                         for (i = 2; (i < formatContext->nbStreams) && (i < MAXSTREAMS); i++) {
 157                                 if (formatContext->streams[i]) mmfile_free(formatContext->streams[i]);
 158                         }
 159                 }
 160
 161                 if (formatContext->thumbNail) {
 162                         if (formatContext->thumbNail->frameData)
 163                                 mmfile_free(formatContext->thumbNail->frameData);
 164
 165                         if (formatContext->thumbNail->configData)
 166                                 mmfile_free(formatContext->thumbNail->configData);
 167
 168                         mmfile_free(formatContext->thumbNail);
 169                 }
 170
 171                 formatContext->videoTotalTrackNum = 0;
 172                 formatContext->audioTotalTrackNum = 0;
 173                 formatContext->nbStreams = 0;
 174         }
 175
 176         return MMFILE_FORMAT_SUCCESS;
 177 }
 178
 179 static int
 180 _PreprocessFile(MMFileSourceType *fileSrc, char **urifilename, int *formatEnum, int *isdrm)
 181 {
 182         const char      *fileName = NULL;
 183         int                     filename_len = 0;
 184         int                     index = 0, skip_index = 0;
 185 #ifdef DRM_SUPPORT
 186         drm_content_info_s      contentInfo;
 187 #endif
 188         int ret = 0;
 189         MMFileIOHandle *fp = NULL;
 190
 191         if (fileSrc->type == MM_FILE_SRC_TYPE_FILE) {
 192                 unsigned long long file_extansion = 0;
 193
 194                 fileName = (const char *)(fileSrc->file.path);
 195                 filename_len = strlen(fileName);
 196
 197 #ifdef DRM_SUPPORT
 198                 /**
 199                  * Make URI name with file name
 200                  */
 201                 drm_bool_type_e res = DRM_TRUE;
 202                 drm_file_type_e file_type = DRM_TYPE_UNDEFINED;
 203                 int ret = 0;
 204
 205                 ret = drm_is_drm_file(fileSrc->file.path, &res);
 206                 if (ret == DRM_RETURN_SUCCESS && DRM_TRUE == res) {
 207                         ret = drm_get_file_type(fileSrc->file.path, &file_type);
 208                         if ((ret == DRM_RETURN_SUCCESS) && ((file_type == DRM_TYPE_OMA_V1) || (file_type == DRM_TYPE_OMA_V2))) {
 209                                 char extansion_name[_MMF_FILE_FILEEXT_MAX];
 210                                 int i = 0;
 211
 212                                 *isdrm = MM_FILE_DRM_OMA;
 213 #ifdef __MMFILE_TEST_MODE__
 214                                 debug_msg("OMA DRM detected.\n");
 215 #endif
 216
 217                                 memset(&contentInfo, 0x0, sizeof(drm_content_info_s));
 218
 219                                 if (DRM_RETURN_SUCCESS != drm_get_content_info(fileSrc->file.path, &contentInfo)) {
 220                                         debug_error("error: drm_get_content_info\n");
 221                                         goto FILE_FORMAT_FAIL;
 222                                 }
 223
 224                                 memset(extansion_name, 0x00, _MMF_FILE_FILEEXT_MAX);
 225                                 if (MMFILE_UTIL_SUCCESS != mmfile_util_get_file_ext(contentInfo.mime_type, extansion_name)) {
 226                                         debug_error("error: mmfile_util_get_ffmpeg_format\n");
 227                                         goto FILE_FORMAT_FAIL;
 228                                 }
 229
 230                                 file_extansion = 0;
 231
 232                                 for (i = 0; i < stlen(extansion_name); i++) {
 233                                         file_extansion |= (extansion_name[i] >= 'A' && extansion_name[i] <= 'Z' ? extansion_name[i] + 0x20 : extansion_name[i]) << i * 8;
 234                                 }
 235
 236                                 *urifilename = mmfile_malloc(MMFILE_DRM_URI_LEN + filename_len + 1);
 237                                 if (!*urifilename) {
 238                                         debug_error("error: mmfile_malloc uriname\n");
 239                                         goto FILE_FORMAT_FAIL;
 240                                 }
 241
 242                                 memset(*urifilename, 0x00, MMFILE_DRM_URI_LEN + filename_len + 1);
 243                                 strncpy(*urifilename, MMFILE_DRM_URI, MMFILE_DRM_URI_LEN);
 244                                 strncat(*urifilename, fileName, filename_len);
 245                                 (*urifilename)[MMFILE_DRM_URI_LEN + filename_len] = '\0';
 246                         } else if ((ret == DRM_RETURN_SUCCESS) &&
 247                                    ((file_type == DRM_TYPE_PLAYREADY) || (file_type == DRM_TYPE_PLAYREADY_ENVELOPE) || (file_type == DRM_TYPE_PIFF))) {
 248                                 *isdrm = MM_FILE_DRM_PROTECTED;
 249                         }
 250                 } else
 251 #endif /* DRM_SUPPORT                    */
 252                 {
 253                         int pos = filename_len;
 254                         *isdrm = MM_FILE_DRM_NONE;
 255 #ifdef __MMFILE_MMAP_MODE__
 256                         *urifilename = mmfile_malloc(MMFILE_MMAP_URI_LEN + filename_len + 1);
 257                         if (!*urifilename) {
 258                                 debug_error("error: mmfile_malloc uriname\n");
 259                                 goto FILE_FORMAT_FAIL;
 260                         }
 261
 262                         memset(*urifilename, 0x00, MMFILE_MMAP_URI_LEN + filename_len + 1);
 263                         strncpy(*urifilename, MMFILE_MMAP_URI, MMFILE_MMAP_URI_LEN);
 264                         strncat(*urifilename, fileName, filename_len);
 265                         (*urifilename)[MMFILE_MMAP_URI_LEN + filename_len] = '\0';
 266
 267 #else
 268                         *urifilename = mmfile_malloc(MMFILE_FILE_URI_LEN + filename_len + 1);
 269                         if (!*urifilename) {
 270                                 debug_error("error: mmfile_malloc uriname\n");
 271                                 goto FILE_FORMAT_FAIL;
 272                         }
 273
 274                         memset(*urifilename, 0x00, MMFILE_FILE_URI_LEN + filename_len + 1);
 275                         strncpy(*urifilename, MMFILE_FILE_URI, MMFILE_FILE_URI_LEN + 1);
 276                         strncat(*urifilename, fileName, filename_len);
 277                         (*urifilename)[MMFILE_FILE_URI_LEN + filename_len] = '\0';
 278 #endif
 279                         /**
 280                          * Get file extension from file's name
 281                          */
 282                         while (pos > 0) {
 283                                 pos--;
 284                                 if (fileName[pos] == '.')
 285                                         break;
 286                                 file_extansion |= (fileName[pos] >= 'A' && fileName[pos] <= 'Z' ? fileName[pos] + 0x20 : fileName[pos]) << (filename_len - pos - 1) * 8;
 287                         }
 288                 }
 289
 290                 ret = mmfile_open(&fp, *urifilename, MMFILE_RDONLY);
 291
 292                 if (ret == MMFILE_IO_FAILED) {
 293                         debug_error("error: mmfile_open\n");
 294                         goto FILE_FORMAT_FAIL;
 295                 }
 296
 297                 /*///////////////////////////////////////////////////////////////////// */
 298                 /*                 Check File format                                 // */
 299                 /*///////////////////////////////////////////////////////////////////// */
 300
 301 #ifdef __MMFILE_TEST_MODE__
 302                 /*debug_msg ("Get codec type of [%s].\n", extansion_name); */
 303 #endif
 304
 305                 switch (file_extansion) {
 306                         case MMFILE_EXT_MP4:
 307                         case MMFILE_EXT_MPEG4:
 308                         case MMFILE_EXT_M4A:
 309                         case MMFILE_EXT_MPG:
 310                         case MMFILE_EXT_MPG4:
 311                         case MMFILE_EXT_M4V:
 312                                 if (MMFileFormatIsValidMP4(fp, NULL)) {
 313                                         *formatEnum = MM_FILE_FORMAT_MP4;
 314                                         goto FILE_FORMAT_SUCCESS;
 315                                 }
 316                                 skip_index = MM_FILE_FORMAT_MP4;
 317                                 goto PROBE_PROPER_FILE_TYPE;
 318                                 break;
 319
 320                         case MMFILE_EXT_3GP:
 321                                 if (MMFileFormatIsValidMP4(fp, NULL)) {
 322                                         *formatEnum = MM_FILE_FORMAT_3GP;
 323                                         goto FILE_FORMAT_SUCCESS;
 324                                 }
 325                                 skip_index = MM_FILE_FORMAT_3GP;
 326                                 goto PROBE_PROPER_FILE_TYPE;
 327                                 break;
 328
 329                         case MMFILE_EXT_AMR:
 330                         case MMFILE_EXT_AWB:
 331                                 if (MMFileFormatIsValidAMR(fp, NULL)) {
 332                                         *formatEnum = MM_FILE_FORMAT_AMR;
 333                                         goto FILE_FORMAT_SUCCESS;
 334                                 }
 335                                 skip_index = MM_FILE_FORMAT_AMR;
 336                                 goto PROBE_PROPER_FILE_TYPE;
 337                                 break;
 338
 339                         case MMFILE_EXT_WAV:
 340                                 if (MMFileFormatIsValidWAV(fp, NULL)) {
 341                                         *formatEnum = MM_FILE_FORMAT_WAV;
 342                                         goto FILE_FORMAT_SUCCESS;
 343                                 }
 344                                 skip_index = MM_FILE_FORMAT_WAV;
 345                                 goto PROBE_PROPER_FILE_TYPE;
 346                                 break;
 347
 348                         case MMFILE_EXT_MID:
 349                         case MMFILE_EXT_MIDI:
 350                         case MMFILE_EXT_SPM:
 351                                 if (MMFileFormatIsValidMID(fp, NULL)) {
 352                                         *formatEnum = MM_FILE_FORMAT_MID;
 353                                         goto FILE_FORMAT_SUCCESS;
 354                                 }
 355                                 skip_index = MM_FILE_FORMAT_MID;
 356                                 goto PROBE_PROPER_FILE_TYPE;
 357                                 break;
 358
 359                         case MMFILE_EXT_MP3:
 360                                 if (MMFileFormatIsValidMP3(fp, NULL, 5)) {
 361                                         *formatEnum = MM_FILE_FORMAT_MP3;
 362                                         goto FILE_FORMAT_SUCCESS;
 363                                 }
 364                                 skip_index = MM_FILE_FORMAT_MP3;
 365                                 goto PROBE_PROPER_FILE_TYPE;
 366                                 break;
 367
 368                         case MMFILE_EXT_AAC:
 369                                 if (MMFileFormatIsValidAAC(fp, NULL)) {
 370                                         *formatEnum = MM_FILE_FORMAT_AAC;
 371                                         goto FILE_FORMAT_SUCCESS;
 372                                 }
 373                                 skip_index = MM_FILE_FORMAT_AAC;
 374                                 goto PROBE_PROPER_FILE_TYPE;
 375                                 break;
 376
 377                         case MMFILE_EXT_XMF:
 378                         case MMFILE_EXT_MXMF:
 379                                 if (MMFileFormatIsValidMID(fp, NULL)) {
 380                                         *formatEnum = MM_FILE_FORMAT_MID;
 381                                         goto FILE_FORMAT_SUCCESS;
 382                                 }
 383                                 skip_index = MM_FILE_FORMAT_MID;
 384                                 goto PROBE_PROPER_FILE_TYPE;
 385                                 break;
 386
 387                         case MMFILE_EXT_MMF:
 388                         case MMFILE_EXT_MA2:
 389                                 if (MMFileFormatIsValidMMF(fp, NULL)) {
 390                                         *formatEnum = MM_FILE_FORMAT_MMF;
 391                                         goto FILE_FORMAT_SUCCESS;
 392                                 }
 393                                 skip_index = MM_FILE_FORMAT_MMF;
 394                                 goto PROBE_PROPER_FILE_TYPE;
 395                                 break;
 396
 397                         case MMFILE_EXT_IMY:
 398                                 if (MMFileFormatIsValidIMY(fp, NULL)) {
 399                                         *formatEnum = MM_FILE_FORMAT_IMELODY;
 400                                         goto FILE_FORMAT_SUCCESS;
 401                                 }
 402                                 skip_index = MM_FILE_FORMAT_IMELODY;
 403                                 goto PROBE_PROPER_FILE_TYPE;
 404                                 break;
 405
 406                         case MMFILE_EXT_AVI:
 407                                 if (MMFileFormatIsValidAVI(fp, NULL)) {
 408                                         *formatEnum = MM_FILE_FORMAT_AVI;
 409                                         goto FILE_FORMAT_SUCCESS;
 410                                 }
 411                                 skip_index = MM_FILE_FORMAT_AVI;
 412                                 goto PROBE_PROPER_FILE_TYPE;
 413                                 break;
 414
 415                         case MMFILE_EXT_DIVX:
 416                                 if (MMFileFormatIsValidAVI(fp, NULL)) {
 417                                         *formatEnum = MM_FILE_FORMAT_DIVX;
 418                                         goto FILE_FORMAT_SUCCESS;
 419                                 }
 420                                 skip_index = MM_FILE_FORMAT_DIVX;
 421                                 goto PROBE_PROPER_FILE_TYPE;
 422                                 break;
 423
 424                         case MMFILE_EXT_ASF:
 425                         case MMFILE_EXT_ASX:
 426                                 if (MMFileFormatIsValidASF(fp, NULL)) {
 427                                         *formatEnum = MM_FILE_FORMAT_ASF;
 428                                         goto FILE_FORMAT_SUCCESS;
 429                                 }
 430                                 skip_index = MM_FILE_FORMAT_ASF;
 431                                 goto PROBE_PROPER_FILE_TYPE;
 432                                 break;
 433
 434                         case MMFILE_EXT_WMA:
 435                                 if (MMFileFormatIsValidWMA(fp, NULL)) {
 436                                         *formatEnum = MM_FILE_FORMAT_WMA;
 437                                         goto FILE_FORMAT_SUCCESS;
 438                                 }
 439                                 skip_index = MM_FILE_FORMAT_WMA;
 440                                 goto PROBE_PROPER_FILE_TYPE;
 441                                 break;
 442
 443                         case MMFILE_EXT_WMV:
 444                                 if (MMFileFormatIsValidWMV(fp, NULL)) {
 445                                         *formatEnum = MM_FILE_FORMAT_WMV;
 446                                         goto FILE_FORMAT_SUCCESS;
 447                                 }
 448                                 skip_index = MM_FILE_FORMAT_WMV;
 449                                 goto PROBE_PROPER_FILE_TYPE;
 450                                 break;
 451
 452                         case MMFILE_EXT_OGG:
 453                                 if (MMFileFormatIsValidOGG(fp, NULL)) {
 454                                         *formatEnum = MM_FILE_FORMAT_OGG;
 455                                         goto FILE_FORMAT_SUCCESS;
 456                                 }
 457                                 skip_index = MM_FILE_FORMAT_OGG;
 458                                 goto PROBE_PROPER_FILE_TYPE;
 459                                 break;
 460
 461                         case MMFILE_EXT_MKV:
 462                         case MMFILE_EXT_MKA:
 463                                 if (MMFileFormatIsValidMatroska(fp, NULL)) {
 464                                         *formatEnum = MM_FILE_FORMAT_MATROSKA;
 465                                         goto FILE_FORMAT_SUCCESS;
 466                                 }
 467                                 skip_index = MM_FILE_FORMAT_MATROSKA;
 468                                 goto PROBE_PROPER_FILE_TYPE;
 469                                 break;
 470
 471                         case MMFILE_EXT_MOV:
 472                                 if (MMFileFormatIsValidMP4(fp, NULL)) {
 473                                         *formatEnum = MM_FILE_FORMAT_QT;
 474                                         goto FILE_FORMAT_SUCCESS;
 475                                 }
 476                                 skip_index = MM_FILE_FORMAT_QT;
 477                                 goto PROBE_PROPER_FILE_TYPE;
 478                                 break;
 479
 480                         case MMFILE_EXT_FLAC:
 481                                 if (MMFileFormatIsValidFLAC(fp, NULL)) {
 482                                         *formatEnum = MM_FILE_FORMAT_FLAC;
 483                                         goto FILE_FORMAT_SUCCESS;
 484                                 }
 485                                 skip_index = MM_FILE_FORMAT_FLAC;
 486                                 goto PROBE_PROPER_FILE_TYPE;
 487                                 break;
 488
 489                         case MMFILE_EXT_FLV:
 490                                 if (MMFileFormatIsValidFLV(fp, NULL)) {
 491                                         *formatEnum = MM_FILE_FORMAT_FLV;
 492                                         goto FILE_FORMAT_SUCCESS;
 493                                 }
 494                                 skip_index = MM_FILE_FORMAT_FLV;
 495                                 goto PROBE_PROPER_FILE_TYPE;
 496                                 break;
 497
 498                         case MMFILE_EXT_RM:
 499                         case MMFILE_EXT_RMVB:
 500                                 if (MMFileFormatIsValidREAL(fp, NULL)) {
 501                                         *formatEnum = MM_FILE_FORMAT_REAL;
 502                                         goto FILE_FORMAT_SUCCESS;
 503                                 }
 504                                 skip_index = MM_FILE_FORMAT_REAL;
 505                                 goto PROBE_PROPER_FILE_TYPE;
 506                                 break;
 507
 508                         case MMFILE_EXT_M2TS:
 509                         case MMFILE_EXT_MTS:
 510                         case MMFILE_EXT_TP:
 511                         case MMFILE_EXT_TS:
 512                                 if (MMFileFormatIsValidMPEGTS(fp, NULL)) {
 513                                         *formatEnum = MM_FILE_FORMAT_M2TS;
 514                                         goto FILE_FORMAT_SUCCESS;
 515                                 }
 516                                 skip_index = MM_FILE_FORMAT_M2TS;
 517                                 goto PROBE_PROPER_FILE_TYPE;
 518                                 break;
 519
 520                         case MMFILE_EXT_MPEG:
 521                                 if (MMFileFormatIsValidMPEGPS(fp, NULL)) {
 522                                         *formatEnum = MM_FILE_FORMAT_M2PS;
 523                                         goto FILE_FORMAT_SUCCESS;
 524                                 } else if (MMFileFormatIsValidMPEGVIDEO(fp, NULL)) {
 525                                         *formatEnum = MM_FILE_FORMAT_M1VIDEO;
 526                                         goto FILE_FORMAT_SUCCESS;
 527                                 }
 528                                 skip_index = MM_FILE_FORMAT_M2PS;
 529                                 goto PROBE_PROPER_FILE_TYPE;
 530                                 break;
 531
 532                         case MMFILE_EXT_AIF:
 533                         case MMFILE_EXT_AIFF:
 534                                 *formatEnum = MM_FILE_FORMAT_AIFF;
 535                                 goto FILE_FORMAT_SUCCESS;
 536                                 break;
 537
 538                         default:
 539                                 debug_warning("probe file type=%s\n", fileName);
 540                                 skip_index = -1;
 541                                 goto PROBE_PROPER_FILE_TYPE;
 542                                 break;
 543                 }
 544         } else if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) {
 545                 char tempURIBuffer[MMFILE_URI_MAX_LEN] = {0, };
 546
 547                 sprintf(tempURIBuffer, "%s%u:%u", MMFILE_MEM_URI, (unsigned int)fileSrc->memory.ptr, fileSrc->memory.size);
 548                 *urifilename = mmfile_strdup(tempURIBuffer);
 549                 if (!*urifilename) {
 550                         debug_error("error: uri is NULL\n");
 551                         goto FILE_FORMAT_FAIL;
 552                 }
 553
 554                 ret = mmfile_open(&fp, *urifilename, MMFILE_RDONLY);
 555
 556                 if (ret == MMFILE_IO_FAILED) {
 557                         debug_error("error: mmfile_open\n");
 558                         goto FILE_FORMAT_FAIL;
 559                 }
 560
 561 #ifdef __MMFILE_TEST_MODE__
 562                 debug_msg("uri: %s\n", *urifilename);
 563 #endif
 564
 565                 switch (fileSrc->memory.format) {
 566                         case MM_FILE_FORMAT_3GP: {
 567                                 if (MMFileFormatIsValidMP4(fp, NULL)) {
 568                                         *formatEnum = MM_FILE_FORMAT_3GP;
 569                                         goto FILE_FORMAT_SUCCESS;
 570                                 }
 571                                 skip_index = MM_FILE_FORMAT_3GP;
 572                                 goto PROBE_PROPER_FILE_TYPE;
 573                                 break;
 574                         }
 575
 576                         case MM_FILE_FORMAT_MP4: {
 577                                 if (MMFileFormatIsValidMP4(fp, NULL)) {
 578                                         *formatEnum = MM_FILE_FORMAT_MP4;
 579                                         goto FILE_FORMAT_SUCCESS;
 580                                 }
 581                                 skip_index = MM_FILE_FORMAT_MP4;
 582                                 goto PROBE_PROPER_FILE_TYPE;
 583                                 break;
 584                         }
 585
 586                         case MM_FILE_FORMAT_AMR: {
 587                                 if (MMFileFormatIsValidAMR(fp, NULL)) {
 588                                         *formatEnum = MM_FILE_FORMAT_AMR;
 589                                         goto FILE_FORMAT_SUCCESS;
 590                                 }
 591                                 skip_index = MM_FILE_FORMAT_AMR;
 592                                 goto PROBE_PROPER_FILE_TYPE;
 593                                 break;
 594                         }
 595
 596                         case MM_FILE_FORMAT_WAV: {
 597                                 if (MMFileFormatIsValidWAV(fp, NULL)) {
 598                                         *formatEnum = MM_FILE_FORMAT_WAV;
 599                                         goto FILE_FORMAT_SUCCESS;
 600                                 }
 601                                 skip_index = MM_FILE_FORMAT_WAV;
 602                                 goto PROBE_PROPER_FILE_TYPE;
 603                                 break;
 604                         }
 605
 606                         case MM_FILE_FORMAT_MID: {
 607                                 if (MMFileFormatIsValidMID(fp, NULL)) {
 608                                         *formatEnum = MM_FILE_FORMAT_MID;
 609                                         goto FILE_FORMAT_SUCCESS;
 610                                 }
 611                                 skip_index = MM_FILE_FORMAT_MID;
 612                                 goto PROBE_PROPER_FILE_TYPE;
 613                                 break;
 614                         }
 615
 616                         case MM_FILE_FORMAT_MP3: {
 617                                 if (MMFileFormatIsValidMP3(fp, NULL, 5)) {
 618                                         *formatEnum = MM_FILE_FORMAT_MP3;
 619                                         goto FILE_FORMAT_SUCCESS;
 620                                 }
 621                                 skip_index = MM_FILE_FORMAT_MP3;
 622                                 goto PROBE_PROPER_FILE_TYPE;
 623                                 break;
 624                         }
 625
 626                         case MM_FILE_FORMAT_AAC: {
 627                                 if (MMFileFormatIsValidAAC(fp, NULL)) {
 628                                         *formatEnum = MM_FILE_FORMAT_AAC;
 629                                         goto FILE_FORMAT_SUCCESS;
 630                                 }
 631                                 skip_index = MM_FILE_FORMAT_AAC;
 632                                 goto PROBE_PROPER_FILE_TYPE;
 633                                 break;
 634                         }
 635
 636                         case MM_FILE_FORMAT_MMF: {
 637                                 if (MMFileFormatIsValidMMF(fp, NULL)) {
 638                                         *formatEnum = MM_FILE_FORMAT_MMF;
 639                                         goto FILE_FORMAT_SUCCESS;
 640                                 }
 641                                 skip_index = MM_FILE_FORMAT_MMF;
 642                                 goto PROBE_PROPER_FILE_TYPE;
 643                                 break;
 644                         }
 645
 646                         case MM_FILE_FORMAT_IMELODY: {
 647                                 if (MMFileFormatIsValidIMY(fp, NULL)) {
 648                                         *formatEnum = MM_FILE_FORMAT_IMELODY;
 649                                         goto FILE_FORMAT_SUCCESS;
 650                                 }
 651                                 skip_index = MM_FILE_FORMAT_IMELODY;
 652                                 goto PROBE_PROPER_FILE_TYPE;
 653                                 break;
 654                         }
 655
 656                         case MM_FILE_FORMAT_AVI: {
 657                                 if (MMFileFormatIsValidAVI(fp, NULL)) {
 658                                         *formatEnum = MM_FILE_FORMAT_AVI;
 659                                         goto FILE_FORMAT_SUCCESS;
 660                                 }
 661                                 skip_index = MM_FILE_FORMAT_AVI;
 662                                 goto PROBE_PROPER_FILE_TYPE;
 663                                 break;
 664                         }
 665
 666                         case MM_FILE_FORMAT_DIVX: {
 667                                 if (MMFileFormatIsValidAVI(fp, NULL)) {
 668                                         *formatEnum = MM_FILE_FORMAT_DIVX;
 669                                         goto FILE_FORMAT_SUCCESS;
 670                                 }
 671                                 skip_index = MM_FILE_FORMAT_DIVX;
 672                                 goto PROBE_PROPER_FILE_TYPE;
 673                                 break;
 674                         }
 675
 676                         case MM_FILE_FORMAT_ASF: {
 677                                 if (MMFileFormatIsValidASF(fp, NULL)) {
 678                                         *formatEnum = MM_FILE_FORMAT_ASF;
 679                                         goto FILE_FORMAT_SUCCESS;
 680                                 }
 681                                 skip_index = MM_FILE_FORMAT_ASF;
 682                                 goto PROBE_PROPER_FILE_TYPE;
 683                                 break;
 684                         }
 685
 686                         case MM_FILE_FORMAT_WMA: {
 687                                 if (MMFileFormatIsValidWMA(fp, NULL)) {
 688                                         *formatEnum = MM_FILE_FORMAT_WMA;
 689                                         goto FILE_FORMAT_SUCCESS;
 690                                 }
 691                                 skip_index = MM_FILE_FORMAT_WMA;
 692                                 goto PROBE_PROPER_FILE_TYPE;
 693                                 break;
 694                         }
 695
 696                         case MM_FILE_FORMAT_WMV: {
 697                                 if (MMFileFormatIsValidWMV(fp, NULL)) {
 698                                         *formatEnum = MM_FILE_FORMAT_WMV;
 699                                         goto FILE_FORMAT_SUCCESS;
 700                                 }
 701                                 skip_index = MM_FILE_FORMAT_WMV;
 702                                 goto PROBE_PROPER_FILE_TYPE;
 703                                 break;
 704                         }
 705
 706                         case MM_FILE_FORMAT_OGG: {
 707                                 if (MMFileFormatIsValidOGG(fp, NULL)) {
 708                                         *formatEnum = MM_FILE_FORMAT_OGG;
 709                                         goto FILE_FORMAT_SUCCESS;
 710                                 }
 711                                 skip_index = MM_FILE_FORMAT_OGG;
 712                                 goto PROBE_PROPER_FILE_TYPE;
 713                         }
 714
 715                         case MM_FILE_FORMAT_MATROSKA: {
 716                                 if (MMFileFormatIsValidMatroska(fp, NULL)) {
 717                                         *formatEnum = MM_FILE_FORMAT_MATROSKA;
 718                                         goto FILE_FORMAT_SUCCESS;
 719                                 }
 720                                 skip_index = MM_FILE_FORMAT_MATROSKA;
 721                                 goto PROBE_PROPER_FILE_TYPE;
 722                         }
 723
 724                         case MM_FILE_FORMAT_QT: {
 725                                 if (MMFileFormatIsValidMP4(fp, NULL)) {
 726                                         *formatEnum = MM_FILE_FORMAT_QT;
 727                                         goto FILE_FORMAT_SUCCESS;
 728                                 }
 729                                 skip_index = MM_FILE_FORMAT_QT;
 730                                 goto PROBE_PROPER_FILE_TYPE;
 731                         }
 732
 733                         case MM_FILE_FORMAT_FLAC: {
 734                                 if (MMFileFormatIsValidFLAC(fp, NULL)) {
 735                                         *formatEnum = MM_FILE_FORMAT_FLAC;
 736                                         goto FILE_FORMAT_SUCCESS;
 737                                 }
 738                                 skip_index = MM_FILE_FORMAT_FLAC;
 739                                 goto PROBE_PROPER_FILE_TYPE;
 740                         }
 741
 742                         case MM_FILE_FORMAT_FLV: {
 743                                 if (MMFileFormatIsValidFLV(fp, NULL)) {
 744                                         *formatEnum = MM_FILE_FORMAT_FLV;
 745                                         goto FILE_FORMAT_SUCCESS;
 746                                 }
 747                                 skip_index = MM_FILE_FORMAT_FLV;
 748                                 goto PROBE_PROPER_FILE_TYPE;
 749                         }
 750
 751                         case MM_FILE_FORMAT_REAL: {
 752                                 if (MMFileFormatIsValidREAL(fp, NULL)) {
 753                                         *formatEnum = MM_FILE_FORMAT_REAL;
 754                                         goto FILE_FORMAT_SUCCESS;
 755                                 }
 756                                 skip_index = MM_FILE_FORMAT_REAL;
 757                                 goto PROBE_PROPER_FILE_TYPE;
 758                         }
 759
 760                         case MM_FILE_FORMAT_M2TS: {
 761                                 if (MMFileFormatIsValidMPEGTS(fp, NULL)) {
 762                                         *formatEnum = MM_FILE_FORMAT_M2TS;
 763                                         goto FILE_FORMAT_SUCCESS;
 764                                 }
 765                                 skip_index = MM_FILE_FORMAT_M2TS;
 766                                 goto PROBE_PROPER_FILE_TYPE;
 767                         }
 768
 769                         case MM_FILE_FORMAT_M2PS: {
 770                                 if (MMFileFormatIsValidMPEGPS(fp, NULL)) {
 771                                         *formatEnum = MM_FILE_FORMAT_M2PS;
 772                                         goto FILE_FORMAT_SUCCESS;
 773                                 }
 774                                 skip_index = MM_FILE_FORMAT_M2PS;
 775                                 goto PROBE_PROPER_FILE_TYPE;
 776                         }
 777
 778                         case MM_FILE_FORMAT_M1AUDIO: {
 779                                 if (MMFileFormatIsValidMPEGAUDIO(fp, NULL)) {
 780                                         *formatEnum = MM_FILE_FORMAT_M1AUDIO;
 781                                         goto FILE_FORMAT_SUCCESS;
 782                                 }
 783                                 skip_index = MM_FILE_FORMAT_M1AUDIO;
 784                                 goto PROBE_PROPER_FILE_TYPE;
 785                         }
 786
 787                         case MM_FILE_FORMAT_M1VIDEO: {
 788                                 if (MMFileFormatIsValidMPEGVIDEO(fp, NULL)) {
 789                                         *formatEnum = MM_FILE_FORMAT_M1VIDEO;
 790                                         goto FILE_FORMAT_SUCCESS;
 791                                 }
 792                                 skip_index = MM_FILE_FORMAT_M1VIDEO;
 793                                 goto PROBE_PROPER_FILE_TYPE;
 794                         }
 795
 796                         default: {
 797                                 debug_warning("probe fileformat type=%d (%d: autoscan)\n", fileSrc->memory.format, MM_FILE_FORMAT_INVALID);
 798                                 skip_index = -1;
 799                                 goto PROBE_PROPER_FILE_TYPE;
 800                                 break;
 801                         }
 802                 }
 803         } else {
 804                 debug_error("error: invaild input type[memory|file]\n");
 805                 goto FILE_FORMAT_FAIL;
 806         }
 807
 808 PROBE_PROPER_FILE_TYPE:
 809         for (index = 0; index < MM_FILE_FORMAT_NUM; index++) {
 810                 if (index == skip_index)
 811                         continue;
 812
 813 #ifdef __MMFILE_TEST_MODE__
 814                 debug_msg("search index = [%d]\n", index);
 815 #endif
 816
 817                 switch (index) {
 818                         case MM_FILE_FORMAT_QT:
 819                         case MM_FILE_FORMAT_3GP:
 820                         case MM_FILE_FORMAT_MP4: {
 821                                 if (skip_index == MM_FILE_FORMAT_QT || skip_index == MM_FILE_FORMAT_3GP || skip_index == MM_FILE_FORMAT_MP4)
 822                                         goto FILE_FORMAT_FAIL;
 823
 824                                 if (MMFileFormatIsValidMP4(fp, NULL)) {
 825                                         *formatEnum = MM_FILE_FORMAT_3GP;
 826                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_3GP;
 827                                         goto FILE_FORMAT_SUCCESS;
 828                                 }
 829                                 break;
 830                         }
 831
 832                         case MM_FILE_FORMAT_ASF:
 833                         case MM_FILE_FORMAT_WMA:
 834                         case MM_FILE_FORMAT_WMV: {
 835                                 if (skip_index == MM_FILE_FORMAT_ASF || skip_index == MM_FILE_FORMAT_WMA || skip_index == MM_FILE_FORMAT_WMV)
 836                                         goto FILE_FORMAT_FAIL;
 837
 838                                 if (MMFileFormatIsValidASF(fp, NULL)) {
 839                                         *formatEnum = MM_FILE_FORMAT_ASF;
 840                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_ASF;
 841                                         goto FILE_FORMAT_SUCCESS;
 842                                 }
 843                                 break;
 844                         }
 845
 846                         case MM_FILE_FORMAT_DIVX:
 847                         case MM_FILE_FORMAT_AVI: {
 848                                 if (skip_index == MM_FILE_FORMAT_DIVX || skip_index == MM_FILE_FORMAT_AVI)
 849                                         goto FILE_FORMAT_FAIL;
 850
 851                                 if (MMFileFormatIsValidAVI(fp, NULL)) {
 852                                         *formatEnum = MM_FILE_FORMAT_AVI;
 853                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_AVI;
 854                                         goto FILE_FORMAT_SUCCESS;
 855                                 }
 856                                 break;
 857                         }
 858
 859                         case MM_FILE_FORMAT_OGG: {
 860                                 if (MMFileFormatIsValidOGG(fp, NULL)) {
 861                                         *formatEnum = MM_FILE_FORMAT_OGG;
 862                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_OGG;
 863                                         goto FILE_FORMAT_SUCCESS;
 864                                 }
 865                                 break;
 866                         }
 867
 868                         case MM_FILE_FORMAT_AMR: {
 869                                 if (MMFileFormatIsValidAMR(fp, NULL)) {
 870                                         *formatEnum = MM_FILE_FORMAT_AMR;
 871                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_AMR;
 872                                         goto FILE_FORMAT_SUCCESS;
 873                                 }
 874                                 break;
 875                         }
 876
 877                         case MM_FILE_FORMAT_AAC: {
 878                                 if (MMFileFormatIsValidAAC(fp, NULL)) {
 879                                         *formatEnum = MM_FILE_FORMAT_AAC;
 880                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_AAC;
 881                                         goto FILE_FORMAT_SUCCESS;
 882                                 }
 883                                 break;
 884                         }
 885
 886                         case MM_FILE_FORMAT_MP3: {
 887                                 if (MMFileFormatIsValidMP3(fp, NULL, 50)) {
 888                                         *formatEnum = MM_FILE_FORMAT_MP3;
 889                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_MP3;
 890                                         goto FILE_FORMAT_SUCCESS;
 891                                 }
 892                                 break;
 893                         }
 894
 895                         case MM_FILE_FORMAT_WAV: {
 896                                 if (MMFileFormatIsValidWAV(fp, NULL)) {
 897                                         *formatEnum = MM_FILE_FORMAT_WAV;
 898                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_WAV;
 899                                         goto FILE_FORMAT_SUCCESS;
 900                                 }
 901                                 break;
 902                         }
 903
 904                         case MM_FILE_FORMAT_MID: {
 905                                 if (MMFileFormatIsValidMID(fp, NULL)) {
 906                                         *formatEnum = MM_FILE_FORMAT_MID;
 907                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_MID;
 908                                         goto FILE_FORMAT_SUCCESS;
 909                                 }
 910                                 break;
 911                         }
 912
 913                         case MM_FILE_FORMAT_MMF: {
 914                                 if (MMFileFormatIsValidMMF(fp, NULL)) {
 915                                         *formatEnum = MM_FILE_FORMAT_MMF;
 916                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_MMF;
 917                                         goto FILE_FORMAT_SUCCESS;
 918                                 }
 919                                 break;
 920                         }
 921
 922                         case MM_FILE_FORMAT_IMELODY: {
 923                                 if (MMFileFormatIsValidIMY(fp, NULL)) {
 924                                         *formatEnum = MM_FILE_FORMAT_IMELODY;
 925                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_IMELODY;
 926                                         goto FILE_FORMAT_SUCCESS;
 927                                 }
 928                                 break;
 929                         }
 930
 931                         case MM_FILE_FORMAT_MATROSKA: {
 932                                 if (MMFileFormatIsValidMatroska(fp, NULL)) {
 933                                         *formatEnum = MM_FILE_FORMAT_MATROSKA;
 934                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_MATROSKA;
 935                                         goto FILE_FORMAT_SUCCESS;
 936                                 }
 937                                 break;
 938                         }
 939
 940                         case MM_FILE_FORMAT_FLAC: {
 941                                 if (MMFileFormatIsValidFLAC(fp, NULL)) {
 942                                         *formatEnum = MM_FILE_FORMAT_FLAC;
 943                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_FLAC;
 944                                         goto FILE_FORMAT_SUCCESS;
 945                                 }
 946                                 break;
 947                         }
 948
 949                         case MM_FILE_FORMAT_FLV: {
 950                                 if (MMFileFormatIsValidFLV(fp, NULL)) {
 951                                         *formatEnum = MM_FILE_FORMAT_FLV;
 952                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_FLV;
 953                                         goto FILE_FORMAT_SUCCESS;
 954                                 }
 955                                 break;
 956                         }
 957
 958                         case MM_FILE_FORMAT_REAL: {
 959                                 if (MMFileFormatIsValidREAL(fp, NULL)) {
 960                                         *formatEnum = MM_FILE_FORMAT_REAL;
 961                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_REAL;
 962                                         goto FILE_FORMAT_SUCCESS;
 963                                 }
 964                                 break;
 965                         }
 966
 967                         case MM_FILE_FORMAT_M2TS: {
 968                                 if (MMFileFormatIsValidMPEGTS(fp, NULL)) {
 969                                         *formatEnum = MM_FILE_FORMAT_M2TS;
 970                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_M2TS;
 971                                         goto FILE_FORMAT_SUCCESS;
 972                                 }
 973                                 break;
 974                         }
 975
 976                         case MM_FILE_FORMAT_M2PS: {
 977                                 if (MMFileFormatIsValidMPEGPS(fp, NULL)) {
 978                                         *formatEnum = MM_FILE_FORMAT_M2PS;
 979                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_M2PS;
 980                                         goto FILE_FORMAT_SUCCESS;
 981                                 }
 982                                 break;
 983                         }
 984
 985                         case MM_FILE_FORMAT_M1AUDIO: {
 986                                 if (MMFileFormatIsValidMPEGAUDIO(fp, NULL)) {
 987                                         *formatEnum = MM_FILE_FORMAT_M1AUDIO;
 988                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_M1AUDIO;
 989                                         goto FILE_FORMAT_SUCCESS;
 990                                 }
 991                                 break;
 992                         }
 993
 994                         case MM_FILE_FORMAT_M1VIDEO: {
 995                                 if (MMFileFormatIsValidMPEGVIDEO(fp, NULL)) {
 996                                         *formatEnum = MM_FILE_FORMAT_M1VIDEO;
 997                                         if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) fileSrc->memory.format = MM_FILE_FORMAT_M1VIDEO;
 998                                         goto FILE_FORMAT_SUCCESS;
 999                                 }
1000                                 break;
1001                         }
1002
1003                         /* not supported file */
1004                         case MM_FILE_FORMAT_NUT:
1005                         case MM_FILE_FORMAT_AIFF:
1006                         case MM_FILE_FORMAT_AU:
1007                         case MM_FILE_FORMAT_VOB:
1008                         case MM_FILE_FORMAT_JPG:
1009                         default: {
1010                                 debug_error("error: invaild format enum[%d]\n", index);
1011                                 goto FILE_FORMAT_FAIL;
1012                                 break;
1013                         }
1014                 }
1015         }
1016
1017 FILE_FORMAT_FAIL:
1018         if (index == MM_FILE_FORMAT_NUM)
1019                 debug_error("Can't probe file type\n");
1020
1021         *formatEnum = -1;
1022
1023         if (fp)
1024                 mmfile_close(fp);
1025
1026         return MMFILE_FORMAT_FAIL;
1027
1028
1029 FILE_FORMAT_SUCCESS:
1030         if (fp)
1031                 mmfile_close(fp);
1032
1033         return MMFILE_FORMAT_SUCCESS;
1034 }
1035
1036 static int _mmfile_format_close(MMFileFormatContext *formatContext, bool clean_all)
1037 {
1038         if (NULL == formatContext) {
1039                 debug_error("error: invalid params\n");
1040                 return MMFILE_FORMAT_FAIL;
1041         }
1042
1043         if (formatContext->Close) {
1044                 formatContext->Close(formatContext);
1045                 formatContext->Close = NULL;
1046         }
1047
1048         _CleanupFrameContext(formatContext, clean_all);
1049
1050         if (formatContext)
1051                 mmfile_free(formatContext);
1052
1053         return MMFILE_FORMAT_SUCCESS;
1054 }
1055
1056
1057 EXPORT_API
1058 int mmfile_format_open(MMFileFormatContext **formatContext, MMFileSourceType *fileSrc)
1059 {
1060         int index = 0;
1061         int ret = 0;
1062         MMFileFormatContext *formatObject = NULL;
1063
1064         if (NULL == fileSrc) {
1065                 debug_error("error: invalid params\n");
1066                 return MMFILE_FORMAT_FAIL;
1067         }
1068
1069         /* create formatContext object */
1070         formatObject = mmfile_malloc(sizeof(MMFileFormatContext));
1071         if (NULL == formatObject) {
1072                 debug_error("error: mmfile_malloc fail for formatObject\n");
1073                 *formatContext = NULL;
1074                 return MMFILE_FORMAT_FAIL;
1075         }
1076
1077         memset(formatObject, 0x00, sizeof(MMFileFormatContext));
1078
1079         mmfile_register_io_all();
1080
1081         /* parsing file extension */
1082         formatObject->filesrc = fileSrc;
1083
1084         formatObject->pre_checked = 0;  /*not yet format checked.*/
1085
1086         /**
1087          * Format detect and validation check.
1088          */
1089         ret = _PreprocessFile(fileSrc, &formatObject->uriFileName,  &formatObject->formatType, &formatObject->isdrm);
1090         if (MMFILE_FORMAT_SUCCESS != ret) {
1091                 debug_error("error: _PreprocessFile fail\n");
1092                 ret = MMFILE_FORMAT_FAIL;
1093                 goto exception;
1094         }
1095
1096         formatObject->pre_checked = 1;  /*already file format checked.*/
1097
1098         /**
1099          * Open format function.
1100          */
1101         if (NULL == MMFileOpenFunc[formatObject->formatType]) {
1102                 debug_error("error: Not implemented \n");
1103                 ret = MMFILE_FORMAT_FAIL;
1104                 goto find_valid_handler;
1105         }
1106
1107         ret = MMFileOpenFunc[formatObject->formatType](formatObject);
1108         if (MMFILE_FORMAT_FAIL == ret) {
1109                 debug_error("error: Try other formats\n");
1110                 ret = MMFILE_FORMAT_FAIL;
1111 /*              goto find_valid_handler; */
1112                 goto exception;
1113         }
1114
1115         *formatContext = formatObject;
1116         return MMFILE_FORMAT_SUCCESS;
1117
1118 find_valid_handler:
1119         formatObject->pre_checked = 0;  /*do check file format*/
1120
1121         for (index = 0; index < MM_FILE_FORMAT_NUM + 1; index++) {
1122                 if (NULL == MMFileOpenFunc[index]) {
1123                         debug_error("error: Not implemented \n");
1124                         ret = MMFILE_FORMAT_FAIL;
1125                         continue;
1126                 }
1127
1128                 if (formatObject->formatType == index)
1129                         continue;
1130
1131                 ret = MMFileOpenFunc[index](formatObject);
1132                 if (MMFILE_FORMAT_FAIL == ret) {
1133 /*                      _CleanupFrameContext(formatObject, true); */
1134                         continue;
1135                 }
1136
1137                 break;
1138         }
1139
1140         formatObject->formatType = index;
1141
1142         if (index == MM_FILE_FORMAT_NUM + 1 && MMFILE_FORMAT_FAIL == ret) {
1143                 debug_error("can't find file format handler\n");
1144                 _CleanupFrameContext(formatObject, true);
1145                 ret = MMFILE_FORMAT_FAIL;
1146                 goto exception;
1147         }
1148
1149         formatObject->formatType = index;
1150         *formatContext = formatObject;
1151
1152         return MMFILE_FORMAT_SUCCESS;
1153
1154 exception:
1155         _mmfile_format_close(formatObject, true);
1156         *formatContext = NULL;
1157
1158         return ret;
1159 }
1160
1161 EXPORT_API
1162 int mmfile_format_read_stream(MMFileFormatContext *formatContext)
1163 {
1164         if (NULL == formatContext || NULL == formatContext->ReadStream) {
1165                 debug_error("error: invalid params\n");
1166                 return MMFILE_FORMAT_FAIL;
1167         }
1168
1169         return formatContext->ReadStream(formatContext);
1170 }
1171
1172 EXPORT_API
1173 int mmfile_format_read_frame(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
1174 {
1175         if (NULL == formatContext || NULL == frame || NULL == formatContext->ReadFrame) {
1176                 debug_error("error: invalid params\n");
1177                 return MMFILE_FORMAT_FAIL;
1178         }
1179
1180         return formatContext->ReadFrame(formatContext, timestamp, frame);
1181 }
1182
1183 EXPORT_API
1184 int mmfile_format_read_tag(MMFileFormatContext *formatContext)
1185 {
1186         if (NULL == formatContext || NULL == formatContext->ReadTag) {
1187                 debug_error("error: invalid params\n");
1188                 return MMFILE_FORMAT_FAIL;
1189         }
1190
1191         return formatContext->ReadTag(formatContext);
1192 }
1193
1194
1195 EXPORT_API
1196 int mmfile_format_close(MMFileFormatContext *formatContext)
1197 {
1198         return _mmfile_format_close(formatContext, false);
1199 }