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.
24 #include <unistd.h> /*for access*/
25 #include <string.h> /*for strXXX*/
28 /* exported MM header files */
31 /* internal MM header files */
32 #include <mm_attrs_private.h>
34 /* internal MM File headers */
35 #include "mm_file_debug.h"
36 #include "mm_file_formats.h"
37 #include "mm_file_format_frame.h"
38 #include "mm_file_codecs.h"
39 #include "mm_file_utils.h"
44 /*#define CHECK_TIME */
50 gettimeofday(&tv, NULL);
51 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
61 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
64 #define _SEEK_POINT_ 3000 /*1000 = 1 seconds*/
66 #define MM_FILE_TAG_SYNCLYRICS "tag-synclyrics" /**< Synchronized Lyrics Information*/
76 MM_FILE_PARSE_TYPE_SIMPLE, /*parse audio/video track num only*/
77 MM_FILE_PARSE_TYPE_NORMAL, /*parse infomation without thumbnail*/
78 MM_FILE_PARSE_TYPE_ALL, /*parse all infomation*/
79 MM_FILE_PARSE_TYPE_SAFE, /*parse infomation without both thumbnail and stream full-searching*/
90 void *formatFuncHandle;
91 void *codecFuncHandle;
99 static mmf_attrs_construct_info_t g_tag_attrs[] = {
100 {(char *)"tag-artist", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
101 {(char *)"tag-title", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
102 {(char *)"tag-album", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
103 {(char *)"tag-album-artist", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
104 {(char *)"tag-genre", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
105 {(char *)"tag-author", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
106 {(char *)"tag-copyright", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
107 {(char *)"tag-date", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
108 {(char *)"tag-description", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
109 {(char *)"tag-comment", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
110 {(char *)"tag-artwork", MMF_VALUE_TYPE_DATA, MM_ATTRS_FLAG_RW, (void *)NULL},
111 {(char *)"tag-artwork-size", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
112 {(char *)"tag-artwork-mime", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
113 {(char *)"tag-track-num", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
114 {(char *)"tag-classification", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
115 {(char *)"tag-rating", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
116 {(char *)"tag-longitude", MM_ATTRS_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, (void *)0},
117 {(char *)"tag-latitude", MM_ATTRS_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, (void *)0},
118 {(char *)"tag-altitude", MM_ATTRS_TYPE_DOUBLE, MM_ATTRS_FLAG_RW, (void *)0},
119 {(char *)"tag-conductor", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
120 {(char *)"tag-unsynclyrics", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
121 {(char *)"tag-synclyrics-num", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
122 {(char *)"tag-synclyrics", MMF_VALUE_TYPE_DATA, MM_ATTRS_FLAG_RW, (void *)NULL},
123 {(char *)"tag-recdate", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
124 {(char *)"tag-rotate", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
125 {(char *)"tag-cdis", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
126 {(char *)"tag-smta", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
129 static mmf_attrs_construct_info_t g_content_attrs[] = {
130 {(char *)"content-duration", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
131 {(char *)"content-video-codec", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
132 {(char *)"content-video-bitrate", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
133 {(char *)"content-video-fps", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
134 {(char *)"content-video-width", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
135 {(char *)"content-video-height", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
136 {(char *)"content-video-thumbnail", MMF_VALUE_TYPE_DATA, MM_ATTRS_FLAG_RW, (void *)NULL},
137 {(char *)"content-video-track-index", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
138 {(char *)"content-video-track-count", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
139 {(char *)"content-audio-codec", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
140 {(char *)"content-audio-bitrate", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
141 {(char *)"content-audio-channels", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
142 {(char *)"content-audio-samplerate", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
143 {(char *)"content-audio-track-index", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
144 {(char *)"content-audio-track-count", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
145 {(char *)"content-audio-bitpersample", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
148 #ifdef __MMFILE_DYN_LOADING__
149 #define MMFILE_FORMAT_SO_FILE_NAME "libmmfile_formats.so"
150 #define MMFILE_CODEC_SO_FILE_NAME "libmmfile_codecs.so"
152 int (*mmfile_format_open)(MMFileFormatContext **formatContext, MMFileSourceType *fileSrc);
153 int (*mmfile_format_read_stream)(MMFileFormatContext *formatContext);
154 int (*mmfile_format_read_frame)(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
155 int (*mmfile_format_read_tag)(MMFileFormatContext *formatContext);
156 int (*mmfile_format_close)(MMFileFormatContext *formatContext);
157 int (*mmfile_codec_open)(MMFileCodecContext **codecContext, int codecType, int codecId, MMFileCodecFrame *input);
158 int (*mmfile_codec_decode)(MMFileCodecContext *codecContext, MMFileCodecFrame *output);
159 int (*mmfile_codec_close)(MMFileCodecContext *codecContext);
160 int (*mmfile_format_get_frame)(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
161 int (*mmfile_format_get_frame_from_memory)(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
164 #ifdef __MMFILE_DYN_LOADING__
165 static int _load_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
167 /* static int dll_func_initialized = 0; //disabled */
171 /* Get from function argument */
172 void *formatFuncHandle = NULL;
173 void *codecFuncHandle = NULL;
176 if (dll_func_initialized) {
181 formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
182 if (!formatFuncHandle) {
183 debug_error("error: %s\n", "libmmfile_formats.so open error");
188 mmfile_format_open = dlsym(formatFuncHandle, "mmfile_format_open");
189 mmfile_format_read_stream = dlsym(formatFuncHandle, "mmfile_format_read_stream");
190 mmfile_format_read_frame = dlsym(formatFuncHandle, "mmfile_format_read_frame");
191 mmfile_format_read_tag = dlsym(formatFuncHandle, "mmfile_format_read_tag");
192 mmfile_format_close = dlsym(formatFuncHandle, "mmfile_format_close");
194 if (!mmfile_format_open ||
195 !mmfile_format_read_stream ||
196 !mmfile_format_read_frame ||
197 !mmfile_format_read_tag ||
198 !mmfile_format_close) {
200 debug_error("error: %s\n", "format function load error");
205 /*closed at app termination.*/
206 /*dlclose (formatFuncHandle); */
208 codecFuncHandle = dlopen(MMFILE_CODEC_SO_FILE_NAME, RTLD_LAZY | RTLD_GLOBAL);
209 if (!codecFuncHandle) {
210 debug_error("error: %s\n", "libmmfile_codecs.so open error");
215 mmfile_codec_open = dlsym(codecFuncHandle, "mmfile_codec_open");
216 mmfile_codec_decode = dlsym(codecFuncHandle, "mmfile_codec_decode");
217 mmfile_codec_close = dlsym(codecFuncHandle, "mmfile_codec_close");
219 if (!mmfile_codec_open || !mmfile_codec_decode || !mmfile_codec_close) {
220 debug_error("error: %s\n", "codec function load error");
225 /*closed at app termination.*/
226 /*dlclose (codecFuncHandle); */
228 /* dll_func_initialized = 1; // disabled */
230 pHandle->codecFuncHandle = codecFuncHandle;
231 pHandle->formatFuncHandle = formatFuncHandle;
236 if (formatFuncHandle) dlclose(formatFuncHandle);
237 if (codecFuncHandle) dlclose(codecFuncHandle);
242 static void _unload_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
244 #ifdef __MMFILE_TEST_MODE__
248 if (pHandle->formatFuncHandle) {
249 dlclose(pHandle->formatFuncHandle);
251 if (pHandle->codecFuncHandle) {
252 dlclose(pHandle->codecFuncHandle);
255 #ifdef __MMFILE_TEST_MODE__
261 #endif /* __MMFILE_DYN_LOADING__ */
267 _is_file_exist(const char *filename)
271 const char *to_access = (strstr(filename, "file://") != NULL) ? filename + 7 : filename;
272 ret = access(to_access, R_OK);
274 debug_error("file [%s] not found.\n", to_access);
281 _info_set_attr_media(mmf_attrs_t *attrs, MMFileFormatContext *formatContext)
284 MMHandleType hattrs = CAST_MM_HANDLE(attrs);
286 if (formatContext->commandType == MM_FILE_TAG) {
287 if (formatContext->title) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_TITLE, formatContext->title);
288 if (formatContext->artist) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ARTIST, formatContext->artist);
289 if (formatContext->author) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_AUTHOR, formatContext->author);
290 if (formatContext->composer && formatContext->author == NULL)
291 mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_AUTHOR, formatContext->composer);
292 if (formatContext->album) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ALBUM, formatContext->album);
293 if (formatContext->album_artist) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ALBUM_ARTIST, formatContext->album_artist);
294 if (formatContext->copyright) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_COPYRIGHT, formatContext->copyright);
295 if (formatContext->description) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_DESCRIPTION, formatContext->description);
296 if (formatContext->comment) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_COMMENT, formatContext->comment);
297 if (formatContext->genre) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_GENRE, formatContext->genre);
298 if (formatContext->classification) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_CLASSIFICATION, formatContext->classification);
299 if (formatContext->year) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_DATE, formatContext->year);
300 if (formatContext->tagTrackNum) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_TRACK_NUM, formatContext->tagTrackNum);
301 if (formatContext->rating) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_RATING, formatContext->rating);
302 if (formatContext->conductor) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_CONDUCTOR, formatContext->conductor);
303 if (formatContext->recDate) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_RECDATE, formatContext->recDate);
304 if (formatContext->rotate) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ROTATE, formatContext->rotate);
305 mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_LONGITUDE, formatContext->longitude);
306 mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_LATIDUE, formatContext->latitude);
307 mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_ALTIDUE, formatContext->altitude);
308 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SYNCLYRICS_NUM, formatContext->syncLyricsNum);
309 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_CDIS, formatContext->cdis);
310 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SMTA, formatContext->smta);
312 if ((formatContext->syncLyricsNum > 0) && (formatContext->syncLyrics))
313 mm_attrs_set_data_by_name(hattrs, MM_FILE_TAG_SYNCLYRICS, formatContext->syncLyrics, formatContext->syncLyricsNum);
315 if (formatContext->unsyncLyrics) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_UNSYNCLYRICS, formatContext->unsyncLyrics);
317 if (formatContext->artwork && formatContext->artworkSize > 0) {
318 void *artworkCopy = NULL;
319 artworkCopy = mmfile_malloc((formatContext->artworkSize));
320 if (NULL != artworkCopy) {
321 memcpy(artworkCopy, formatContext->artwork, formatContext->artworkSize);
322 mm_attrs_set_data_by_name(hattrs, MM_FILE_TAG_ARTWORK, artworkCopy, formatContext->artworkSize);
323 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_ARTWORK_SIZE, formatContext->artworkSize);
324 if (formatContext->artworkMime) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ARTWORK_MIME, formatContext->artworkMime);
327 } else if (formatContext->commandType == MM_FILE_CONTENTS) {
329 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_DURATION, formatContext->duration);
330 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_TRACK_COUNT, formatContext->audioTotalTrackNum);
331 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_TRACK_COUNT, formatContext->videoTotalTrackNum);
333 if (formatContext->videoTotalTrackNum > 0 &&
334 formatContext->nbStreams > 0 &&
335 formatContext->streams[MMFILE_VIDEO_STREAM]) {
337 MMFileFormatStream *videoStream = formatContext->streams[MMFILE_VIDEO_STREAM];
339 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_CODEC, videoStream->codecId);
340 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_BITRATE, videoStream->bitRate);
341 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_FPS, videoStream->framePerSec);
342 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_WIDTH, videoStream->width);
343 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_HEIGHT, videoStream->height);
345 if (formatContext->thumbNail && formatContext->thumbNail->frameData) {
346 void *thumbNailCopy = NULL;
347 thumbNailCopy = mmfile_malloc(formatContext->thumbNail->frameSize);
349 if (NULL != thumbNailCopy) {
350 memcpy(thumbNailCopy, formatContext->thumbNail->frameData, formatContext->thumbNail->frameSize);
351 mm_attrs_set_data_by_name(hattrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, thumbNailCopy, formatContext->thumbNail->frameSize);
352 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_WIDTH, formatContext->thumbNail->frameWidth);
353 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_HEIGHT, formatContext->thumbNail->frameHeight);
358 if (formatContext->audioTotalTrackNum > 0 &&
359 formatContext->nbStreams > 0 &&
360 formatContext->streams[MMFILE_AUDIO_STREAM]) {
362 MMFileFormatStream *audioStream = formatContext->streams[MMFILE_AUDIO_STREAM];
364 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_CODEC, audioStream->codecId);
365 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_CHANNELS, audioStream->nbChannel);
366 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_BITRATE, audioStream->bitRate);
367 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_SAMPLERATE, audioStream->samplePerSec);
368 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, audioStream->bitPerSample);
375 ret = mmf_attrs_commit((MMHandleType)hattrs);
381 _get_contents_info(mmf_attrs_t *attrs, MMFileSourceType *src, MMFILE_PARSE_INFO *parse)
383 MMFileFormatContext *formatContext = NULL;
384 MMFileCodecContext *codecContext = NULL;
385 MMFileFormatFrame frameContext = {0, };
386 MMFileCodecFrame codecFrame = {0, };
387 MMFileCodecFrame decodedFrame = {0, };
392 return FILEINFO_ERROR_FILE_INTERNAL;
394 ret = mmfile_format_open(&formatContext, src);
395 if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
396 debug_error("error: mmfile_format_open\n");
397 ret = FILEINFO_ERROR_FILE_INTERNAL;
401 if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL) {
402 if (parse->type == MM_FILE_PARSE_TYPE_SAFE)
403 formatContext->cdis = 1;
404 ret = mmfile_format_read_stream(formatContext);
405 if (MMFILE_FORMAT_FAIL == ret) {
406 debug_error("error: mmfile_format_read_stream\n");
407 ret = FILEINFO_ERROR_FILE_INTERNAL;
411 parse->audio_track_num = formatContext->audioTotalTrackNum;
412 parse->video_track_num = formatContext->videoTotalTrackNum;
414 /* check uhqa content*/
415 if (formatContext->streams[MMFILE_AUDIO_STREAM] != NULL) {
416 parse->is_uhqa = formatContext->streams[MMFILE_AUDIO_STREAM]->is_uhqa;
418 parse->is_uhqa = FALSE;
421 if (parse->type >= MM_FILE_PARSE_TYPE_ALL) {
422 if (formatContext->videoTotalTrackNum > 0) {
424 if (parse->type != MM_FILE_PARSE_TYPE_SAFE) {
425 if (formatContext->formatType == MM_FILE_FORMAT_3GP || formatContext->formatType == MM_FILE_FORMAT_MP4) {
426 MMFileUtilGetMetaDataFromMP4(formatContext);
429 MMFileFormatStream *videoStream = formatContext->streams[MMFILE_VIDEO_STREAM];
430 unsigned int timestamp = _SEEK_POINT_;
432 ret = mmfile_format_read_frame(formatContext, timestamp, &frameContext);
433 if (MMFILE_FORMAT_FAIL == ret) {
434 debug_error("error: mmfile_format_read_frame\n");
435 ret = FILEINFO_ERROR_FILE_INTERNAL;
439 if (frameContext.bCompressed) {
440 codecFrame.frameDataSize = frameContext.frameSize;
441 codecFrame.width = frameContext.frameWidth;
442 codecFrame.height = frameContext.frameHeight;
443 codecFrame.frameData = frameContext.frameData;
444 codecFrame.configLen = frameContext.configLenth;
445 codecFrame.configData = frameContext.configData;
446 codecFrame.version = videoStream->version;
448 ret = mmfile_codec_open(&codecContext, MMFILE_VIDEO_DECODE, videoStream->codecId, &codecFrame);
449 if (MMFILE_FORMAT_FAIL == ret) {
450 debug_error("error: mmfile_codec_open\n");
451 ret = FILEINFO_ERROR_FILE_INTERNAL;
455 ret = mmfile_codec_decode(codecContext, &decodedFrame);
456 if (MMFILE_FORMAT_FAIL == ret) {
457 debug_error("error: mmfile_codec_decode\n");
458 ret = FILEINFO_ERROR_FILE_INTERNAL;
462 /* set video thumbnail */
463 formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
464 if (NULL == formatContext->thumbNail) {
465 debug_error("error: mmfile_malloc\n");
466 ret = FILEINFO_ERROR_FILE_INTERNAL;
470 formatContext->thumbNail->frameSize = decodedFrame.frameDataSize;
471 formatContext->thumbNail->frameWidth = decodedFrame.width;
472 formatContext->thumbNail->frameHeight = decodedFrame.height;
473 formatContext->thumbNail->frameData = decodedFrame.frameData;
474 formatContext->thumbNail->configLenth = 0;
475 formatContext->thumbNail->configData = NULL;
477 formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
478 if (NULL == formatContext->thumbNail) {
479 debug_error("error: mmfile_format_read_frame\n");
480 ret = FILEINFO_ERROR_FILE_INTERNAL;
484 formatContext->thumbNail->frameSize = frameContext.frameSize;
485 formatContext->thumbNail->frameWidth = frameContext.frameWidth;
486 formatContext->thumbNail->frameHeight = frameContext.frameHeight;
487 formatContext->thumbNail->frameData = frameContext.frameData;
488 formatContext->thumbNail->configLenth = 0;
489 formatContext->thumbNail->configData = NULL;
495 * if MM_FILE_PARSE_TYPE_SIMPLE, just get number of each stream.
497 parse->audio_track_num = formatContext->audioTotalTrackNum;
498 parse->video_track_num = formatContext->videoTotalTrackNum;
501 #ifdef __MMFILE_TEST_MODE__
502 mmfile_format_print_frame(&frameContext);
505 formatContext->commandType = MM_FILE_CONTENTS;
507 if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
508 _info_set_attr_media(attrs, formatContext);
510 if (frameContext.bCompressed) {
511 if (frameContext.frameData) mmfile_free(frameContext.frameData);
512 if (frameContext.configData) mmfile_free(frameContext.configData);
514 if (decodedFrame.frameData) {
515 mmfile_free(decodedFrame.frameData);
516 formatContext->thumbNail->frameData = NULL;
518 if (decodedFrame.configData) {
519 mmfile_free(decodedFrame.configData);
520 formatContext->thumbNail->configData = NULL;
523 if (frameContext.frameData) {
524 mmfile_free(frameContext.frameData);
525 formatContext->thumbNail->frameData = NULL;
527 if (frameContext.configData) {
528 mmfile_free(frameContext.configData);
529 formatContext->thumbNail->configData = NULL;
534 mmfile_format_close(formatContext);
537 mmfile_codec_close(codecContext);
540 return FILEINFO_ERROR_NONE;
543 formatContext->commandType = MM_FILE_CONTENTS;
545 if (frameContext.bCompressed) {
546 if (frameContext.frameData)
547 mmfile_free(frameContext.frameData);
549 if (frameContext.configData)
550 mmfile_free(frameContext.configData);
552 if (decodedFrame.frameData) {
553 mmfile_free(decodedFrame.frameData);
554 formatContext->thumbNail->frameData = NULL;
557 if (decodedFrame.configData) {
558 mmfile_free(decodedFrame.configData);
559 formatContext->thumbNail->configData = NULL;
562 if (frameContext.frameData) {
563 mmfile_free(frameContext.frameData);
564 formatContext->thumbNail->frameData = NULL;
567 if (frameContext.configData) {
568 mmfile_free(frameContext.configData);
569 formatContext->thumbNail->configData = NULL;
573 if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
574 _info_set_attr_media(attrs, formatContext);
577 mmfile_format_close(formatContext);
580 mmfile_codec_close(codecContext);
582 return FILEINFO_ERROR_NONE;
586 if (frameContext.bCompressed) {
587 if (frameContext.frameData)
588 mmfile_free(frameContext.frameData);
590 if (frameContext.configData)
591 mmfile_free(frameContext.configData);
593 if (decodedFrame.frameData) {
594 mmfile_free(decodedFrame.frameData);
595 formatContext->thumbNail->frameData = NULL;
598 if (decodedFrame.configData) {
599 mmfile_free(decodedFrame.configData);
600 formatContext->thumbNail->configData = NULL;
603 if (frameContext.frameData) {
604 mmfile_free(frameContext.frameData);
605 formatContext->thumbNail->frameData = NULL;
608 if (frameContext.configData) {
609 mmfile_free(frameContext.configData);
610 formatContext->thumbNail->configData = NULL;
615 mmfile_format_close(formatContext);
617 /* if (codecContext) { mmfile_codec_close(codecContext); } */ /*dead code*/
624 _get_tag_info(mmf_attrs_t *attrs, MMFileSourceType *src)
626 MMFileFormatContext *formatContext = NULL;
629 ret = mmfile_format_open(&formatContext, src);
630 if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
631 debug_error("error: mmfile_format_open\n");
632 ret = FILEINFO_ERROR_FILE_INTERNAL;
636 ret = mmfile_format_read_tag(formatContext);
637 if (MMFILE_FORMAT_FAIL == ret) {
638 debug_warning("reading tag is fail\n");
639 ret = FILEINFO_ERROR_FILE_INTERNAL;
643 formatContext->commandType = MM_FILE_TAG;
645 _info_set_attr_media(attrs, formatContext);
648 mmfile_format_close(formatContext);
651 return FILEINFO_ERROR_NONE;
656 mmfile_format_close(formatContext);
659 return FILEINFO_ERROR_FILE_INTERNAL;
666 int mm_file_get_attrs(MMHandleType attrs, char **err_attr_name, const char *first_attribute_name, ...)
668 int ret = FILEINFO_ERROR_NONE;
672 debug_error("Invalid arguments [attrs 0]\n");
673 return FILEINFO_ERROR_INVALID_ARGUMENT;
676 if (first_attribute_name == NULL) {
677 debug_error("Invalid arguments [first_attribute_name null]\n");
678 return FILEINFO_ERROR_INVALID_ARGUMENT;
681 /* get requested attributes */
682 va_start(var_args, first_attribute_name);
683 ret = mm_attrs_get_valist(attrs, err_attr_name, first_attribute_name, var_args);
686 if (ret != FILEINFO_ERROR_NONE) {
688 debug_error("failed to get %s\n", *err_attr_name);
695 int mm_file_get_synclyrics_info(MMHandleType tag_attrs, int index, unsigned long *time_info, char **lyrics)
697 int ret = FILEINFO_ERROR_NONE;
698 AvSynclyricsInfo *sync_lyric_item = NULL;
699 GList *synclyrics_list = NULL;
701 #ifdef __MMFILE_TEST_MODE__
705 if ((mmf_attrs_t *)tag_attrs == NULL) {
706 debug_error("invalid handle");
707 return FILEINFO_ERROR_INVALID_ARGUMENT;
710 ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
711 if (ret != FILEINFO_ERROR_NONE) {
712 #ifdef __MMFILE_TEST_MODE__
713 debug_warning("get data fail");
718 if (synclyrics_list != NULL) {
720 sync_lyric_item = (AvSynclyricsInfo *)g_list_nth_data(synclyrics_list, index);
722 if (sync_lyric_item == NULL) {
723 #ifdef __MMFILE_TEST_MODE__
724 debug_warning("synclyric item is NULL");
726 return FILEINFO_ERROR_ATTR_NOT_EXIST;
729 *time_info = sync_lyric_item->time_info;
730 *lyrics = sync_lyric_item->lyric_info;
733 #ifdef __MMFILE_TEST_MODE__
734 debug_warning("synclyrics_list is NULL");
736 return FILEINFO_ERROR_ATTR_NOT_EXIST;
743 int mm_file_create_tag_attrs(MMHandleType *tag_attrs, const char *filename)
745 int ret = FILEINFO_ERROR_NONE;
746 mmf_attrs_t *attrs = NULL;
747 MMFileSourceType src;
749 #ifdef __MMFILE_TEST_MODE__
753 /* Check argument here */
754 if (tag_attrs == NULL) {
755 debug_error("Invalid arguments [tag null]\n");
756 return FILEINFO_ERROR_INVALID_ARGUMENT;
758 if (filename == NULL) {
759 debug_error("Invalid arguments [filename null]\n");
760 return FILEINFO_ERROR_INVALID_ARGUMENT;
762 if (strlen(filename) == 0) {
763 debug_error("Invalid arguments [filename size 0]\n");
764 return FILEINFO_ERROR_INVALID_ARGUMENT;
768 #ifdef __MMFILE_DYN_LOADING__
769 MMFILE_FUNC_HANDLE func_handle;
771 ret = _load_dynamic_functions(&func_handle);
773 debug_error("load library error\n");
774 return FILEINFO_ERROR_FILE_INTERNAL;
778 /*set source file infomation*/
779 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
781 ret = _is_file_exist(filename);
783 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
788 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("tag", g_tag_attrs, ARRAY_SIZE(g_tag_attrs), NULL, NULL);
790 debug_error("attribute internal error.\n");
791 ret = FILEINFO_ERROR_FILE_INTERNAL;
795 ret = _get_tag_info(attrs, &src);
796 if (ret != FILEINFO_ERROR_NONE) {
797 mmf_attrs_free((MMHandleType)attrs);
799 debug_error("failed to get tag: %s\n", filename);
802 *tag_attrs = (MMHandleType)attrs;
805 #ifdef __MMFILE_DYN_LOADING__
806 _unload_dynamic_functions(&func_handle);
809 #ifdef __MMFILE_TEST_MODE__
818 int mm_file_destroy_tag_attrs(MMHandleType tag_attrs)
820 void *artwork = NULL;
821 GList *synclyrics_list = NULL;
822 int ret = FILEINFO_ERROR_NONE;
824 #ifdef __MMFILE_TEST_MODE__
828 if ((mmf_attrs_t *)tag_attrs == NULL) {
829 debug_error("invalid handle.\n");
830 return FILEINFO_ERROR_INVALID_ARGUMENT;
833 ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_ARTWORK, &artwork);
835 if (artwork != NULL) {
836 mmfile_free(artwork);
839 ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
841 if (synclyrics_list != NULL) {
842 mm_file_free_synclyrics_list(synclyrics_list);
845 mmf_attrs_free(tag_attrs);
847 #ifdef __MMFILE_TEST_MODE__
855 int mm_file_create_content_attrs(MMHandleType *contents_attrs, const char *filename)
857 mmf_attrs_t *attrs = NULL;
858 MMFileSourceType src = {0, };
859 MMFILE_PARSE_INFO parse = {0, };
862 #ifdef __MMFILE_TEST_MODE__
866 /* Check argument here */
867 if (contents_attrs == NULL) {
868 debug_error("Invalid arguments [contents null]\n");
869 return FILEINFO_ERROR_INVALID_ARGUMENT;
871 if (filename == NULL) {
872 debug_error("Invalid arguments [filename null]\n");
873 return FILEINFO_ERROR_INVALID_ARGUMENT;
875 if (strlen(filename) == 0) {
876 debug_error("Invalid arguments [filename size 0]\n");
877 return FILEINFO_ERROR_INVALID_ARGUMENT;
881 #ifdef __MMFILE_DYN_LOADING__
882 MMFILE_FUNC_HANDLE func_handle;
889 ret = _load_dynamic_functions(&func_handle);
891 debug_error("load library error\n");
892 return FILEINFO_ERROR_FILE_INTERNAL;
896 debug_msg("_load_dynamic_functions() = %lld\n", gettime() - ti);
901 /*set source file infomation*/
902 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
904 ret = _is_file_exist(filename);
906 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
911 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
913 debug_error("attribute internal error.\n");
914 ret = FILEINFO_ERROR_FILE_INTERNAL;
919 parse.type = MM_FILE_PARSE_TYPE_ALL;
920 ret = _get_contents_info(attrs, &src, &parse);
921 if (ret != FILEINFO_ERROR_NONE) {
922 mmf_attrs_free((MMHandleType)attrs);
924 debug_error("failed to get contents: %s\n", filename);
927 *contents_attrs = (MMHandleType) attrs;
931 #ifdef __MMFILE_DYN_LOADING__
937 _unload_dynamic_functions(&func_handle);
940 debug_msg("_unload_dynamic_functions() = %lld\n", gettime() - ti);
945 #ifdef __MMFILE_TEST_MODE__
954 int mm_file_create_tag_attrs_from_memory(MMHandleType *tag_attrs, const void *data, unsigned int size, int format)
956 mmf_attrs_t *attrs = NULL;
957 MMFileSourceType src;
958 /*MMFILE_PARSE_INFO parse = {0, };*/
961 #ifdef __MMFILE_TEST_MODE__
965 /* Check argument here */
966 if (tag_attrs == NULL || data == NULL) {
967 debug_error("Invalid arguments\n");
968 return FILEINFO_ERROR_INVALID_ARGUMENT;
971 #ifdef __MMFILE_DYN_LOADING__
972 MMFILE_FUNC_HANDLE func_handle;
974 ret = _load_dynamic_functions(&func_handle);
976 debug_error("load library error\n");
977 return FILEINFO_ERROR_FILE_INTERNAL;
981 MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);
984 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("tag", g_tag_attrs, ARRAY_SIZE(g_tag_attrs), NULL, NULL);
986 debug_error("attribute internal error.\n");
987 ret = FILEINFO_ERROR_FILE_INTERNAL;
991 /*parse.type = MM_FILE_PARSE_TYPE_ALL;*/
992 ret = _get_tag_info(attrs, &src);
993 if (ret != FILEINFO_ERROR_NONE) {
994 mmf_attrs_free((MMHandleType)attrs);
996 debug_error("failed to get tag");
999 *tag_attrs = (MMHandleType)attrs;
1002 #ifdef __MMFILE_DYN_LOADING__
1003 _unload_dynamic_functions(&func_handle);
1006 #ifdef __MMFILE_TEST_MODE__
1015 int mm_file_create_content_attrs_from_memory(MMHandleType *contents_attrs, const void *data, unsigned int size, int format)
1017 mmf_attrs_t *attrs = NULL;
1018 MMFileSourceType src;
1019 MMFILE_PARSE_INFO parse = {0, };
1022 #ifdef __MMFILE_TEST_MODE__
1026 /* Check argument here */
1027 if (contents_attrs == NULL || data == NULL) {
1028 debug_error("Invalid arguments\n");
1029 return FILEINFO_ERROR_INVALID_ARGUMENT;
1032 #ifdef __MMFILE_DYN_LOADING__
1033 MMFILE_FUNC_HANDLE func_handle;
1035 ret = _load_dynamic_functions(&func_handle);
1037 debug_error("load library error\n");
1038 return FILEINFO_ERROR_FILE_INTERNAL;
1042 MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);
1045 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
1047 debug_error("attribute internal error.\n");
1048 ret = FILEINFO_ERROR_FILE_INTERNAL;
1052 parse.type = MM_FILE_PARSE_TYPE_ALL;
1053 ret = _get_contents_info(attrs, &src, &parse);
1054 if (ret != FILEINFO_ERROR_NONE) {
1055 mmf_attrs_free((MMHandleType)attrs);
1057 debug_error("failed to get contents");
1060 *contents_attrs = (MMHandleType)attrs;
1063 #ifdef __MMFILE_DYN_LOADING__
1064 _unload_dynamic_functions(&func_handle);
1067 #ifdef __MMFILE_TEST_MODE__
1076 int mm_file_destroy_content_attrs(MMHandleType contents_attrs)
1078 void *thumbnail = NULL;
1079 int ret = FILEINFO_ERROR_NONE;
1081 #ifdef __MMFILE_TEST_MODE__
1085 if ((mmf_attrs_t *)contents_attrs == NULL) {
1086 debug_error("invalid handle.\n");
1087 return FILEINFO_ERROR_INVALID_ARGUMENT;
1090 ret = mm_attrs_get_data_by_name(contents_attrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, &thumbnail);
1091 if (thumbnail != NULL) {
1092 mmfile_free(thumbnail);
1095 mmf_attrs_free(contents_attrs);
1097 #ifdef __MMFILE_TEST_MODE__
1106 int mm_file_get_stream_info(const char *filename, int *audio_stream_num, int *video_stream_num)
1108 MMFileSourceType src = {0, };
1109 MMFILE_PARSE_INFO parse = {0, };
1113 #ifdef __MMFILE_TEST_MODE__
1117 if (filename == NULL || strlen(filename) == 0 || audio_stream_num == NULL || video_stream_num == NULL) {
1118 debug_error("Invalid arguments\n");
1119 return FILEINFO_ERROR_INVALID_ARGUMENT;
1122 #ifdef __MMFILE_DYN_LOADING__
1123 MMFILE_FUNC_HANDLE func_handle;
1125 ret = _load_dynamic_functions(&func_handle);
1127 debug_error("load library error\n");
1128 return FILEINFO_ERROR_FILE_INTERNAL;
1132 /*set source file infomation*/
1133 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1135 ret = _is_file_exist(filename);
1137 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
1141 parse.type = MM_FILE_PARSE_TYPE_SIMPLE;
1142 ret = _get_contents_info(NULL, &src, &parse);
1143 if (ret != FILEINFO_ERROR_NONE) {
1144 debug_error("failed to get stream info: %s\n", filename);
1146 if (parse.audio_track_num == 0 && parse.video_track_num == 0) {
1147 debug_error("empty header. retry to get stream info: %s\n", filename);
1148 parse.type = MM_FILE_PARSE_TYPE_NORMAL;
1149 ret = _get_contents_info(NULL, &src, &parse);
1153 /*set number of each stream*/
1154 *audio_stream_num = parse.audio_track_num;
1155 *video_stream_num = parse.video_track_num;
1158 #ifdef __MMFILE_DYN_LOADING__
1159 _unload_dynamic_functions(&func_handle);
1162 #ifdef __MMFILE_TEST_MODE__
1170 int mm_file_create_content_attrs_simple(MMHandleType *contents_attrs, const char *filename)
1172 mmf_attrs_t *attrs = NULL;
1173 MMFileSourceType src = {0, };
1174 MMFILE_PARSE_INFO parse = {0, };
1177 #ifdef __MMFILE_TEST_MODE__
1181 #ifdef __MMFILE_DYN_LOADING__
1182 MMFILE_FUNC_HANDLE func_handle;
1184 ret = _load_dynamic_functions(&func_handle);
1186 debug_error("load library error\n");
1187 return FILEINFO_ERROR_FILE_INTERNAL;
1190 if (filename == NULL) {
1191 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1194 if (strlen(filename) == 0) {
1195 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1200 /*set source file infomation*/
1201 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1203 ret = _is_file_exist(filename);
1205 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
1210 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
1212 debug_error("attribute internal error.\n");
1213 ret = FILEINFO_ERROR_FILE_INTERNAL;
1217 parse.type = MM_FILE_PARSE_TYPE_NORMAL;
1218 ret = _get_contents_info(attrs, &src, &parse);
1219 if (ret != FILEINFO_ERROR_NONE) {
1220 mmf_attrs_free((MMHandleType)attrs);
1222 debug_error("failed to get contents: %s\n", filename);
1225 *contents_attrs = (MMHandleType) attrs;
1228 #ifdef __MMFILE_DYN_LOADING__
1229 _unload_dynamic_functions(&func_handle);
1232 #ifdef __MMFILE_TEST_MODE__
1240 int mm_file_create_content_attrs_safe(MMHandleType *contents_attrs, const char *filename)
1242 mmf_attrs_t *attrs = NULL;
1243 MMFileSourceType src = {0, };
1244 MMFILE_PARSE_INFO parse = {0, };
1247 #ifdef __MMFILE_TEST_MODE__
1251 #ifdef __MMFILE_DYN_LOADING__
1252 MMFILE_FUNC_HANDLE func_handle;
1254 ret = _load_dynamic_functions(&func_handle);
1256 debug_error("load library error\n");
1257 return FILEINFO_ERROR_FILE_INTERNAL;
1260 if (filename == NULL) {
1261 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1264 if (strlen(filename) == 0) {
1265 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1270 /*set source file infomation*/
1271 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1273 ret = _is_file_exist(filename);
1275 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
1280 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
1282 debug_error("attribute internal error.\n");
1283 ret = FILEINFO_ERROR_FILE_INTERNAL;
1287 parse.type = MM_FILE_PARSE_TYPE_SAFE;
1288 ret = _get_contents_info(attrs, &src, &parse);
1289 if (ret != FILEINFO_ERROR_NONE) {
1290 mmf_attrs_free((MMHandleType)attrs);
1292 debug_error("failed to get contents: %s\n", filename);
1295 *contents_attrs = (MMHandleType) attrs;
1298 #ifdef __MMFILE_DYN_LOADING__
1299 _unload_dynamic_functions(&func_handle);
1302 #ifdef __MMFILE_TEST_MODE__
1310 int mm_file_get_video_frame(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
1313 void *formatFuncHandle = NULL;
1316 debug_error("Invalid arguments [Path is Null]\n");
1317 return FILEINFO_ERROR_INVALID_ARGUMENT;
1320 #ifdef __MMFILE_DYN_LOADING__
1321 /* Get from function argument */
1322 formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
1323 if (!formatFuncHandle) {
1324 debug_error("error : dlopen");
1328 mmfile_format_get_frame = dlsym(formatFuncHandle, "mmfile_format_get_frame");
1329 if (!mmfile_format_get_frame) {
1330 debug_error("error : load library");
1335 #ifdef __MMFILE_TEST_MODE__
1336 debug_msg("file path [%s] is_accurate [%d]", path, is_accurate);
1339 ret = mmfile_format_get_frame(path, timestamp, is_accurate, frame, size, width, height);
1340 if (ret == MMFILE_FORMAT_FAIL) {
1341 debug_error("error : get frame");
1345 if (formatFuncHandle) dlclose(formatFuncHandle);
1347 return FILEINFO_ERROR_NONE;
1350 if (formatFuncHandle) dlclose(formatFuncHandle);
1352 return FILEINFO_ERROR_FILE_INTERNAL;
1356 int mm_file_get_video_frame_from_memory(const void *data, unsigned int datasize, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
1359 void *formatFuncHandle = NULL;
1362 debug_error("Invalid arguments [data is Null]\n");
1363 return FILEINFO_ERROR_INVALID_ARGUMENT;
1366 if (datasize == 0) {
1367 debug_error("Invalid arguments [datasize is zero]\n");
1368 return FILEINFO_ERROR_INVALID_ARGUMENT;
1371 #ifdef __MMFILE_DYN_LOADING__
1372 /* Get from function argument */
1373 formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
1374 if (!formatFuncHandle) {
1375 debug_error("error : dlopen");
1379 mmfile_format_get_frame_from_memory = dlsym(formatFuncHandle, "mmfile_format_get_frame_from_memory");
1380 if (!mmfile_format_get_frame_from_memory) {
1381 debug_error("error : load library");
1386 #ifdef __MMFILE_TEST_MODE__
1387 debug_msg("data [%p], data_size[%d], is_accurate [%d]", data, datasize, is_accurate);
1390 ret = mmfile_format_get_frame_from_memory(data, datasize, timestamp, is_accurate, frame, size, width, height);
1391 if (ret == MMFILE_FORMAT_FAIL) {
1392 debug_error("error : get frame");
1396 if (formatFuncHandle) dlclose(formatFuncHandle);
1398 return FILEINFO_ERROR_NONE;
1401 if (formatFuncHandle) dlclose(formatFuncHandle);
1403 return FILEINFO_ERROR_FILE_INTERNAL;
1407 int mm_file_check_uhqa(const char *filename, bool *is_uhqa)
1409 mmf_attrs_t *attrs = NULL;
1410 MMFileSourceType src = {0, };
1411 MMFILE_PARSE_INFO parse = {0, };
1414 #ifdef __MMFILE_DYN_LOADING__
1415 MMFILE_FUNC_HANDLE func_handle;
1417 ret = _load_dynamic_functions(&func_handle);
1419 debug_error("load library error\n");
1420 return FILEINFO_ERROR_FILE_INTERNAL;
1423 if (filename == NULL) {
1424 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1427 if (strlen(filename) == 0) {
1428 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1433 /*set source file infomation*/
1434 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1436 ret = _is_file_exist(filename);
1438 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
1443 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
1445 debug_error("attribute internal error.\n");
1446 ret = FILEINFO_ERROR_FILE_INTERNAL;
1450 parse.type = MM_FILE_PARSE_TYPE_NORMAL;
1451 ret = _get_contents_info(attrs, &src, &parse);
1452 if (ret == FILEINFO_ERROR_NONE) {
1453 *is_uhqa = parse.is_uhqa;
1455 debug_error("_get_contents_info failed\n");
1459 mmf_attrs_free((MMHandleType)attrs);
1463 #ifdef __MMFILE_DYN_LOADING__
1464 _unload_dynamic_functions(&func_handle);
1467 #ifdef __MMFILE_TEST_MODE__