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},
127 {(char *)"tag-spherical", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
128 {(char *)"tag-stitched", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
129 {(char *)"tag-stitching-software", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
130 {(char *)"tag-projection-type", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
131 {(char *)"tag-stereo-mode", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
132 {(char *)"tag-source-count", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
133 {(char *)"tag-init-view-heading", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
134 {(char *)"tag-init-view-pitch", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
135 {(char *)"tag-init-view-roll", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
136 {(char *)"tag-timestamp", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
137 {(char *)"tag-full-pano-width", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
138 {(char *)"tag-full-pano-height", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
139 {(char *)"tag-cropped-area-image-width", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
140 {(char *)"tag-cropped-area-image-height", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
141 {(char *)"tag-cropped-area-left", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
142 {(char *)"tag-cropped-area-top", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
143 {(char *)"tag-ambisonic-type", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
144 {(char *)"tag-ambisonic-format", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
145 {(char *)"tag-ambisonic-order", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
146 {(char *)"stereo-mode-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
147 {(char *)"metadata-source-v2", MMF_VALUE_TYPE_STRING, MM_ATTRS_FLAG_RW, (void *)NULL},
148 {(char *)"proj-type-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
149 {(char *)"pose-yaw-degrees-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
150 {(char *)"pose-pitch-degrees-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
151 {(char *)"pose-roll-degrees-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
152 {(char *)"cbmp-layout-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
153 {(char *)"cbmp-padding-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
154 {(char *)"equi-projection-bounds-top-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
155 {(char *)"equi-projection-bounds-bottom-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
156 {(char *)"equi-projection-bounds-left-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
157 {(char *)"equi-projection-bounds-right-v2", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
160 static mmf_attrs_construct_info_t g_content_attrs[] = {
161 {(char *)"content-duration", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
162 {(char *)"content-video-codec", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
163 {(char *)"content-video-format", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
164 {(char *)"content-video-bitrate", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
165 {(char *)"content-video-fps", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
166 {(char *)"content-video-width", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
167 {(char *)"content-video-height", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
168 {(char *)"content-video-thumbnail", MMF_VALUE_TYPE_DATA, MM_ATTRS_FLAG_RW, (void *)NULL},
169 {(char *)"content-video-track-index", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
170 {(char *)"content-video-track-count", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
171 {(char *)"content-audio-codec", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
172 {(char *)"content-audio-bitrate", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
173 {(char *)"content-audio-channels", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
174 {(char *)"content-audio-samplerate", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
175 {(char *)"content-audio-track-index", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
176 {(char *)"content-audio-track-count", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
177 {(char *)"content-audio-bitpersample", MMF_VALUE_TYPE_INT, MM_ATTRS_FLAG_RW, (void *)0},
180 #ifdef __MMFILE_DYN_LOADING__
181 #define MMFILE_FORMAT_SO_FILE_NAME LIBDIR"/libmmfile_formats.so"
182 #define MMFILE_CODEC_SO_FILE_NAME LIBDIR"/libmmfile_codecs.so"
184 int (*mmfile_format_open)(MMFileFormatContext **formatContext, MMFileSourceType *fileSrc);
185 int (*mmfile_format_read_stream)(MMFileFormatContext *formatContext);
186 int (*mmfile_format_read_frame)(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
187 int (*mmfile_format_read_tag)(MMFileFormatContext *formatContext);
188 int (*mmfile_format_close)(MMFileFormatContext *formatContext);
189 int (*mmfile_codec_open)(MMFileCodecContext **codecContext, int codecType, int codecId, MMFileCodecFrame *input);
190 int (*mmfile_codec_decode)(MMFileCodecContext *codecContext, MMFileCodecFrame *output);
191 int (*mmfile_codec_close)(MMFileCodecContext *codecContext);
192 int (*mmfile_format_get_frame)(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
193 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);
196 #ifdef __MMFILE_DYN_LOADING__
197 static int _load_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
199 /* static int dll_func_initialized = 0; //disabled */
203 /* Get from function argument */
204 void *formatFuncHandle = NULL;
205 void *codecFuncHandle = NULL;
208 if (dll_func_initialized) {
213 formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
214 if (!formatFuncHandle) {
215 debug_error(DEBUG, "error: %s\n", "libmmfile_formats.so open error");
220 mmfile_format_open = dlsym(formatFuncHandle, "mmfile_format_open");
221 mmfile_format_read_stream = dlsym(formatFuncHandle, "mmfile_format_read_stream");
222 mmfile_format_read_frame = dlsym(formatFuncHandle, "mmfile_format_read_frame");
223 mmfile_format_read_tag = dlsym(formatFuncHandle, "mmfile_format_read_tag");
224 mmfile_format_close = dlsym(formatFuncHandle, "mmfile_format_close");
226 if (!mmfile_format_open ||
227 !mmfile_format_read_stream ||
228 !mmfile_format_read_frame ||
229 !mmfile_format_read_tag ||
230 !mmfile_format_close) {
232 debug_error(DEBUG, "error: %s\n", "format function load error");
237 /*closed at app termination.*/
238 /*dlclose (formatFuncHandle); */
240 codecFuncHandle = dlopen(MMFILE_CODEC_SO_FILE_NAME, RTLD_LAZY | RTLD_GLOBAL);
241 if (!codecFuncHandle) {
242 debug_error(DEBUG, "error: %s\n", "libmmfile_codecs.so open error");
247 mmfile_codec_open = dlsym(codecFuncHandle, "mmfile_codec_open");
248 mmfile_codec_decode = dlsym(codecFuncHandle, "mmfile_codec_decode");
249 mmfile_codec_close = dlsym(codecFuncHandle, "mmfile_codec_close");
251 if (!mmfile_codec_open || !mmfile_codec_decode || !mmfile_codec_close) {
252 debug_error(DEBUG, "error: %s\n", "codec function load error");
257 /*closed at app termination.*/
258 /*dlclose (codecFuncHandle); */
260 /* dll_func_initialized = 1; // disabled */
262 pHandle->codecFuncHandle = codecFuncHandle;
263 pHandle->formatFuncHandle = formatFuncHandle;
268 if (formatFuncHandle) dlclose(formatFuncHandle);
269 if (codecFuncHandle) dlclose(codecFuncHandle);
274 static void _unload_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
276 debug_fenter(RELEASE);
278 if (pHandle->formatFuncHandle) {
279 dlclose(pHandle->formatFuncHandle);
281 if (pHandle->codecFuncHandle) {
282 dlclose(pHandle->codecFuncHandle);
285 debug_fleave(RELEASE);
289 #endif /* __MMFILE_DYN_LOADING__ */
295 _is_file_exist(const char *filename)
299 const char *to_access = (strstr(filename, "file://") != NULL) ? filename + 7 : filename;
300 ret = access(to_access, R_OK);
302 debug_error(DEBUG, "file [%s] not found.\n", to_access);
309 _info_set_attr_media(mmf_attrs_t *attrs, MMFileFormatContext *formatContext)
312 MMHandleType hattrs = CAST_MM_HANDLE(attrs);
314 if (formatContext->commandType == MM_FILE_TAG) {
315 if (formatContext->title) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_TITLE, formatContext->title);
316 if (formatContext->artist) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ARTIST, formatContext->artist);
317 if (formatContext->author) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_AUTHOR, formatContext->author);
318 if (formatContext->composer && formatContext->author == NULL)
319 mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_AUTHOR, formatContext->composer);
320 if (formatContext->album) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ALBUM, formatContext->album);
321 if (formatContext->album_artist) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ALBUM_ARTIST, formatContext->album_artist);
322 if (formatContext->copyright) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_COPYRIGHT, formatContext->copyright);
323 if (formatContext->description) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_DESCRIPTION, formatContext->description);
324 if (formatContext->comment) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_COMMENT, formatContext->comment);
325 if (formatContext->genre) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_GENRE, formatContext->genre);
326 if (formatContext->classification) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_CLASSIFICATION, formatContext->classification);
327 if (formatContext->year) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_DATE, formatContext->year);
328 if (formatContext->tagTrackNum) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_TRACK_NUM, formatContext->tagTrackNum);
329 if (formatContext->rating) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_RATING, formatContext->rating);
330 if (formatContext->conductor) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_CONDUCTOR, formatContext->conductor);
331 if (formatContext->recDate) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_RECDATE, formatContext->recDate);
332 if (formatContext->rotate) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ROTATE, formatContext->rotate);
333 mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_LONGITUDE, formatContext->longitude);
334 mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_LATIDUE, formatContext->latitude);
335 mm_attrs_set_double_by_name(hattrs, MM_FILE_TAG_ALTIDUE, formatContext->altitude);
336 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SYNCLYRICS_NUM, formatContext->syncLyricsNum);
337 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_CDIS, formatContext->cdis);
338 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SMTA, formatContext->smta);
340 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL, formatContext->isSpherical);
341 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_STITCHED, formatContext->isStitched);
342 if (formatContext->stitchingSoftware) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_SPHERICAL_STITCHING_SOFTWARE, formatContext->stitchingSoftware);
343 if (formatContext->projectionType) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_SPHERICAL_PROJECTION_TYPE, formatContext->projectionType);
344 if (formatContext->stereoMode) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_SPHERICAL_STEREO_MODE, formatContext->stereoMode);
345 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_SOURCE_COUNT, formatContext->sourceCount);
346 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_INIT_VIEW_HEADING, formatContext->initViewHeading);
347 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_INIT_VIEW_PITCH, formatContext->initViewPitch);
348 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_INIT_VIEW_ROLL, formatContext->initViewRoll);
349 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_TIMESTAMP, formatContext->timestamp);
350 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_FULL_PANO_WIDTH, formatContext->fullPanoWidth);
351 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_FULL_PANO_HEIGHT, formatContext->fullPanoHeight);
352 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_WIDTH, formatContext->croppedAreaImageWidth);
353 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_HEIGHT, formatContext->croppedAreaImageHeight);
354 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_LEFT, formatContext->croppedAreaLeft);
355 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_TOP, formatContext->croppedAreaTop);
357 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_AMBISONIC_TYPE, formatContext->ambisonicType);
358 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_AMBISONIC_FORMAT, formatContext->ambisonicFormat);
359 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_AMBISONIC_ORDER, formatContext->ambisonicOrder);
361 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_STEREO_MODE, formatContext->stereoModeV2);
362 if (formatContext->metadataSourceV2) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_METADATA_SOURCE, formatContext->metadataSourceV2);
363 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_PROJ_TYPE, formatContext->projTypeV2);
364 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_POSE_YAW, formatContext->poseYawV2);
365 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_POSE_PITCH, formatContext->posePitchV2);
366 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_POSE_ROLL, formatContext->poseRollV2);
367 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_CBMP_LAYOUT, formatContext->cbmpLayoutV2);
368 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_CBMP_PADDING, formatContext->cbmpPaddingV2);
369 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_TOP, formatContext->equiBoundsTopV2);
370 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_BOTTOM, formatContext->equiBoundsBottomV2);
371 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_LEFT, formatContext->equiBoundsLeftV2);
372 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_RIGHT, formatContext->equiBoundsRightV2);
374 if ((formatContext->syncLyricsNum > 0) && (formatContext->syncLyrics))
375 mm_attrs_set_data_by_name(hattrs, MM_FILE_TAG_SYNCLYRICS, formatContext->syncLyrics, formatContext->syncLyricsNum);
377 if (formatContext->unsyncLyrics) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_UNSYNCLYRICS, formatContext->unsyncLyrics);
379 if (formatContext->artwork && formatContext->artworkSize > 0) {
380 void *artworkCopy = NULL;
381 artworkCopy = mmfile_malloc((formatContext->artworkSize));
382 if (NULL != artworkCopy) {
383 memcpy(artworkCopy, formatContext->artwork, formatContext->artworkSize);
384 mm_attrs_set_data_by_name(hattrs, MM_FILE_TAG_ARTWORK, artworkCopy, formatContext->artworkSize);
385 mm_attrs_set_int_by_name(hattrs, MM_FILE_TAG_ARTWORK_SIZE, formatContext->artworkSize);
386 if (formatContext->artworkMime) mm_attrs_set_string_by_name(hattrs, MM_FILE_TAG_ARTWORK_MIME, formatContext->artworkMime);
389 } else if (formatContext->commandType == MM_FILE_CONTENTS) {
391 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_DURATION, formatContext->duration);
392 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_TRACK_COUNT, formatContext->audioTotalTrackNum);
393 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_TRACK_COUNT, formatContext->videoTotalTrackNum);
395 if (formatContext->videoTotalTrackNum > 0 &&
396 formatContext->nbStreams > 0 &&
397 formatContext->streams[MMFILE_VIDEO_STREAM]) {
399 MMFileFormatStream *videoStream = formatContext->streams[MMFILE_VIDEO_STREAM];
401 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_FORMAT, formatContext->formatType);
402 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_CODEC, videoStream->codecId);
403 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_BITRATE, videoStream->bitRate);
404 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_FPS, videoStream->framePerSec);
405 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_WIDTH, videoStream->width);
406 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_HEIGHT, videoStream->height);
408 if (formatContext->thumbNail && formatContext->thumbNail->frameData) {
409 void *thumbNailCopy = NULL;
410 thumbNailCopy = mmfile_malloc(formatContext->thumbNail->frameSize);
412 if (NULL != thumbNailCopy) {
413 memcpy(thumbNailCopy, formatContext->thumbNail->frameData, formatContext->thumbNail->frameSize);
414 mm_attrs_set_data_by_name(hattrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, thumbNailCopy, formatContext->thumbNail->frameSize);
415 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_WIDTH, formatContext->thumbNail->frameWidth);
416 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_VIDEO_HEIGHT, formatContext->thumbNail->frameHeight);
421 if (formatContext->audioTotalTrackNum > 0 &&
422 formatContext->nbStreams > 0 &&
423 formatContext->streams[MMFILE_AUDIO_STREAM]) {
425 MMFileFormatStream *audioStream = formatContext->streams[MMFILE_AUDIO_STREAM];
427 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_CODEC, audioStream->codecId);
428 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_CHANNELS, audioStream->nbChannel);
429 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_BITRATE, audioStream->bitRate);
430 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_SAMPLERATE, audioStream->samplePerSec);
431 mm_attrs_set_int_by_name(hattrs, MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, audioStream->bitPerSample);
438 mmf_attrs_commit((MMHandleType)hattrs);
444 _get_contents_info(mmf_attrs_t *attrs, MMFileSourceType *src, MMFILE_PARSE_INFO *parse)
446 MMFileFormatContext *formatContext = NULL;
447 MMFileCodecContext *codecContext = NULL;
448 MMFileFormatFrame frameContext = {0, };
449 MMFileCodecFrame codecFrame = {0, };
450 MMFileCodecFrame decodedFrame = {0, };
455 return FILEINFO_ERROR_FILE_INTERNAL;
457 ret = mmfile_format_open(&formatContext, src);
458 if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
459 debug_error(DEBUG, "error: mmfile_format_open\n");
460 ret = FILEINFO_ERROR_FILE_INTERNAL;
464 if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL) {
465 if (parse->type == MM_FILE_PARSE_TYPE_SAFE)
466 formatContext->cdis = 1;
467 ret = mmfile_format_read_stream(formatContext);
468 if (MMFILE_FORMAT_FAIL == ret) {
469 debug_error(DEBUG, "error: mmfile_format_read_stream\n");
470 ret = FILEINFO_ERROR_FILE_INTERNAL;
474 parse->audio_track_num = formatContext->audioTotalTrackNum;
475 parse->video_track_num = formatContext->videoTotalTrackNum;
477 /* check uhqa content*/
478 if (formatContext->streams[MMFILE_AUDIO_STREAM] != NULL) {
479 parse->is_uhqa = formatContext->streams[MMFILE_AUDIO_STREAM]->is_uhqa;
481 parse->is_uhqa = FALSE;
484 if (parse->type >= MM_FILE_PARSE_TYPE_ALL) {
485 if (formatContext->videoTotalTrackNum > 0) {
487 /*why below code needed?
488 This API is for extracting some attributes not metadata(TAG). mm_file_create_content_attrs() use this API.
489 but MMFileUtilGetMetaDataFromMP4() Extract just TAG info. That is needed for mm_file_create_tag_attrs()*/
491 if (parse->type != MM_FILE_PARSE_TYPE_SAFE) {
492 if (formatContext->formatType == MM_FILE_FORMAT_3GP || formatContext->formatType == MM_FILE_FORMAT_MP4) {
493 MMFileUtilGetMetaDataFromMP4(formatContext);
497 MMFileFormatStream *videoStream = formatContext->streams[MMFILE_VIDEO_STREAM];
498 unsigned int timestamp = _SEEK_POINT_;
500 ret = mmfile_format_read_frame(formatContext, timestamp, &frameContext);
501 if (MMFILE_FORMAT_FAIL == ret) {
502 debug_error(DEBUG, "error: mmfile_format_read_frame\n");
503 ret = FILEINFO_ERROR_FILE_INTERNAL;
507 if (frameContext.bCompressed) {
508 codecFrame.frameDataSize = frameContext.frameSize;
509 codecFrame.width = frameContext.frameWidth;
510 codecFrame.height = frameContext.frameHeight;
511 codecFrame.frameData = frameContext.frameData;
512 codecFrame.configLen = frameContext.configLenth;
513 codecFrame.configData = frameContext.configData;
514 codecFrame.version = videoStream->version;
516 ret = mmfile_codec_open(&codecContext, MMFILE_VIDEO_DECODE, videoStream->codecId, &codecFrame);
517 if (MMFILE_FORMAT_FAIL == ret) {
518 debug_error(DEBUG, "error: mmfile_codec_open\n");
519 ret = FILEINFO_ERROR_FILE_INTERNAL;
523 ret = mmfile_codec_decode(codecContext, &decodedFrame);
524 if (MMFILE_FORMAT_FAIL == ret) {
525 debug_error(DEBUG, "error: mmfile_codec_decode\n");
526 ret = FILEINFO_ERROR_FILE_INTERNAL;
530 /* set video thumbnail */
531 formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
532 if (NULL == formatContext->thumbNail) {
533 debug_error(DEBUG, "error: mmfile_malloc\n");
534 ret = FILEINFO_ERROR_FILE_INTERNAL;
538 formatContext->thumbNail->frameSize = decodedFrame.frameDataSize;
539 formatContext->thumbNail->frameWidth = decodedFrame.width;
540 formatContext->thumbNail->frameHeight = decodedFrame.height;
541 formatContext->thumbNail->frameData = decodedFrame.frameData;
542 formatContext->thumbNail->configLenth = 0;
543 formatContext->thumbNail->configData = NULL;
545 formatContext->thumbNail = mmfile_malloc(sizeof(MMFileFormatFrame));
546 if (NULL == formatContext->thumbNail) {
547 debug_error(DEBUG, "error: mmfile_format_read_frame\n");
548 ret = FILEINFO_ERROR_FILE_INTERNAL;
552 formatContext->thumbNail->frameSize = frameContext.frameSize;
553 formatContext->thumbNail->frameWidth = frameContext.frameWidth;
554 formatContext->thumbNail->frameHeight = frameContext.frameHeight;
555 formatContext->thumbNail->frameData = frameContext.frameData;
556 formatContext->thumbNail->configLenth = 0;
557 formatContext->thumbNail->configData = NULL;
563 * if MM_FILE_PARSE_TYPE_SIMPLE, just get number of each stream.
565 parse->audio_track_num = formatContext->audioTotalTrackNum;
566 parse->video_track_num = formatContext->videoTotalTrackNum;
569 #ifdef __MMFILE_TEST_MODE__
570 mmfile_format_print_frame(&frameContext);
573 formatContext->commandType = MM_FILE_CONTENTS;
575 if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
576 _info_set_attr_media(attrs, formatContext);
578 if (frameContext.bCompressed) {
579 mmfile_free(frameContext.frameData);
580 mmfile_free(frameContext.configData);
582 if (decodedFrame.frameData) {
583 mmfile_free(decodedFrame.frameData);
584 formatContext->thumbNail->frameData = NULL;
586 if (decodedFrame.configData) {
587 mmfile_free(decodedFrame.configData);
588 formatContext->thumbNail->configData = NULL;
591 if (frameContext.frameData) {
592 mmfile_free(frameContext.frameData);
593 formatContext->thumbNail->frameData = NULL;
595 if (frameContext.configData) {
596 mmfile_free(frameContext.configData);
597 formatContext->thumbNail->configData = NULL;
602 mmfile_format_close(formatContext);
605 mmfile_codec_close(codecContext);
608 return FILEINFO_ERROR_NONE;
611 formatContext->commandType = MM_FILE_CONTENTS;
613 if (frameContext.bCompressed) {
614 mmfile_free(frameContext.frameData);
615 mmfile_free(frameContext.configData);
617 if (decodedFrame.frameData) {
618 mmfile_free(decodedFrame.frameData);
619 if (formatContext->thumbNail)
620 formatContext->thumbNail->frameData = NULL;
623 if (decodedFrame.configData) {
624 mmfile_free(decodedFrame.configData);
625 if (formatContext->thumbNail)
626 formatContext->thumbNail->configData = NULL;
629 if (frameContext.frameData) {
630 mmfile_free(frameContext.frameData);
631 if (formatContext->thumbNail)
632 formatContext->thumbNail->frameData = NULL;
635 if (frameContext.configData) {
636 mmfile_free(frameContext.configData);
637 if (formatContext->thumbNail)
638 formatContext->thumbNail->configData = NULL;
642 if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
643 _info_set_attr_media(attrs, formatContext);
646 mmfile_format_close(formatContext);
649 mmfile_codec_close(codecContext);
651 return FILEINFO_ERROR_NONE;
655 if (frameContext.bCompressed) {
656 mmfile_free(frameContext.frameData);
657 mmfile_free(frameContext.configData);
659 if (decodedFrame.frameData) {
660 mmfile_free(decodedFrame.frameData);
661 if (formatContext->thumbNail)
662 formatContext->thumbNail->frameData = NULL;
665 if (decodedFrame.configData) {
666 mmfile_free(decodedFrame.configData);
667 if (formatContext->thumbNail)
668 formatContext->thumbNail->configData = NULL;
671 if (frameContext.frameData) {
672 mmfile_free(frameContext.frameData);
673 if (formatContext->thumbNail)
674 formatContext->thumbNail->frameData = NULL;
677 if (frameContext.configData) {
678 mmfile_free(frameContext.configData);
679 if (formatContext->thumbNail)
680 formatContext->thumbNail->configData = NULL;
685 mmfile_format_close(formatContext);
687 /* if (codecContext) { mmfile_codec_close(codecContext); } */ /*dead code*/
694 _get_tag_info(mmf_attrs_t *attrs, MMFileSourceType *src)
696 MMFileFormatContext *formatContext = NULL;
699 ret = mmfile_format_open(&formatContext, src);
700 if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
701 debug_error(DEBUG, "error: mmfile_format_open\n");
702 ret = FILEINFO_ERROR_FILE_INTERNAL;
706 ret = mmfile_format_read_tag(formatContext);
707 if (MMFILE_FORMAT_FAIL == ret) {
708 debug_warning(DEBUG, "reading tag is fail\n");
709 ret = FILEINFO_ERROR_FILE_INTERNAL;
713 formatContext->commandType = MM_FILE_TAG;
715 _info_set_attr_media(attrs, formatContext);
718 mmfile_format_close(formatContext);
721 return FILEINFO_ERROR_NONE;
726 mmfile_format_close(formatContext);
729 return FILEINFO_ERROR_FILE_INTERNAL;
736 int mm_file_get_attrs(MMHandleType attrs, char **err_attr_name, const char *first_attribute_name, ...)
738 int ret = FILEINFO_ERROR_NONE;
742 debug_error(DEBUG, "Invalid arguments [attrs 0]\n");
743 return FILEINFO_ERROR_INVALID_ARGUMENT;
746 if (first_attribute_name == NULL) {
747 debug_error(DEBUG, "Invalid arguments [first_attribute_name null]\n");
748 return FILEINFO_ERROR_INVALID_ARGUMENT;
751 /* get requested attributes */
752 va_start(var_args, first_attribute_name);
753 ret = mm_attrs_get_valist(attrs, err_attr_name, first_attribute_name, var_args);
756 if (ret != FILEINFO_ERROR_NONE) {
758 debug_error(DEBUG, "failed to get %s\n", *err_attr_name);
765 int mm_file_get_synclyrics_info(MMHandleType tag_attrs, int index, unsigned long *time_info, char **lyrics)
767 int ret = FILEINFO_ERROR_NONE;
768 AvSynclyricsInfo *sync_lyric_item = NULL;
769 GList *synclyrics_list = NULL;
771 debug_fenter(RELEASE);
773 if ((mmf_attrs_t *)tag_attrs == NULL) {
774 debug_error(DEBUG, "invalid handle");
775 return FILEINFO_ERROR_INVALID_ARGUMENT;
778 ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
779 if (ret != FILEINFO_ERROR_NONE) {
780 debug_warning(RELEASE, "get data fail");
784 if (synclyrics_list != NULL) {
786 sync_lyric_item = (AvSynclyricsInfo *)g_list_nth_data(synclyrics_list, index);
788 if (sync_lyric_item == NULL) {
789 debug_warning(RELEASE, "synclyric item is NULL");
790 return FILEINFO_ERROR_ATTR_NOT_EXIST;
793 *time_info = sync_lyric_item->time_info;
794 *lyrics = sync_lyric_item->lyric_info;
797 debug_warning(RELEASE, "synclyrics_list is NULL");
798 return FILEINFO_ERROR_ATTR_NOT_EXIST;
805 int mm_file_create_tag_attrs(MMHandleType *tag_attrs, const char *filename)
807 int ret = FILEINFO_ERROR_NONE;
808 mmf_attrs_t *attrs = NULL;
809 MMFileSourceType src;
811 debug_fenter(RELEASE);
813 /* Check argument here */
814 if (tag_attrs == NULL) {
815 debug_error(DEBUG, "Invalid arguments [tag null]\n");
816 return FILEINFO_ERROR_INVALID_ARGUMENT;
818 if (filename == NULL) {
819 debug_error(DEBUG, "Invalid arguments [filename null]\n");
820 return FILEINFO_ERROR_INVALID_ARGUMENT;
822 if (strlen(filename) == 0) {
823 debug_error(DEBUG, "Invalid arguments [filename size 0]\n");
824 return FILEINFO_ERROR_INVALID_ARGUMENT;
828 #ifdef __MMFILE_DYN_LOADING__
829 MMFILE_FUNC_HANDLE func_handle;
831 ret = _load_dynamic_functions(&func_handle);
833 debug_error(DEBUG, "load library error\n");
834 return FILEINFO_ERROR_FILE_INTERNAL;
838 /*set source file infomation*/
839 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
841 ret = _is_file_exist(filename);
843 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
848 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("tag", g_tag_attrs, ARRAY_SIZE(g_tag_attrs), NULL, NULL);
850 debug_error(DEBUG, "attribute internal error.\n");
851 ret = FILEINFO_ERROR_FILE_INTERNAL;
855 ret = _get_tag_info(attrs, &src);
856 if (ret != FILEINFO_ERROR_NONE) {
857 mmf_attrs_free((MMHandleType)attrs);
859 debug_error(DEBUG, "failed to get tag: %s\n", filename);
862 *tag_attrs = (MMHandleType)attrs;
865 #ifdef __MMFILE_DYN_LOADING__
866 _unload_dynamic_functions(&func_handle);
869 debug_fleave(RELEASE);
876 int mm_file_destroy_tag_attrs(MMHandleType tag_attrs)
878 void *artwork = NULL;
879 GList *synclyrics_list = NULL;
880 int ret = FILEINFO_ERROR_NONE;
882 debug_fenter(RELEASE);
884 if ((mmf_attrs_t *)tag_attrs == NULL) {
885 debug_error(DEBUG, "invalid handle.\n");
886 return FILEINFO_ERROR_INVALID_ARGUMENT;
889 ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_ARTWORK, &artwork);
890 mmfile_free(artwork);
892 ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
893 mm_file_free_synclyrics_list(synclyrics_list);
894 mmf_attrs_free(tag_attrs);
896 debug_fleave(RELEASE);
902 int mm_file_create_content_attrs(MMHandleType *contents_attrs, const char *filename)
904 mmf_attrs_t *attrs = NULL;
905 MMFileSourceType src = {0, };
906 MMFILE_PARSE_INFO parse = {0, };
909 debug_fenter(RELEASE);
911 /* Check argument here */
912 if (contents_attrs == NULL) {
913 debug_error(DEBUG, "Invalid arguments [contents null]\n");
914 return FILEINFO_ERROR_INVALID_ARGUMENT;
916 if (filename == NULL) {
917 debug_error(DEBUG, "Invalid arguments [filename null]\n");
918 return FILEINFO_ERROR_INVALID_ARGUMENT;
920 if (strlen(filename) == 0) {
921 debug_error(DEBUG, "Invalid arguments [filename size 0]\n");
922 return FILEINFO_ERROR_INVALID_ARGUMENT;
926 #ifdef __MMFILE_DYN_LOADING__
927 MMFILE_FUNC_HANDLE func_handle;
934 ret = _load_dynamic_functions(&func_handle);
936 debug_error(DEBUG, "load library error\n");
937 return FILEINFO_ERROR_FILE_INTERNAL;
941 debug_msg(DEBUG, "_load_dynamic_functions() = %lld\n", gettime() - ti);
946 /*set source file infomation*/
947 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
949 ret = _is_file_exist(filename);
951 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
956 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
958 debug_error(DEBUG, "attribute internal error.\n");
959 ret = FILEINFO_ERROR_FILE_INTERNAL;
964 parse.type = MM_FILE_PARSE_TYPE_ALL;
965 ret = _get_contents_info(attrs, &src, &parse);
966 if (ret != FILEINFO_ERROR_NONE) {
967 mmf_attrs_free((MMHandleType)attrs);
969 debug_error(DEBUG, "failed to get contents: %s\n", filename);
972 *contents_attrs = (MMHandleType) attrs;
976 #ifdef __MMFILE_DYN_LOADING__
982 _unload_dynamic_functions(&func_handle);
985 debug_msg(DEBUG, "_unload_dynamic_functions() = %lld\n", gettime() - ti);
990 debug_fleave(RELEASE);
997 int mm_file_create_tag_attrs_from_memory(MMHandleType *tag_attrs, const void *data, unsigned int size, int format)
999 mmf_attrs_t *attrs = NULL;
1000 MMFileSourceType src;
1001 /*MMFILE_PARSE_INFO parse = {0, };*/
1004 debug_fenter(RELEASE);
1006 /* Check argument here */
1007 if (tag_attrs == NULL || data == NULL) {
1008 debug_error(DEBUG, "Invalid arguments\n");
1009 return FILEINFO_ERROR_INVALID_ARGUMENT;
1012 #ifdef __MMFILE_DYN_LOADING__
1013 MMFILE_FUNC_HANDLE func_handle;
1015 ret = _load_dynamic_functions(&func_handle);
1017 debug_error(DEBUG, "load library error\n");
1018 return FILEINFO_ERROR_FILE_INTERNAL;
1022 MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);
1025 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("tag", g_tag_attrs, ARRAY_SIZE(g_tag_attrs), NULL, NULL);
1027 debug_error(DEBUG, "attribute internal error.\n");
1028 ret = FILEINFO_ERROR_FILE_INTERNAL;
1032 /*parse.type = MM_FILE_PARSE_TYPE_ALL;*/
1033 ret = _get_tag_info(attrs, &src);
1034 if (ret != FILEINFO_ERROR_NONE) {
1035 mmf_attrs_free((MMHandleType)attrs);
1037 debug_error(DEBUG, "failed to get tag");
1040 *tag_attrs = (MMHandleType)attrs;
1043 #ifdef __MMFILE_DYN_LOADING__
1044 _unload_dynamic_functions(&func_handle);
1047 debug_fleave(RELEASE);
1054 int mm_file_create_content_attrs_from_memory(MMHandleType *contents_attrs, const void *data, unsigned int size, int format)
1056 mmf_attrs_t *attrs = NULL;
1057 MMFileSourceType src;
1058 MMFILE_PARSE_INFO parse = {0, };
1061 debug_fenter(RELEASE);
1063 /* Check argument here */
1064 if (contents_attrs == NULL || data == NULL) {
1065 debug_error(DEBUG, "Invalid arguments\n");
1066 return FILEINFO_ERROR_INVALID_ARGUMENT;
1069 #ifdef __MMFILE_DYN_LOADING__
1070 MMFILE_FUNC_HANDLE func_handle;
1072 ret = _load_dynamic_functions(&func_handle);
1074 debug_error(DEBUG, "load library error\n");
1075 return FILEINFO_ERROR_FILE_INTERNAL;
1079 MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);
1082 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
1084 debug_error(DEBUG, "attribute internal error.\n");
1085 ret = FILEINFO_ERROR_FILE_INTERNAL;
1089 parse.type = MM_FILE_PARSE_TYPE_ALL;
1090 ret = _get_contents_info(attrs, &src, &parse);
1091 if (ret != FILEINFO_ERROR_NONE) {
1092 mmf_attrs_free((MMHandleType)attrs);
1094 debug_error(DEBUG, "failed to get contents");
1097 *contents_attrs = (MMHandleType)attrs;
1100 #ifdef __MMFILE_DYN_LOADING__
1101 _unload_dynamic_functions(&func_handle);
1104 debug_fleave(RELEASE);
1111 int mm_file_destroy_content_attrs(MMHandleType contents_attrs)
1113 void *thumbnail = NULL;
1114 int ret = FILEINFO_ERROR_NONE;
1116 debug_fenter(RELEASE);
1118 if ((mmf_attrs_t *)contents_attrs == NULL) {
1119 debug_error(DEBUG, "invalid handle.\n");
1120 return FILEINFO_ERROR_INVALID_ARGUMENT;
1123 ret = mm_attrs_get_data_by_name(contents_attrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, &thumbnail);
1124 mmfile_free(thumbnail);
1126 mmf_attrs_free(contents_attrs);
1128 debug_fleave(RELEASE);
1135 int mm_file_get_stream_info(const char *filename, int *audio_stream_num, int *video_stream_num)
1137 MMFileSourceType src = {0, };
1138 MMFILE_PARSE_INFO parse = {0, };
1142 debug_fenter(RELEASE);
1144 if (filename == NULL || strlen(filename) == 0 || audio_stream_num == NULL || video_stream_num == NULL) {
1145 debug_error(DEBUG, "Invalid arguments\n");
1146 return FILEINFO_ERROR_INVALID_ARGUMENT;
1149 #ifdef __MMFILE_DYN_LOADING__
1150 MMFILE_FUNC_HANDLE func_handle;
1152 ret = _load_dynamic_functions(&func_handle);
1154 debug_error(DEBUG, "load library error\n");
1155 return FILEINFO_ERROR_FILE_INTERNAL;
1159 /*set source file infomation*/
1160 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1162 ret = _is_file_exist(filename);
1164 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
1168 parse.type = MM_FILE_PARSE_TYPE_SIMPLE;
1169 ret = _get_contents_info(NULL, &src, &parse);
1170 if (ret != FILEINFO_ERROR_NONE) {
1171 debug_error(DEBUG, "failed to get stream info: %s\n", filename);
1173 if (parse.audio_track_num == 0 && parse.video_track_num == 0) {
1174 debug_error(DEBUG, "empty header. retry to get stream info: %s\n", filename);
1175 parse.type = MM_FILE_PARSE_TYPE_NORMAL;
1176 ret = _get_contents_info(NULL, &src, &parse);
1180 /*set number of each stream*/
1181 *audio_stream_num = parse.audio_track_num;
1182 *video_stream_num = parse.video_track_num;
1185 #ifdef __MMFILE_DYN_LOADING__
1186 _unload_dynamic_functions(&func_handle);
1189 debug_fleave(RELEASE);
1195 int mm_file_create_content_attrs_simple(MMHandleType *contents_attrs, const char *filename)
1197 mmf_attrs_t *attrs = NULL;
1198 MMFileSourceType src = {0, };
1199 MMFILE_PARSE_INFO parse = {0, };
1202 debug_fenter(RELEASE);
1204 #ifdef __MMFILE_DYN_LOADING__
1205 MMFILE_FUNC_HANDLE func_handle;
1207 ret = _load_dynamic_functions(&func_handle);
1209 debug_error(DEBUG, "load library error\n");
1210 return FILEINFO_ERROR_FILE_INTERNAL;
1213 if (filename == NULL) {
1214 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1217 if (strlen(filename) == 0) {
1218 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1223 /*set source file infomation*/
1224 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1226 ret = _is_file_exist(filename);
1228 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
1233 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
1235 debug_error(DEBUG, "attribute internal error.\n");
1236 ret = FILEINFO_ERROR_FILE_INTERNAL;
1240 parse.type = MM_FILE_PARSE_TYPE_NORMAL;
1241 ret = _get_contents_info(attrs, &src, &parse);
1242 if (ret != FILEINFO_ERROR_NONE) {
1243 mmf_attrs_free((MMHandleType)attrs);
1245 debug_error(DEBUG, "failed to get contents: %s\n", filename);
1248 *contents_attrs = (MMHandleType) attrs;
1251 #ifdef __MMFILE_DYN_LOADING__
1252 _unload_dynamic_functions(&func_handle);
1255 debug_fleave(RELEASE);
1261 int mm_file_create_content_attrs_safe(MMHandleType *contents_attrs, const char *filename)
1263 mmf_attrs_t *attrs = NULL;
1264 MMFileSourceType src = {0, };
1265 MMFILE_PARSE_INFO parse = {0, };
1268 debug_fenter(RELEASE);
1270 #ifdef __MMFILE_DYN_LOADING__
1271 MMFILE_FUNC_HANDLE func_handle;
1273 ret = _load_dynamic_functions(&func_handle);
1275 debug_error(DEBUG, "load library error\n");
1276 return FILEINFO_ERROR_FILE_INTERNAL;
1279 if (filename == NULL) {
1280 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1283 if (strlen(filename) == 0) {
1284 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1289 /*set source file infomation*/
1290 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1292 ret = _is_file_exist(filename);
1294 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
1299 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
1301 debug_error(DEBUG, "attribute internal error.\n");
1302 ret = FILEINFO_ERROR_FILE_INTERNAL;
1306 parse.type = MM_FILE_PARSE_TYPE_SAFE;
1307 ret = _get_contents_info(attrs, &src, &parse);
1308 if (ret != FILEINFO_ERROR_NONE) {
1309 mmf_attrs_free((MMHandleType)attrs);
1311 debug_error(DEBUG, "failed to get contents: %s\n", filename);
1314 *contents_attrs = (MMHandleType) attrs;
1317 #ifdef __MMFILE_DYN_LOADING__
1318 _unload_dynamic_functions(&func_handle);
1321 debug_fleave(RELEASE);
1327 int mm_file_get_video_frame(const char *path, double timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
1330 void *formatFuncHandle = NULL;
1333 debug_error(DEBUG, "Invalid arguments [Path is Null]\n");
1334 return FILEINFO_ERROR_INVALID_ARGUMENT;
1337 #ifdef __MMFILE_DYN_LOADING__
1338 /* Get from function argument */
1339 formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
1340 if (!formatFuncHandle) {
1341 debug_error(DEBUG, "error : dlopen");
1345 mmfile_format_get_frame = dlsym(formatFuncHandle, "mmfile_format_get_frame");
1346 if (!mmfile_format_get_frame) {
1347 debug_error(DEBUG, "error : load library");
1352 debug_msg(RELEASE, "file path [%s] is_accurate [%d]", path, is_accurate);
1354 ret = mmfile_format_get_frame(path, timestamp, is_accurate, frame, size, width, height);
1355 if (ret == MMFILE_FORMAT_FAIL) {
1356 debug_error(DEBUG, "error : get frame");
1360 if (formatFuncHandle) dlclose(formatFuncHandle);
1362 return FILEINFO_ERROR_NONE;
1365 if (formatFuncHandle) dlclose(formatFuncHandle);
1367 return FILEINFO_ERROR_FILE_INTERNAL;
1371 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)
1374 void *formatFuncHandle = NULL;
1377 debug_error(DEBUG, "Invalid arguments [data is Null]\n");
1378 return FILEINFO_ERROR_INVALID_ARGUMENT;
1381 if (datasize == 0) {
1382 debug_error(DEBUG, "Invalid arguments [datasize is zero]\n");
1383 return FILEINFO_ERROR_INVALID_ARGUMENT;
1386 #ifdef __MMFILE_DYN_LOADING__
1387 /* Get from function argument */
1388 formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
1389 if (!formatFuncHandle) {
1390 debug_error(DEBUG, "error : dlopen");
1394 mmfile_format_get_frame_from_memory = dlsym(formatFuncHandle, "mmfile_format_get_frame_from_memory");
1395 if (!mmfile_format_get_frame_from_memory) {
1396 debug_error(DEBUG, "error : load library");
1401 debug_msg(RELEASE, "data [%p], data_size[%d], is_accurate [%d]", data, datasize, is_accurate);
1403 ret = mmfile_format_get_frame_from_memory(data, datasize, timestamp, is_accurate, frame, size, width, height);
1404 if (ret == MMFILE_FORMAT_FAIL) {
1405 debug_error(DEBUG, "error : get frame");
1409 if (formatFuncHandle) dlclose(formatFuncHandle);
1411 return FILEINFO_ERROR_NONE;
1414 if (formatFuncHandle) dlclose(formatFuncHandle);
1416 return FILEINFO_ERROR_FILE_INTERNAL;
1420 int mm_file_check_uhqa(const char *filename, bool *is_uhqa)
1422 mmf_attrs_t *attrs = NULL;
1423 MMFileSourceType src = {0, };
1424 MMFILE_PARSE_INFO parse = {0, };
1427 #ifdef __MMFILE_DYN_LOADING__
1428 MMFILE_FUNC_HANDLE func_handle;
1430 ret = _load_dynamic_functions(&func_handle);
1432 debug_error(DEBUG, "load library error\n");
1433 return FILEINFO_ERROR_FILE_INTERNAL;
1436 if (filename == NULL) {
1437 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1440 if (strlen(filename) == 0) {
1441 ret = FILEINFO_ERROR_INVALID_ARGUMENT;
1446 /*set source file infomation*/
1447 MM_FILE_SET_MEDIA_FILE_SRC(src, filename);
1449 ret = _is_file_exist(filename);
1451 ret = FILEINFO_ERROR_FILE_NOT_FOUND;
1456 attrs = (mmf_attrs_t *) mmf_attrs_new_from_data("content", g_content_attrs, ARRAY_SIZE(g_content_attrs), NULL, NULL);
1458 debug_error(DEBUG, "attribute internal error.\n");
1459 ret = FILEINFO_ERROR_FILE_INTERNAL;
1463 parse.type = MM_FILE_PARSE_TYPE_NORMAL;
1464 ret = _get_contents_info(attrs, &src, &parse);
1465 if (ret == FILEINFO_ERROR_NONE) {
1466 *is_uhqa = parse.is_uhqa;
1468 debug_error(DEBUG, "_get_contents_info failed\n");
1472 mmf_attrs_free((MMHandleType)attrs);
1476 #ifdef __MMFILE_DYN_LOADING__
1477 _unload_dynamic_functions(&func_handle);
1480 debug_fleave(RELEASE);