path: root/mm_file.c

/*
 * libmm-fileinfo
 *
 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
 *
 * Contact: Haejeong Kim <backto.kim@samsung.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>	/*for access*/
#include <string.h>	/*for strXXX*/
#include <dlfcn.h>

/* exported MM header files */
#include <mm_file.h>
#include <mm_attrs.h>

/* internal MM File headers */
#include "mm_file_debug.h"
#include "mm_file_formats.h"
#include "mm_file_format_frame.h"
#include "mm_file_utils.h"

/**
 * Defines.
 */

#ifndef ARRAY_SIZE
#define ARRAY_SIZE(arr)		(sizeof(arr) / sizeof((arr)[0]))
#endif

#define _SEEK_POINT_	3000		/*1000 = 1 seconds*/

#define	MM_FILE_TAG_SYNCLYRICS	"tag-synclyrics"	/**< Synchronized Lyrics Information*/


enum {
	MM_FILE_TAG,
	MM_FILE_CONTENTS,
	MM_FILE_INVALID,
};

typedef enum {
	MM_FILE_PARSE_TYPE_SIMPLE,		/*parse audio/video track num only*/
	MM_FILE_PARSE_TYPE_NORMAL,		/*parse infomation without thumbnail*/
	MM_FILE_PARSE_TYPE_ALL,			/*parse all infomation*/
	MM_FILE_PARSE_TYPE_SAFE,		/*parse infomation without both thumbnail and stream full-searching*/
} MMFILE_PARSE_TYPE;

typedef struct {
	int	type;
	int	audio_track_num;
	int	video_track_num;
	bool is_uhqa;
} MMFILE_PARSE_INFO;

typedef struct {
	void *formatFuncHandle;
} MMFILE_FUNC_HANDLE;



/**
 * global values.
 */
static MMAttrsConstructInfo g_tag_attrs[] = {
	{(char *)"tag-artist",			MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-title",			MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-album",			MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-album-artist",	MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-genre",			MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-author",			MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-copyright",		MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-date",			MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-description",		MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-comment",		MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-artwork",		MM_ATTRS_TYPE_DATA,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-artwork-size",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-artwork-mime",	MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-track-num",		MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-classification",	MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-rating",			MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-longitude",		MM_ATTRS_TYPE_DOUBLE,	MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-latitude",		MM_ATTRS_TYPE_DOUBLE,	MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-altitude",		MM_ATTRS_TYPE_DOUBLE,	MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-conductor",		MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-unsynclyrics",	MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-synclyrics-num",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-synclyrics",		MM_ATTRS_TYPE_DATA,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-recdate",		MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-part-of-set",		MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-rotate",			MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-cdis",			MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-smta",			MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-spherical",					MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-stitched",					MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-stitching-software",			MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-projection-type",				MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-stereo-mode",					MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"tag-source-count",				MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-init-view-heading",			MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-init-view-pitch",				MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-init-view-roll",				MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-timestamp",					MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-full-pano-width",				MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-full-pano-height",			MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-cropped-area-image-width",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-cropped-area-image-height",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-cropped-area-left",			MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-cropped-area-top",			MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-ambisonic-type",				MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-ambisonic-format",			MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"tag-ambisonic-order",				MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"stereo-mode-v2",						MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"metadata-source-v2",					MM_ATTRS_TYPE_STRING,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"proj-type-v2",						MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"pose-yaw-degrees-v2",					MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"pose-pitch-degrees-v2",				MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"pose-roll-degrees-v2",				MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"cbmp-layout-v2",						MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"cbmp-padding-v2",						MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"equi-projection-bounds-top-v2",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"equi-projection-bounds-bottom-v2",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"equi-projection-bounds-left-v2",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"equi-projection-bounds-right-v2",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
};

static MMAttrsConstructInfo g_content_attrs[] = {
	{(char *)"content-duration",			MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-video-codec",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-video-format",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-video-bitrate",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-video-fps",			MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-video-width",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-video-height",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-video-thumbnail",		MM_ATTRS_TYPE_DATA,	MM_ATTRS_FLAG_RW, (void *)NULL},
	{(char *)"content-video-track-index",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-video-track-count",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-audio-codec",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-audio-bitrate",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-audio-channels",		MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-audio-samplerate",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-audio-track-index",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-audio-track-count",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
	{(char *)"content-audio-bitpersample",	MM_ATTRS_TYPE_INT,		MM_ATTRS_FLAG_RW, (void *)0},
};

#ifdef __MMFILE_DYN_LOADING__
#define MMFILE_FORMAT_SO_FILE_NAME  LIBDIR"/libmmfile_formats.so"

static int (*mmfile_format_open)(MMFileFormatContext **formatContext, MMFileSourceType *fileSrc);
static int (*mmfile_format_read_stream)(MMFileFormatContext *formatContext);
static int (*mmfile_format_read_frame)(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
static int (*mmfile_format_read_tag)(MMFileFormatContext *formatContext);
static int (*mmfile_format_close)(MMFileFormatContext *formatContext);
static int (*mmfile_format_get_frame)(const char *path, int64_t timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
static int (*mmfile_format_get_frame_from_memory)(const void *data, unsigned int datasize, int64_t timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height);
#endif

#ifdef __MMFILE_DYN_LOADING__
static int _load_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
{
	void *formatFuncHandle = NULL;

	formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
	mm_file_retvm_if_fails(DEBUG, formatFuncHandle, FILEINFO_ERROR_FILE_INTERNAL);

	mmfile_format_open			= dlsym(formatFuncHandle, "mmfile_format_open");
	mmfile_format_read_stream	= dlsym(formatFuncHandle, "mmfile_format_read_stream");
	mmfile_format_read_frame	= dlsym(formatFuncHandle, "mmfile_format_read_frame");
	mmfile_format_read_tag		= dlsym(formatFuncHandle, "mmfile_format_read_tag");
	mmfile_format_close			= dlsym(formatFuncHandle, "mmfile_format_close");

	if (!mmfile_format_open ||
	    !mmfile_format_read_stream ||
	    !mmfile_format_read_frame ||
	    !mmfile_format_read_tag ||
	    !mmfile_format_close) {

		debug_error(DEBUG, "error: %s\n", "format function load error");
		goto exception;
	}

	pHandle->formatFuncHandle = formatFuncHandle;

	return FILEINFO_ERROR_NONE;

exception:
	if (formatFuncHandle)
		dlclose(formatFuncHandle);

	return FILEINFO_ERROR_FILE_INTERNAL;
}

static void _unload_dynamic_functions(MMFILE_FUNC_HANDLE *pHandle)
{
	debug_fenter(RELEASE);

	if (pHandle->formatFuncHandle)
		dlclose(pHandle->formatFuncHandle);

	debug_fleave(RELEASE);
}

#endif /* __MMFILE_DYN_LOADING__ */

/**
 * local functions.
 */
static int _is_file_readable(const char *filename)
{
	mm_file_retvm_if_fails(DEBUG, filename, FILEINFO_ERROR_INVALID_ARGUMENT);

	if (access(filename, R_OK) == -1) {
		if (errno == EACCES || errno == EPERM) {
			debug_error(DEBUG, "Permission denied [%s]", filename);
			return FILEINFO_ERROR_PERMISSION_DENIED;
		} else {
			debug_error(DEBUG, "Not exist file [%s]", filename);
			return FILEINFO_ERROR_FILE_NOT_FOUND;
		}
	}

	return FILEINFO_ERROR_NONE;
}

static int _info_set_attr_media(MMHandleType attrs, MMFileFormatContext *formatContext)
{
	int ret = 0;

	if (formatContext->commandType == MM_FILE_TAG) {
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_TITLE, formatContext->title);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ARTIST, formatContext->artist);
		if (formatContext->author)
			mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_AUTHOR, formatContext->author);
		else
			mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_AUTHOR, formatContext->composer);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ALBUM, formatContext->album);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ALBUM_ARTIST, formatContext->album_artist);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_COPYRIGHT, formatContext->copyright);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_DESCRIPTION, formatContext->description);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_COMMENT, formatContext->comment);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_GENRE, formatContext->genre);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_CLASSIFICATION, formatContext->classification);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_DATE, formatContext->year);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_TRACK_NUM, formatContext->tagTrackNum);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_RATING, formatContext->rating);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_CONDUCTOR, formatContext->conductor);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_RECDATE, formatContext->recDate);

		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ROTATE, formatContext->rotate);
		mm_attrs_set_double_by_name(attrs, MM_FILE_TAG_LONGITUDE, formatContext->longitude);
		mm_attrs_set_double_by_name(attrs, MM_FILE_TAG_LATIDUE, formatContext->latitude);
		mm_attrs_set_double_by_name(attrs, MM_FILE_TAG_ALTIDUE, formatContext->altitude);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SYNCLYRICS_NUM, formatContext->syncLyricsNum);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_CDIS, formatContext->cdis);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SMTA, formatContext->smta);

		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL, formatContext->isSpherical);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_STITCHED, formatContext->isStitched);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_SPHERICAL_STITCHING_SOFTWARE, formatContext->stitchingSoftware);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_SPHERICAL_PROJECTION_TYPE, formatContext->projectionType);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_SPHERICAL_STEREO_MODE, formatContext->stereoMode);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_SOURCE_COUNT, formatContext->sourceCount);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_INIT_VIEW_HEADING, formatContext->initViewHeading);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_INIT_VIEW_PITCH, formatContext->initViewPitch);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_INIT_VIEW_ROLL, formatContext->initViewRoll);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_TIMESTAMP, formatContext->timestamp);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_FULL_PANO_WIDTH, formatContext->fullPanoWidth);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_FULL_PANO_HEIGHT, formatContext->fullPanoHeight);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_WIDTH, formatContext->croppedAreaImageWidth);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_IMAGE_HEIGHT, formatContext->croppedAreaImageHeight);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_LEFT, formatContext->croppedAreaLeft);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_CROPPED_AREA_TOP, formatContext->croppedAreaTop);

		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_AMBISONIC_TYPE, formatContext->ambisonicType);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_AMBISONIC_FORMAT, formatContext->ambisonicFormat);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_AMBISONIC_ORDER, formatContext->ambisonicOrder);

		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_STEREO_MODE, formatContext->stereoModeV2);
		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_METADATA_SOURCE, formatContext->metadataSourceV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_PROJ_TYPE, formatContext->projTypeV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_POSE_YAW, formatContext->poseYawV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_POSE_PITCH, formatContext->posePitchV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_POSE_ROLL, formatContext->poseRollV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_CBMP_LAYOUT, formatContext->cbmpLayoutV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_CBMP_PADDING, formatContext->cbmpPaddingV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_TOP, formatContext->equiBoundsTopV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_BOTTOM, formatContext->equiBoundsBottomV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_LEFT, formatContext->equiBoundsLeftV2);
		mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_SPHERICAL_V2_EQUI_BOUNDS_RIGHT, formatContext->equiBoundsRightV2);

		mm_attrs_set_data_by_name(attrs, MM_FILE_TAG_SYNCLYRICS, formatContext->syncLyrics, formatContext->syncLyricsNum);

		mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_UNSYNCLYRICS, formatContext->unsyncLyrics);

		if (formatContext->artwork && formatContext->artworkSize > 0) {
			void *artworkCopy = g_memdup2(formatContext->artwork, formatContext->artworkSize);

			mm_attrs_set_data_by_name(attrs, MM_FILE_TAG_ARTWORK, artworkCopy, formatContext->artworkSize);
			mm_attrs_set_int_by_name(attrs, MM_FILE_TAG_ARTWORK_SIZE, formatContext->artworkSize);
			mm_attrs_set_string_by_name(attrs, MM_FILE_TAG_ARTWORK_MIME, formatContext->artworkMime);
		}
	} else if (formatContext->commandType == MM_FILE_CONTENTS) {
		/*get duration*/
		mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_DURATION, formatContext->duration);
		mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_TRACK_COUNT, formatContext->audioTotalTrackNum);
		mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_TRACK_COUNT, formatContext->videoTotalTrackNum);

		if (formatContext->videoTotalTrackNum > 0 &&
		    formatContext->nbStreams > 0 &&
		    formatContext->streams[MMFILE_VIDEO_STREAM]) {

			MMFileFormatStream *videoStream = formatContext->streams[MMFILE_VIDEO_STREAM];

			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_FORMAT, formatContext->formatType);
			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_CODEC, videoStream->codecId);
			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_BITRATE, videoStream->bitRate);
			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_FPS, videoStream->framePerSec);
			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_WIDTH, videoStream->width);
			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_HEIGHT, videoStream->height);

			if (formatContext->thumbNail && formatContext->thumbNail->frameData) {
				void *thumbNailCopy = NULL;
				thumbNailCopy = g_memdup2(formatContext->thumbNail->frameData, formatContext->thumbNail->frameSize);

				mm_attrs_set_data_by_name(attrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, thumbNailCopy, formatContext->thumbNail->frameSize);
				mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_WIDTH, formatContext->thumbNail->frameWidth);
				mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_VIDEO_HEIGHT, formatContext->thumbNail->frameHeight);
			}
		}

		if (formatContext->audioTotalTrackNum > 0 &&
		    formatContext->nbStreams > 0 &&
		    formatContext->streams[MMFILE_AUDIO_STREAM]) {

			MMFileFormatStream *audioStream = formatContext->streams[MMFILE_AUDIO_STREAM];

			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_CODEC, audioStream->codecId);
			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_CHANNELS, audioStream->nbChannel);
			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_BITRATE, audioStream->bitRate);
			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_SAMPLERATE, audioStream->samplePerSec);
			mm_attrs_set_int_by_name(attrs, MM_FILE_CONTENT_AUDIO_BITPERSAMPLE, audioStream->bitPerSample);
		}
	} else {
		ret = -1;
	}

	/*commit attrs*/
	mm_attrs_commit_all(attrs);

	return ret;
}

static int
__get_contents_thumbnail(MMFileFormatContext *formatContext)
{
	int ret = FILEINFO_ERROR_NONE;
	MMFileFormatFrame frameContext = {0, };
	MMFileFormatFrame *thumbnail = NULL;

	mm_file_retvm_if_fails(DEBUG, formatContext, FILEINFO_ERROR_FILE_INTERNAL);

	if (MMFILE_FORMAT_FAIL == mmfile_format_read_frame(formatContext, _SEEK_POINT_, &frameContext)) {
		debug_error(DEBUG, "error: mmfile_format_read_frame\n");
		ret = FILEINFO_ERROR_FILE_INTERNAL;
		goto exception;
	}

	/* set video thumbnail */
	thumbnail = g_new0(MMFileFormatFrame, 1);

	thumbnail->frameSize = frameContext.frameSize;
	thumbnail->frameWidth = frameContext.frameWidth;
	thumbnail->frameHeight = frameContext.frameHeight;
	thumbnail->frameData = frameContext.frameData;
	thumbnail->frameDataFree = frameContext.frameDataFree;
	thumbnail->configLenth = 0;
	thumbnail->configData = NULL;

#ifdef __MMFILE_TEST_MODE__
	mmfile_format_print_frame(thumbnail);
#endif

	formatContext->thumbNail = thumbnail;

	/* because #MMFILE_FORMAT_SUCCESS is different with #FILEINFO_ERROR_NONE */
	return FILEINFO_ERROR_NONE;
exception:
	mmfile_free(thumbnail);
	if (frameContext.frameDataFree)
		frameContext.frameDataFree(frameContext.frameData);
	else
		mmfile_free(frameContext.frameData);
	mmfile_free(frameContext.configData);

	return ret;
}

static int
_get_contents_info(MMHandleType attrs, MMFileSourceType *src, MMFILE_PARSE_INFO *parse)
{
	MMFileFormatContext *formatContext = NULL;
	int ret = 0;

	mm_file_retvm_if_fails(DEBUG, src, FILEINFO_ERROR_FILE_INTERNAL);
	mm_file_retvm_if_fails(DEBUG, parse, FILEINFO_ERROR_FILE_INTERNAL);

	if (MMFILE_FORMAT_FAIL == mmfile_format_open(&formatContext, src) || formatContext == NULL) {
		debug_error(DEBUG, "error: mmfile_format_open\n");
		ret = FILEINFO_ERROR_FILE_INTERNAL;
		goto exception;
	}

	if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL) {
		if (parse->type == MM_FILE_PARSE_TYPE_SAFE)
			formatContext->cdis = 1;

		if (MMFILE_FORMAT_FAIL == mmfile_format_read_stream(formatContext)) {
			debug_error(DEBUG, "error: mmfile_format_read_stream\n");
			ret = FILEINFO_ERROR_FILE_INTERNAL;
			goto exception;
		}

		parse->audio_track_num = formatContext->audioTotalTrackNum;
		parse->video_track_num = formatContext->videoTotalTrackNum;

		/* check uhqa content*/
		if (formatContext->streams[MMFILE_AUDIO_STREAM] != NULL)
			parse->is_uhqa = formatContext->streams[MMFILE_AUDIO_STREAM]->is_uhqa;
		else
			parse->is_uhqa = false;

		if (parse->type >= MM_FILE_PARSE_TYPE_ALL && formatContext->videoTotalTrackNum > 0) {
/*why below code needed?
This API is for extracting some attributes not metadata(TAG). mm_file_create_content_attrs() use this API.
but MMFileUtilGetMetaDataFromMP4() Extract just TAG info. That is needed for mm_file_create_tag_attrs()*/
#if 0
			if (parse->type != MM_FILE_PARSE_TYPE_SAFE) {
				if (formatContext->formatType == MM_FILE_FORMAT_3GP || formatContext->formatType == MM_FILE_FORMAT_MP4) {
					MMFileUtilGetMetaDataFromMP4(formatContext);
				}
			}
#endif
			ret = __get_contents_thumbnail(formatContext);
			if (FILEINFO_ERROR_NONE != ret) {
				debug_error(DEBUG, "error: __get_contents_thumbnail\n");
				ret = FILEINFO_ERROR_NONE;
			}
		}
	} else {
		/**
		 * if MM_FILE_PARSE_TYPE_SIMPLE, just get number of each stream.
		 */
		parse->audio_track_num = formatContext->audioTotalTrackNum;
		parse->video_track_num = formatContext->videoTotalTrackNum;
	}

	formatContext->commandType = MM_FILE_CONTENTS;

	if (parse->type >= MM_FILE_PARSE_TYPE_NORMAL)
		_info_set_attr_media(attrs, formatContext);

	if (formatContext->thumbNail) {
		if (formatContext->thumbNail->frameDataFree)
			formatContext->thumbNail->frameDataFree(formatContext->thumbNail->frameData);
		else
			mmfile_free(formatContext->thumbNail->frameData);
		mmfile_free(formatContext->thumbNail->configData);
		mmfile_free(formatContext->thumbNail);
	}

exception:
	if (formatContext)
		mmfile_format_close(formatContext);

	return ret;
}


static int
_get_tag_info(MMHandleType attrs, MMFileSourceType *src, bool extract_albumart)
{
	MMFileFormatContext *formatContext = NULL;
	int ret = 0;

	ret = mmfile_format_open(&formatContext, src);
	if (MMFILE_FORMAT_FAIL == ret || formatContext == NULL) {
		debug_error(DEBUG, "error: mmfile_format_open\n");
		ret = FILEINFO_ERROR_FILE_INTERNAL;
		goto exception;
	}

	/* Set albumart flag */
	formatContext->extract_artwork = extract_albumart;

	ret = mmfile_format_read_tag(formatContext);
	if (MMFILE_FORMAT_FAIL == ret) {
		debug_warning(DEBUG, "reading tag is fail\n");
		ret = FILEINFO_ERROR_FILE_INTERNAL;
		goto exception;
	}

	formatContext->commandType = MM_FILE_TAG;

	_info_set_attr_media(attrs, formatContext);

	if (formatContext)  {
		mmfile_format_close(formatContext);
	}

	return FILEINFO_ERROR_NONE;


exception:
	if (formatContext)  {
		mmfile_format_close(formatContext);
	}

	return FILEINFO_ERROR_FILE_INTERNAL;
}


/**
 * global functions.
 */
int mm_file_get_attrs(MMHandleType attrs, const char *first_attribute_name, ...)
{
	int ret = FILEINFO_ERROR_NONE;
	va_list var_args;
	char *err_attr_name = NULL;

	mm_file_retvm_if_fails(DEBUG, attrs, FILEINFO_ERROR_INVALID_ARGUMENT);
	mm_file_retvm_if_fails(DEBUG, first_attribute_name, FILEINFO_ERROR_INVALID_ARGUMENT);

	/* get requested attributes */
	va_start(var_args, first_attribute_name);
	ret = mm_attrs_get_valist(attrs, &err_attr_name, first_attribute_name, var_args);
	va_end(var_args);

	if (ret != FILEINFO_ERROR_NONE) {
		if (err_attr_name) {
			debug_error(DEBUG, "failed to get %s\n", err_attr_name);
			free(err_attr_name);
		}
	}

	return ret;
}

int mm_file_get_synclyrics_info(MMHandleType tag_attrs, int index, unsigned long *time_info, char **lyrics)
{
	int ret = FILEINFO_ERROR_NONE;
	AvSynclyricsInfo *sync_lyric_item = NULL;
	GList *synclyrics_list = NULL;

	debug_fenter(RELEASE);

	mm_file_retvm_if_fails(DEBUG, tag_attrs, FILEINFO_ERROR_INVALID_ARGUMENT);

	ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
	if (ret != FILEINFO_ERROR_NONE) {
		debug_warning(RELEASE, "get data fail");
		return ret;
	}

	mm_file_retvm_if_fails(RELEASE, synclyrics_list, FILEINFO_ERROR_ATTR_NOT_EXIST);

	sync_lyric_item = (AvSynclyricsInfo *)g_list_nth_data(synclyrics_list, index);

	mm_file_retvm_if_fails(RELEASE, sync_lyric_item, FILEINFO_ERROR_ATTR_NOT_EXIST);

	*time_info = sync_lyric_item->time_info;
	*lyrics = sync_lyric_item->lyric_info;

	return ret;
}

static int __mm_file_create_tag_attrs(MMHandleType *tag_attrs, const char *filename, bool extract_albumart)
{
	int ret = FILEINFO_ERROR_NONE;
	MMHandleType attrs = NULL;
	MMFileSourceType src;

	debug_fenter(RELEASE);

	mm_file_retvm_if_fails(DEBUG, tag_attrs, FILEINFO_ERROR_INVALID_ARGUMENT);

	ret = _is_file_readable(filename);
	if (ret != FILEINFO_ERROR_NONE)
		return ret;

#ifdef __MMFILE_DYN_LOADING__
	MMFILE_FUNC_HANDLE func_handle;

	ret = _load_dynamic_functions(&func_handle);
	if (ret != FILEINFO_ERROR_NONE) {
		debug_error(DEBUG, "load library error\n");
		return ret;
	}
#endif

	/*set source file infomation*/
	MM_FILE_SET_MEDIA_FILE_SRC(src, filename);

	/*set attrs*/
	ret = mm_attrs_new(g_tag_attrs, ARRAY_SIZE(g_tag_attrs), "tag", NULL, NULL, &attrs);
	if (ret) {
		debug_error(DEBUG, "attribute internal error.\n");
		ret = FILEINFO_ERROR_FILE_INTERNAL;
		goto END;
	}

	ret = _get_tag_info(attrs, &src, extract_albumart);
	if (ret != FILEINFO_ERROR_NONE) {
		mm_attrs_free(attrs);
		attrs = NULL;
		debug_error(DEBUG, "failed to get tag: %s\n", filename);
	}

	*tag_attrs = attrs;

END:
#ifdef __MMFILE_DYN_LOADING__
	_unload_dynamic_functions(&func_handle);
#endif

	debug_fleave(RELEASE);

	return ret;
}

int mm_file_create_tag_attrs(MMHandleType *tag_attrs, const char *filename)
{
	return __mm_file_create_tag_attrs(tag_attrs, filename, true);
}

int mm_file_create_tag_attrs_no_albumart(MMHandleType *tag_attrs, const char *filename)
{
	return __mm_file_create_tag_attrs(tag_attrs, filename, false);
}

int mm_file_destroy_tag_attrs(MMHandleType tag_attrs)
{
	void *artwork = NULL;
	GList *synclyrics_list = NULL;
	int ret = FILEINFO_ERROR_NONE;

	debug_fenter(RELEASE);

	mm_file_retvm_if_fails(DEBUG, tag_attrs, FILEINFO_ERROR_INVALID_ARGUMENT);

	ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_ARTWORK, &artwork);
	mmfile_free(artwork);

	ret = mm_attrs_get_data_by_name(tag_attrs, MM_FILE_TAG_SYNCLYRICS, (void **)&synclyrics_list);
	mm_file_free_synclyrics_list(synclyrics_list);
	mm_attrs_free(tag_attrs);

	debug_fleave(RELEASE);

	return ret;
}

static int __create_content_attrs(MMHandleType *contents_attrs, const char *filename, MMFILE_PARSE_TYPE parse_type)
{
	MMHandleType attrs = NULL;
	MMFileSourceType src = {0, };
	MMFILE_PARSE_INFO parse = {0, };
	int ret = 0;

	debug_fenter(RELEASE);

	mm_file_retvm_if_fails(DEBUG, contents_attrs, FILEINFO_ERROR_INVALID_ARGUMENT);

	ret = _is_file_readable(filename);
	if (ret != FILEINFO_ERROR_NONE)
		return ret;

#ifdef __MMFILE_DYN_LOADING__
	MMFILE_FUNC_HANDLE func_handle;

	ret = _load_dynamic_functions(&func_handle);
	if (ret != FILEINFO_ERROR_NONE) {
		debug_error(DEBUG, "load library error\n");
		return ret;
	}
#endif
	/*set source file infomation*/
	MM_FILE_SET_MEDIA_FILE_SRC(src, filename);

	/*set attrs*/
	ret = mm_attrs_new(g_content_attrs, ARRAY_SIZE(g_content_attrs), "content", NULL, NULL, &attrs);
	if (ret) {
		debug_error(DEBUG, "attribute internal error.\n");
		ret = FILEINFO_ERROR_FILE_INTERNAL;
		goto END;
	}


	parse.type = parse_type;
	ret = _get_contents_info(attrs, &src, &parse);
	if (ret != FILEINFO_ERROR_NONE) {
		mm_attrs_free(attrs);
		attrs = NULL;
		debug_error(DEBUG, "failed to get contents: %s\n", filename);
	}

	*contents_attrs = attrs;


END:
#ifdef __MMFILE_DYN_LOADING__
	_unload_dynamic_functions(&func_handle);
#endif

	debug_fleave(RELEASE);

	return ret;
}


int mm_file_create_content_attrs(MMHandleType *contents_attrs, const char *filename)
{
	return __create_content_attrs(contents_attrs, filename, MM_FILE_PARSE_TYPE_ALL);
}


static int __mm_file_create_tag_attrs_from_memory(MMHandleType *tag_attrs, const void *data, unsigned int size, int format, bool extract_albumart)
{
	MMHandleType attrs = NULL;
	MMFileSourceType src;
	/*MMFILE_PARSE_INFO parse = {0, };*/
	int ret = 0;

	debug_fenter(RELEASE);

	mm_file_retvm_if_fails(DEBUG, tag_attrs, FILEINFO_ERROR_INVALID_ARGUMENT);
	mm_file_retvm_if_fails(DEBUG, data, FILEINFO_ERROR_INVALID_ARGUMENT);

#ifdef __MMFILE_DYN_LOADING__
	MMFILE_FUNC_HANDLE func_handle;

	ret = _load_dynamic_functions(&func_handle);
	if (ret != FILEINFO_ERROR_NONE) {
		debug_error(DEBUG, "load library error\n");
		return ret;
	}
#endif

	MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);

	/*set attrs*/
	ret = mm_attrs_new(g_tag_attrs, ARRAY_SIZE(g_tag_attrs), "tag", NULL, NULL, &attrs);
	if (ret) {
		debug_error(DEBUG, "attribute internal error.\n");
		ret = FILEINFO_ERROR_FILE_INTERNAL;
		goto END;
	}

	/*parse.type = MM_FILE_PARSE_TYPE_ALL;*/
	ret = _get_tag_info(attrs, &src, extract_albumart);
	if (ret != FILEINFO_ERROR_NONE) {
		mm_attrs_free(attrs);
		attrs = NULL;
		debug_error(DEBUG, "failed to get tag");
	}

	*tag_attrs = attrs;

END:
#ifdef __MMFILE_DYN_LOADING__
	_unload_dynamic_functions(&func_handle);
#endif

	debug_fleave(RELEASE);

	return ret;
}

int mm_file_create_tag_attrs_from_memory(MMHandleType *tag_attrs, const void *data, unsigned int size, int format)
{
	return __mm_file_create_tag_attrs_from_memory(tag_attrs, data, size, format, true);
}

int mm_file_create_tag_attrs_no_albumart_from_memory(MMHandleType *tag_attrs, const void *data, unsigned int size, int format)
{
	return __mm_file_create_tag_attrs_from_memory(tag_attrs, data, size, format, false);
}

int mm_file_create_content_attrs_from_memory(MMHandleType *contents_attrs, const void *data, unsigned int size, int format)
{
	MMHandleType attrs = NULL;
	MMFileSourceType src;
	MMFILE_PARSE_INFO parse = {0, };
	int ret = 0;

	debug_fenter(RELEASE);

	mm_file_retvm_if_fails(DEBUG, contents_attrs, FILEINFO_ERROR_INVALID_ARGUMENT);
	mm_file_retvm_if_fails(DEBUG, data, FILEINFO_ERROR_INVALID_ARGUMENT);

#ifdef __MMFILE_DYN_LOADING__
	MMFILE_FUNC_HANDLE func_handle;

	ret = _load_dynamic_functions(&func_handle);
	if (ret != FILEINFO_ERROR_NONE) {
		debug_error(DEBUG, "load library error\n");
		return ret;
	}
#endif

	MM_FILE_SET_MEDIA_MEM_SRC(src, data, size, format);

	/*set attrs*/
	ret = mm_attrs_new(g_content_attrs, ARRAY_SIZE(g_content_attrs), "content", NULL, NULL, &attrs);
	if (ret) {
		debug_error(DEBUG, "attribute internal error.\n");
		ret = FILEINFO_ERROR_FILE_INTERNAL;
		goto END;
	}

	parse.type = MM_FILE_PARSE_TYPE_ALL;
	ret = _get_contents_info(attrs, &src, &parse);
	if (ret != FILEINFO_ERROR_NONE) {
		mm_attrs_free(attrs);
		attrs = NULL;
		debug_error(DEBUG, "failed to get contents");
	}

	*contents_attrs = attrs;

END:
#ifdef __MMFILE_DYN_LOADING__
	_unload_dynamic_functions(&func_handle);
#endif

	debug_fleave(RELEASE);

	return ret;
}



int mm_file_destroy_content_attrs(MMHandleType contents_attrs)
{
	void *thumbnail = NULL;
	int ret = FILEINFO_ERROR_NONE;

	debug_fenter(RELEASE);

	mm_file_retvm_if_fails(DEBUG, contents_attrs, FILEINFO_ERROR_INVALID_ARGUMENT);

	ret = mm_attrs_get_data_by_name(contents_attrs, MM_FILE_CONTENT_VIDEO_THUMBNAIL, &thumbnail);
	mmfile_free(thumbnail);

	mm_attrs_free(contents_attrs);

	debug_fleave(RELEASE);

	return ret;
}



int mm_file_get_stream_info(const char *filename, int *audio_stream_num, int *video_stream_num)
{
	MMFileSourceType     src = {0, };
	MMFILE_PARSE_INFO    parse = {0, };

	int ret = 0;

	debug_fenter(RELEASE);

	mm_file_retvm_if_fails(DEBUG, audio_stream_num, FILEINFO_ERROR_INVALID_ARGUMENT);
	mm_file_retvm_if_fails(DEBUG, video_stream_num, FILEINFO_ERROR_INVALID_ARGUMENT);

	ret = _is_file_readable(filename);
	if (ret != FILEINFO_ERROR_NONE)
		return ret;

#ifdef __MMFILE_DYN_LOADING__
	MMFILE_FUNC_HANDLE func_handle;

	ret = _load_dynamic_functions(&func_handle);
	if (ret != FILEINFO_ERROR_NONE) {
		debug_error(DEBUG, "load library error\n");
		return ret;
	}
#endif

	/*set source file infomation*/
	MM_FILE_SET_MEDIA_FILE_SRC(src, filename);


	parse.type = MM_FILE_PARSE_TYPE_SIMPLE;
	ret = _get_contents_info(NULL, &src, &parse);
	if (ret != FILEINFO_ERROR_NONE) {
		debug_error(DEBUG, "failed to get stream info: %s\n", filename);
	} else {
		if (parse.audio_track_num == 0 && parse.video_track_num == 0) {
			debug_error(DEBUG, "empty header. retry to get stream info: %s\n", filename);
			parse.type = MM_FILE_PARSE_TYPE_NORMAL;
			ret = _get_contents_info(NULL, &src, &parse);
		}
	}

	/*set number of each stream*/
	*audio_stream_num = parse.audio_track_num;
	*video_stream_num = parse.video_track_num;

#ifdef __MMFILE_DYN_LOADING__
	_unload_dynamic_functions(&func_handle);
#endif

	debug_fleave(RELEASE);

	return ret;
}


int mm_file_create_content_attrs_simple(MMHandleType *contents_attrs, const char *filename)
{
	return __create_content_attrs(contents_attrs, filename, MM_FILE_PARSE_TYPE_NORMAL);
}


int mm_file_create_content_attrs_safe(MMHandleType *contents_attrs, const char *filename)
{
	return __create_content_attrs(contents_attrs, filename, MM_FILE_PARSE_TYPE_SAFE);
}


int mm_file_get_video_frame(const char *path, int64_t timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
{
	int ret = 0;
	void *formatFuncHandle = NULL;

	mm_file_retvm_if_fails(DEBUG, path, FILEINFO_ERROR_INVALID_ARGUMENT);

#ifdef __MMFILE_DYN_LOADING__
	/* Get from function argument */
	formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
	if (!formatFuncHandle) {
		debug_error(DEBUG, "error : dlopen");
		goto exception;
	}

	mmfile_format_get_frame = dlsym(formatFuncHandle, "mmfile_format_get_frame");
	if (!mmfile_format_get_frame) {
		debug_error(DEBUG, "error : load library");
		goto exception;
	}
#endif

	debug_msg(RELEASE, "file path [%s] is_accurate [%d]", path, is_accurate);

	ret = mmfile_format_get_frame(path, timestamp, is_accurate, frame, size, width, height);
	if (ret  == MMFILE_FORMAT_FAIL) {
		debug_error(DEBUG, "error : get frame");
		goto exception;
	}

	if (formatFuncHandle)
		dlclose(formatFuncHandle);

	return FILEINFO_ERROR_NONE;

exception:
	if (formatFuncHandle)
		dlclose(formatFuncHandle);

	return FILEINFO_ERROR_FILE_INTERNAL;
}


int mm_file_get_video_frame_from_memory(const void *data, unsigned int datasize, int64_t timestamp, bool is_accurate, unsigned char **frame, int *size, int *width, int *height)
{
	int ret = 0;
	void *formatFuncHandle = NULL;

	mm_file_retvm_if_fails(DEBUG, data, FILEINFO_ERROR_INVALID_ARGUMENT);
	mm_file_retvm_if_fails(DEBUG, datasize != 0, FILEINFO_ERROR_INVALID_ARGUMENT);

#ifdef __MMFILE_DYN_LOADING__
	/* Get from function argument */
	formatFuncHandle = dlopen(MMFILE_FORMAT_SO_FILE_NAME, RTLD_LAZY);
	if (!formatFuncHandle) {
		debug_error(DEBUG, "error : dlopen");
		goto exception;
	}

	mmfile_format_get_frame_from_memory = dlsym(formatFuncHandle, "mmfile_format_get_frame_from_memory");
	if (!mmfile_format_get_frame_from_memory) {
		debug_error(DEBUG, "error : load library");
		goto exception;
	}
#endif

	debug_msg(RELEASE, "data [%p], data_size[%d], is_accurate [%d]", data, datasize, is_accurate);

	ret = mmfile_format_get_frame_from_memory(data, datasize, timestamp, is_accurate, frame, size, width, height);
	if (ret  == MMFILE_FORMAT_FAIL) {
		debug_error(DEBUG, "error : get frame");
		goto exception;
	}

	if (formatFuncHandle)
		dlclose(formatFuncHandle);

	return FILEINFO_ERROR_NONE;

exception:
	if (formatFuncHandle)
		dlclose(formatFuncHandle);

	return FILEINFO_ERROR_FILE_INTERNAL;
}


int mm_file_check_uhqa(const char *filename, bool *is_uhqa)
{
	MMHandleType attrs = NULL;
	MMFileSourceType src = {0, };
	MMFILE_PARSE_INFO parse = {0, };
	int ret = 0;

	ret = _is_file_readable(filename);
	if (ret != FILEINFO_ERROR_NONE)
		return ret;

#ifdef __MMFILE_DYN_LOADING__
	MMFILE_FUNC_HANDLE func_handle;

	ret = _load_dynamic_functions(&func_handle);
	if (ret != FILEINFO_ERROR_NONE) {
		debug_error(DEBUG, "load library error\n");
		return ret;
	}
#endif

	/*set source file infomation*/
	MM_FILE_SET_MEDIA_FILE_SRC(src, filename);

	/*set attrs*/
	ret = mm_attrs_new(g_content_attrs, ARRAY_SIZE(g_content_attrs), "content", NULL, NULL, &attrs);
	if (ret) {
		debug_error(DEBUG, "attribute internal error.\n");
		ret = FILEINFO_ERROR_FILE_INTERNAL;
		goto END;
	}

	parse.type = MM_FILE_PARSE_TYPE_NORMAL;
	ret = _get_contents_info(attrs, &src, &parse);
	if (ret == FILEINFO_ERROR_NONE) {
		*is_uhqa = parse.is_uhqa;
	} else {
		debug_error(DEBUG, "_get_contents_info failed\n");
		*is_uhqa = false;
	}

	mm_attrs_free(attrs);

END:
#ifdef __MMFILE_DYN_LOADING__
	_unload_dynamic_functions(&func_handle);
#endif

	debug_fleave(RELEASE);

	return ret;
}