4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Haejeong Kim <backto.kim@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
27 #include <drm_client.h>
31 #include "mm_file_debug.h"
32 #include "mm_file_format_private.h"
33 #include "mm_file_utils.h"
35 #define _MMF_FILE_FILEEXT_MAX 128
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
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 */
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 */
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 */
100 mmfile_format_open_imy, /* IMY */
101 mmfile_format_open_ffmpg, /* WMA */
102 mmfile_format_open_ffmpg, /* WMV */
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 */
112 static int _CleanupFrameContext(MMFileFormatContext *formatContext, bool clean_all)
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;
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);
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);
146 if (formatContext->privateFormatData) mmfile_free(formatContext->privateFormatData);
147 if (formatContext->privateCodecData) mmfile_free(formatContext->privateCodecData);
149 if (formatContext->nbStreams > 0) {
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]);
156 for (i = 2; (i < formatContext->nbStreams) && (i < MAXSTREAMS); i++) {
157 if (formatContext->streams[i]) mmfile_free(formatContext->streams[i]);
161 if (formatContext->thumbNail) {
162 if (formatContext->thumbNail->frameData)
163 mmfile_free(formatContext->thumbNail->frameData);
165 if (formatContext->thumbNail->configData)
166 mmfile_free(formatContext->thumbNail->configData);
168 mmfile_free(formatContext->thumbNail);
171 formatContext->videoTotalTrackNum = 0;
172 formatContext->audioTotalTrackNum = 0;
173 formatContext->nbStreams = 0;
176 return MMFILE_FORMAT_SUCCESS;
180 _PreprocessFile(MMFileSourceType *fileSrc, char **urifilename, int *formatEnum, int *isdrm)
182 const char *fileName = NULL;
183 int filename_len = 0;
184 int index = 0, skip_index = 0;
186 drm_content_info_s contentInfo;
189 MMFileIOHandle *fp = NULL;
191 if (fileSrc->type == MM_FILE_SRC_TYPE_FILE) {
192 unsigned long long file_extansion = 0;
194 fileName = (const char *)(fileSrc->file.path);
195 filename_len = strlen(fileName);
199 * Make URI name with file name
201 drm_bool_type_e res = DRM_TRUE;
202 drm_file_type_e file_type = DRM_TYPE_UNDEFINED;
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];
212 *isdrm = MM_FILE_DRM_OMA;
213 #ifdef __MMFILE_TEST_MODE__
214 debug_msg("OMA DRM detected.\n");
217 memset(&contentInfo, 0x0, sizeof(drm_content_info_s));
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;
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;
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;
236 *urifilename = mmfile_malloc(MMFILE_DRM_URI_LEN + filename_len + 1);
238 debug_error("error: mmfile_malloc uriname\n");
239 goto FILE_FORMAT_FAIL;
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;
251 #endif /* DRM_SUPPORT */
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);
258 debug_error("error: mmfile_malloc uriname\n");
259 goto FILE_FORMAT_FAIL;
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';
268 *urifilename = mmfile_malloc(MMFILE_FILE_URI_LEN + filename_len + 1);
270 debug_error("error: mmfile_malloc uriname\n");
271 goto FILE_FORMAT_FAIL;
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';
280 * Get file extension from file's name
284 if (fileName[pos] == '.')
286 file_extansion |= (fileName[pos] >= 'A' && fileName[pos] <= 'Z' ? fileName[pos] + 0x20 : fileName[pos]) << (filename_len - pos - 1) * 8;
290 ret = mmfile_open(&fp, *urifilename, MMFILE_RDONLY);
292 if (ret == MMFILE_IO_FAILED) {
293 debug_error("error: mmfile_open\n");
294 goto FILE_FORMAT_FAIL;
297 /*///////////////////////////////////////////////////////////////////// */
298 /* Check File format // */
299 /*///////////////////////////////////////////////////////////////////// */
301 #ifdef __MMFILE_TEST_MODE__
302 /*debug_msg ("Get codec type of [%s].\n", extansion_name); */
305 switch (file_extansion) {
307 case MMFILE_EXT_MPEG4:
310 case MMFILE_EXT_MPG4:
312 if (MMFileFormatIsValidMP4(fp, NULL)) {
313 *formatEnum = MM_FILE_FORMAT_MP4;
314 goto FILE_FORMAT_SUCCESS;
316 skip_index = MM_FILE_FORMAT_MP4;
317 goto PROBE_PROPER_FILE_TYPE;
321 if (MMFileFormatIsValidMP4(fp, NULL)) {
322 *formatEnum = MM_FILE_FORMAT_3GP;
323 goto FILE_FORMAT_SUCCESS;
325 skip_index = MM_FILE_FORMAT_3GP;
326 goto PROBE_PROPER_FILE_TYPE;
331 if (MMFileFormatIsValidAMR(fp, NULL)) {
332 *formatEnum = MM_FILE_FORMAT_AMR;
333 goto FILE_FORMAT_SUCCESS;
335 skip_index = MM_FILE_FORMAT_AMR;
336 goto PROBE_PROPER_FILE_TYPE;
340 if (MMFileFormatIsValidWAV(fp, NULL)) {
341 *formatEnum = MM_FILE_FORMAT_WAV;
342 goto FILE_FORMAT_SUCCESS;
344 skip_index = MM_FILE_FORMAT_WAV;
345 goto PROBE_PROPER_FILE_TYPE;
349 case MMFILE_EXT_MIDI:
351 if (MMFileFormatIsValidMID(fp, NULL)) {
352 *formatEnum = MM_FILE_FORMAT_MID;
353 goto FILE_FORMAT_SUCCESS;
355 skip_index = MM_FILE_FORMAT_MID;
356 goto PROBE_PROPER_FILE_TYPE;
360 if (MMFileFormatIsValidMP3(fp, NULL, 5)) {
361 *formatEnum = MM_FILE_FORMAT_MP3;
362 goto FILE_FORMAT_SUCCESS;
364 skip_index = MM_FILE_FORMAT_MP3;
365 goto PROBE_PROPER_FILE_TYPE;
369 if (MMFileFormatIsValidAAC(fp, NULL)) {
370 *formatEnum = MM_FILE_FORMAT_AAC;
371 goto FILE_FORMAT_SUCCESS;
373 skip_index = MM_FILE_FORMAT_AAC;
374 goto PROBE_PROPER_FILE_TYPE;
378 case MMFILE_EXT_MXMF:
379 if (MMFileFormatIsValidMID(fp, NULL)) {
380 *formatEnum = MM_FILE_FORMAT_MID;
381 goto FILE_FORMAT_SUCCESS;
383 skip_index = MM_FILE_FORMAT_MID;
384 goto PROBE_PROPER_FILE_TYPE;
389 if (MMFileFormatIsValidMMF(fp, NULL)) {
390 *formatEnum = MM_FILE_FORMAT_MMF;
391 goto FILE_FORMAT_SUCCESS;
393 skip_index = MM_FILE_FORMAT_MMF;
394 goto PROBE_PROPER_FILE_TYPE;
398 if (MMFileFormatIsValidIMY(fp, NULL)) {
399 *formatEnum = MM_FILE_FORMAT_IMELODY;
400 goto FILE_FORMAT_SUCCESS;
402 skip_index = MM_FILE_FORMAT_IMELODY;
403 goto PROBE_PROPER_FILE_TYPE;
407 if (MMFileFormatIsValidAVI(fp, NULL)) {
408 *formatEnum = MM_FILE_FORMAT_AVI;
409 goto FILE_FORMAT_SUCCESS;
411 skip_index = MM_FILE_FORMAT_AVI;
412 goto PROBE_PROPER_FILE_TYPE;
415 case MMFILE_EXT_DIVX:
416 if (MMFileFormatIsValidAVI(fp, NULL)) {
417 *formatEnum = MM_FILE_FORMAT_DIVX;
418 goto FILE_FORMAT_SUCCESS;
420 skip_index = MM_FILE_FORMAT_DIVX;
421 goto PROBE_PROPER_FILE_TYPE;
426 if (MMFileFormatIsValidASF(fp, NULL)) {
427 *formatEnum = MM_FILE_FORMAT_ASF;
428 goto FILE_FORMAT_SUCCESS;
430 skip_index = MM_FILE_FORMAT_ASF;
431 goto PROBE_PROPER_FILE_TYPE;
435 if (MMFileFormatIsValidWMA(fp, NULL)) {
436 *formatEnum = MM_FILE_FORMAT_WMA;
437 goto FILE_FORMAT_SUCCESS;
439 skip_index = MM_FILE_FORMAT_WMA;
440 goto PROBE_PROPER_FILE_TYPE;
444 if (MMFileFormatIsValidWMV(fp, NULL)) {
445 *formatEnum = MM_FILE_FORMAT_WMV;
446 goto FILE_FORMAT_SUCCESS;
448 skip_index = MM_FILE_FORMAT_WMV;
449 goto PROBE_PROPER_FILE_TYPE;
453 if (MMFileFormatIsValidOGG(fp, NULL)) {
454 *formatEnum = MM_FILE_FORMAT_OGG;
455 goto FILE_FORMAT_SUCCESS;
457 skip_index = MM_FILE_FORMAT_OGG;
458 goto PROBE_PROPER_FILE_TYPE;
463 if (MMFileFormatIsValidMatroska(fp, NULL)) {
464 *formatEnum = MM_FILE_FORMAT_MATROSKA;
465 goto FILE_FORMAT_SUCCESS;
467 skip_index = MM_FILE_FORMAT_MATROSKA;
468 goto PROBE_PROPER_FILE_TYPE;
472 if (MMFileFormatIsValidMP4(fp, NULL)) {
473 *formatEnum = MM_FILE_FORMAT_QT;
474 goto FILE_FORMAT_SUCCESS;
476 skip_index = MM_FILE_FORMAT_QT;
477 goto PROBE_PROPER_FILE_TYPE;
480 case MMFILE_EXT_FLAC:
481 if (MMFileFormatIsValidFLAC(fp, NULL)) {
482 *formatEnum = MM_FILE_FORMAT_FLAC;
483 goto FILE_FORMAT_SUCCESS;
485 skip_index = MM_FILE_FORMAT_FLAC;
486 goto PROBE_PROPER_FILE_TYPE;
490 if (MMFileFormatIsValidFLV(fp, NULL)) {
491 *formatEnum = MM_FILE_FORMAT_FLV;
492 goto FILE_FORMAT_SUCCESS;
494 skip_index = MM_FILE_FORMAT_FLV;
495 goto PROBE_PROPER_FILE_TYPE;
499 case MMFILE_EXT_RMVB:
500 if (MMFileFormatIsValidREAL(fp, NULL)) {
501 *formatEnum = MM_FILE_FORMAT_REAL;
502 goto FILE_FORMAT_SUCCESS;
504 skip_index = MM_FILE_FORMAT_REAL;
505 goto PROBE_PROPER_FILE_TYPE;
508 case MMFILE_EXT_M2TS:
512 if (MMFileFormatIsValidMPEGTS(fp, NULL)) {
513 *formatEnum = MM_FILE_FORMAT_M2TS;
514 goto FILE_FORMAT_SUCCESS;
516 skip_index = MM_FILE_FORMAT_M2TS;
517 goto PROBE_PROPER_FILE_TYPE;
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;
528 skip_index = MM_FILE_FORMAT_M2PS;
529 goto PROBE_PROPER_FILE_TYPE;
533 case MMFILE_EXT_AIFF:
534 *formatEnum = MM_FILE_FORMAT_AIFF;
535 goto FILE_FORMAT_SUCCESS;
539 debug_warning("probe file type=%s\n", fileName);
541 goto PROBE_PROPER_FILE_TYPE;
544 } else if (fileSrc->type == MM_FILE_SRC_TYPE_MEMORY) {
545 char tempURIBuffer[MMFILE_URI_MAX_LEN] = {0, };
547 sprintf(tempURIBuffer, "%s%u:%u", MMFILE_MEM_URI, (unsigned int)fileSrc->memory.ptr, fileSrc->memory.size);
548 *urifilename = mmfile_strdup(tempURIBuffer);
550 debug_error("error: uri is NULL\n");
551 goto FILE_FORMAT_FAIL;
554 ret = mmfile_open(&fp, *urifilename, MMFILE_RDONLY);
556 if (ret == MMFILE_IO_FAILED) {
557 debug_error("error: mmfile_open\n");
558 goto FILE_FORMAT_FAIL;
561 #ifdef __MMFILE_TEST_MODE__
562 debug_msg("uri: %s\n", *urifilename);
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;
571 skip_index = MM_FILE_FORMAT_3GP;
572 goto PROBE_PROPER_FILE_TYPE;
576 case MM_FILE_FORMAT_MP4: {
577 if (MMFileFormatIsValidMP4(fp, NULL)) {
578 *formatEnum = MM_FILE_FORMAT_MP4;
579 goto FILE_FORMAT_SUCCESS;
581 skip_index = MM_FILE_FORMAT_MP4;
582 goto PROBE_PROPER_FILE_TYPE;
586 case MM_FILE_FORMAT_AMR: {
587 if (MMFileFormatIsValidAMR(fp, NULL)) {
588 *formatEnum = MM_FILE_FORMAT_AMR;
589 goto FILE_FORMAT_SUCCESS;
591 skip_index = MM_FILE_FORMAT_AMR;
592 goto PROBE_PROPER_FILE_TYPE;
596 case MM_FILE_FORMAT_WAV: {
597 if (MMFileFormatIsValidWAV(fp, NULL)) {
598 *formatEnum = MM_FILE_FORMAT_WAV;
599 goto FILE_FORMAT_SUCCESS;
601 skip_index = MM_FILE_FORMAT_WAV;
602 goto PROBE_PROPER_FILE_TYPE;
606 case MM_FILE_FORMAT_MID: {
607 if (MMFileFormatIsValidMID(fp, NULL)) {
608 *formatEnum = MM_FILE_FORMAT_MID;
609 goto FILE_FORMAT_SUCCESS;
611 skip_index = MM_FILE_FORMAT_MID;
612 goto PROBE_PROPER_FILE_TYPE;
616 case MM_FILE_FORMAT_MP3: {
617 if (MMFileFormatIsValidMP3(fp, NULL, 5)) {
618 *formatEnum = MM_FILE_FORMAT_MP3;
619 goto FILE_FORMAT_SUCCESS;
621 skip_index = MM_FILE_FORMAT_MP3;
622 goto PROBE_PROPER_FILE_TYPE;
626 case MM_FILE_FORMAT_AAC: {
627 if (MMFileFormatIsValidAAC(fp, NULL)) {
628 *formatEnum = MM_FILE_FORMAT_AAC;
629 goto FILE_FORMAT_SUCCESS;
631 skip_index = MM_FILE_FORMAT_AAC;
632 goto PROBE_PROPER_FILE_TYPE;
636 case MM_FILE_FORMAT_MMF: {
637 if (MMFileFormatIsValidMMF(fp, NULL)) {
638 *formatEnum = MM_FILE_FORMAT_MMF;
639 goto FILE_FORMAT_SUCCESS;
641 skip_index = MM_FILE_FORMAT_MMF;
642 goto PROBE_PROPER_FILE_TYPE;
646 case MM_FILE_FORMAT_IMELODY: {
647 if (MMFileFormatIsValidIMY(fp, NULL)) {
648 *formatEnum = MM_FILE_FORMAT_IMELODY;
649 goto FILE_FORMAT_SUCCESS;
651 skip_index = MM_FILE_FORMAT_IMELODY;
652 goto PROBE_PROPER_FILE_TYPE;
656 case MM_FILE_FORMAT_AVI: {
657 if (MMFileFormatIsValidAVI(fp, NULL)) {
658 *formatEnum = MM_FILE_FORMAT_AVI;
659 goto FILE_FORMAT_SUCCESS;
661 skip_index = MM_FILE_FORMAT_AVI;
662 goto PROBE_PROPER_FILE_TYPE;
666 case MM_FILE_FORMAT_DIVX: {
667 if (MMFileFormatIsValidAVI(fp, NULL)) {
668 *formatEnum = MM_FILE_FORMAT_DIVX;
669 goto FILE_FORMAT_SUCCESS;
671 skip_index = MM_FILE_FORMAT_DIVX;
672 goto PROBE_PROPER_FILE_TYPE;
676 case MM_FILE_FORMAT_ASF: {
677 if (MMFileFormatIsValidASF(fp, NULL)) {
678 *formatEnum = MM_FILE_FORMAT_ASF;
679 goto FILE_FORMAT_SUCCESS;
681 skip_index = MM_FILE_FORMAT_ASF;
682 goto PROBE_PROPER_FILE_TYPE;
686 case MM_FILE_FORMAT_WMA: {
687 if (MMFileFormatIsValidWMA(fp, NULL)) {
688 *formatEnum = MM_FILE_FORMAT_WMA;
689 goto FILE_FORMAT_SUCCESS;
691 skip_index = MM_FILE_FORMAT_WMA;
692 goto PROBE_PROPER_FILE_TYPE;
696 case MM_FILE_FORMAT_WMV: {
697 if (MMFileFormatIsValidWMV(fp, NULL)) {
698 *formatEnum = MM_FILE_FORMAT_WMV;
699 goto FILE_FORMAT_SUCCESS;
701 skip_index = MM_FILE_FORMAT_WMV;
702 goto PROBE_PROPER_FILE_TYPE;
706 case MM_FILE_FORMAT_OGG: {
707 if (MMFileFormatIsValidOGG(fp, NULL)) {
708 *formatEnum = MM_FILE_FORMAT_OGG;
709 goto FILE_FORMAT_SUCCESS;
711 skip_index = MM_FILE_FORMAT_OGG;
712 goto PROBE_PROPER_FILE_TYPE;
715 case MM_FILE_FORMAT_MATROSKA: {
716 if (MMFileFormatIsValidMatroska(fp, NULL)) {
717 *formatEnum = MM_FILE_FORMAT_MATROSKA;
718 goto FILE_FORMAT_SUCCESS;
720 skip_index = MM_FILE_FORMAT_MATROSKA;
721 goto PROBE_PROPER_FILE_TYPE;
724 case MM_FILE_FORMAT_QT: {
725 if (MMFileFormatIsValidMP4(fp, NULL)) {
726 *formatEnum = MM_FILE_FORMAT_QT;
727 goto FILE_FORMAT_SUCCESS;
729 skip_index = MM_FILE_FORMAT_QT;
730 goto PROBE_PROPER_FILE_TYPE;
733 case MM_FILE_FORMAT_FLAC: {
734 if (MMFileFormatIsValidFLAC(fp, NULL)) {
735 *formatEnum = MM_FILE_FORMAT_FLAC;
736 goto FILE_FORMAT_SUCCESS;
738 skip_index = MM_FILE_FORMAT_FLAC;
739 goto PROBE_PROPER_FILE_TYPE;
742 case MM_FILE_FORMAT_FLV: {
743 if (MMFileFormatIsValidFLV(fp, NULL)) {
744 *formatEnum = MM_FILE_FORMAT_FLV;
745 goto FILE_FORMAT_SUCCESS;
747 skip_index = MM_FILE_FORMAT_FLV;
748 goto PROBE_PROPER_FILE_TYPE;
751 case MM_FILE_FORMAT_REAL: {
752 if (MMFileFormatIsValidREAL(fp, NULL)) {
753 *formatEnum = MM_FILE_FORMAT_REAL;
754 goto FILE_FORMAT_SUCCESS;
756 skip_index = MM_FILE_FORMAT_REAL;
757 goto PROBE_PROPER_FILE_TYPE;
760 case MM_FILE_FORMAT_M2TS: {
761 if (MMFileFormatIsValidMPEGTS(fp, NULL)) {
762 *formatEnum = MM_FILE_FORMAT_M2TS;
763 goto FILE_FORMAT_SUCCESS;
765 skip_index = MM_FILE_FORMAT_M2TS;
766 goto PROBE_PROPER_FILE_TYPE;
769 case MM_FILE_FORMAT_M2PS: {
770 if (MMFileFormatIsValidMPEGPS(fp, NULL)) {
771 *formatEnum = MM_FILE_FORMAT_M2PS;
772 goto FILE_FORMAT_SUCCESS;
774 skip_index = MM_FILE_FORMAT_M2PS;
775 goto PROBE_PROPER_FILE_TYPE;
778 case MM_FILE_FORMAT_M1AUDIO: {
779 if (MMFileFormatIsValidMPEGAUDIO(fp, NULL)) {
780 *formatEnum = MM_FILE_FORMAT_M1AUDIO;
781 goto FILE_FORMAT_SUCCESS;
783 skip_index = MM_FILE_FORMAT_M1AUDIO;
784 goto PROBE_PROPER_FILE_TYPE;
787 case MM_FILE_FORMAT_M1VIDEO: {
788 if (MMFileFormatIsValidMPEGVIDEO(fp, NULL)) {
789 *formatEnum = MM_FILE_FORMAT_M1VIDEO;
790 goto FILE_FORMAT_SUCCESS;
792 skip_index = MM_FILE_FORMAT_M1VIDEO;
793 goto PROBE_PROPER_FILE_TYPE;
797 debug_warning("probe fileformat type=%d (%d: autoscan)\n", fileSrc->memory.format, MM_FILE_FORMAT_INVALID);
799 goto PROBE_PROPER_FILE_TYPE;
804 debug_error("error: invaild input type[memory|file]\n");
805 goto FILE_FORMAT_FAIL;
808 PROBE_PROPER_FILE_TYPE:
809 for (index = 0; index < MM_FILE_FORMAT_NUM; index++) {
810 if (index == skip_index)
813 #ifdef __MMFILE_TEST_MODE__
814 debug_msg("search index = [%d]\n", 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)
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;
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)
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;
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)
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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:
1010 debug_error("error: invaild format enum[%d]\n", index);
1017 if (index == MM_FILE_FORMAT_NUM)
1018 debug_error("Can't probe file type\n");
1025 return MMFILE_FORMAT_FAIL;
1028 FILE_FORMAT_SUCCESS:
1032 return MMFILE_FORMAT_SUCCESS;
1035 static int _mmfile_format_close(MMFileFormatContext *formatContext, bool clean_all)
1037 if (NULL == formatContext) {
1038 debug_error("error: invalid params\n");
1039 return MMFILE_FORMAT_FAIL;
1042 if (formatContext->Close) {
1043 formatContext->Close(formatContext);
1044 formatContext->Close = NULL;
1047 _CleanupFrameContext(formatContext, clean_all);
1050 mmfile_free(formatContext);
1052 return MMFILE_FORMAT_SUCCESS;
1057 int mmfile_format_open(MMFileFormatContext **formatContext, MMFileSourceType *fileSrc)
1061 MMFileFormatContext *formatObject = NULL;
1063 if (NULL == fileSrc) {
1064 debug_error("error: invalid params\n");
1065 return MMFILE_FORMAT_FAIL;
1068 /* create formatContext object */
1069 formatObject = mmfile_malloc(sizeof(MMFileFormatContext));
1070 if (NULL == formatObject) {
1071 debug_error("error: mmfile_malloc fail for formatObject\n");
1072 *formatContext = NULL;
1073 return MMFILE_FORMAT_FAIL;
1076 memset(formatObject, 0x00, sizeof(MMFileFormatContext));
1078 mmfile_register_io_all();
1080 /* parsing file extension */
1081 formatObject->filesrc = fileSrc;
1083 formatObject->pre_checked = 0; /*not yet format checked.*/
1086 * Format detect and validation check.
1088 ret = _PreprocessFile(fileSrc, &formatObject->uriFileName, &formatObject->formatType, &formatObject->isdrm);
1089 if (MMFILE_FORMAT_SUCCESS != ret) {
1090 debug_error("error: _PreprocessFile fail\n");
1091 ret = MMFILE_FORMAT_FAIL;
1095 formatObject->pre_checked = 1; /*already file format checked.*/
1098 * Open format function.
1100 if (NULL == MMFileOpenFunc[formatObject->formatType]) {
1101 debug_error("error: Not implemented \n");
1102 ret = MMFILE_FORMAT_FAIL;
1103 goto find_valid_handler;
1106 ret = MMFileOpenFunc[formatObject->formatType](formatObject);
1107 if (MMFILE_FORMAT_FAIL == ret) {
1108 debug_error("error: Try other formats\n");
1109 ret = MMFILE_FORMAT_FAIL;
1110 /* goto find_valid_handler; */
1114 *formatContext = formatObject;
1115 return MMFILE_FORMAT_SUCCESS;
1118 formatObject->pre_checked = 0; /*do check file format*/
1120 for (index = 0; index < MM_FILE_FORMAT_NUM + 1; index++) {
1121 if (NULL == MMFileOpenFunc[index]) {
1122 debug_error("error: Not implemented \n");
1123 ret = MMFILE_FORMAT_FAIL;
1127 if (formatObject->formatType == index)
1130 ret = MMFileOpenFunc[index](formatObject);
1131 if (MMFILE_FORMAT_FAIL == ret) {
1132 /* _CleanupFrameContext(formatObject, true); */
1139 formatObject->formatType = index;
1141 if (index == MM_FILE_FORMAT_NUM + 1 && MMFILE_FORMAT_FAIL == ret) {
1142 debug_error("can't find file format handler\n");
1143 _CleanupFrameContext(formatObject, true);
1144 ret = MMFILE_FORMAT_FAIL;
1148 formatObject->formatType = index;
1149 *formatContext = formatObject;
1151 return MMFILE_FORMAT_SUCCESS;
1154 _mmfile_format_close(formatObject, true);
1155 *formatContext = NULL;
1161 int mmfile_format_read_stream(MMFileFormatContext *formatContext)
1163 if (NULL == formatContext || NULL == formatContext->ReadStream) {
1164 debug_error("error: invalid params\n");
1165 return MMFILE_FORMAT_FAIL;
1168 return formatContext->ReadStream(formatContext);
1172 int mmfile_format_read_frame(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
1174 if (NULL == formatContext || NULL == frame || NULL == formatContext->ReadFrame) {
1175 debug_error("error: invalid params\n");
1176 return MMFILE_FORMAT_FAIL;
1179 return formatContext->ReadFrame(formatContext, timestamp, frame);
1183 int mmfile_format_read_tag(MMFileFormatContext *formatContext)
1185 if (NULL == formatContext || NULL == formatContext->ReadTag) {
1186 debug_error("error: invalid params\n");
1187 return MMFILE_FORMAT_FAIL;
1190 return formatContext->ReadTag(formatContext);
1195 int mmfile_format_close(MMFileFormatContext *formatContext)
1197 return _mmfile_format_close(formatContext, false);