#include "mm_file_format_private.h"
#include "mm_file_format_aac.h"
-
-/* Internal Error Type */
-#define MMFILE_AAC_PARSER_FILE_END 2
-
/* Media specific definations */
#define MMFILE_AAC_ADIF_HEADER_MAX_SIZE 30
#define MMFILE_AAC_ADTS_HEADER_MAX_SIZE 7
#define AAC_ADTS_FRAME_LEN_OFFSET 30
#define AAC_ADTS_SAMPLES_PER_FRAME 1024
-#define IS_AAC_ADIF_HEADER(buff) (!(memcmp((buff), "ADIF", 4)))
-#define IS_AAC_ADTS_HEADER(buff) (((buff)[0] == 0xff) && (((buff)[1] & 0xf0) == 0xf0))
-
-
/* Array to Number conversions */
#define GET_INT_NUMBER(buff) (int)((((int)(buff)[0]) << 24) | \
(((int)(buff)[1]) << 16) | \
0, 0, 0, 0
};
-/* internal APIs */
-void _aac_init_handle(tMMFILE_AAC_HANDLE *privateData);
-int _search_id3tag(tMMFILE_AAC_HANDLE *pData);
-int _parse_id3_tag(tMMFILE_AAC_HANDLE *pData);
-int _get_range_bits_value(unsigned char *buff, int fieldOffset, int fieldSize);
-int _parse_aac_adif_header(tMMFILE_AAC_HANDLE *pData);
-int _get_next_adts_frame_length(tMMFILE_AAC_HANDLE *pData, int *frameLen);
-int _parse_aac_adts_header(tMMFILE_AAC_HANDLE *pData);
-
-
-void _aac_init_handle(tMMFILE_AAC_HANDLE *privateData)
+static void __aac_init_handle(tMMFILE_AAC_HANDLE *privateData)
{
/* Default Initializations */
privateData->streamOffset = 0;
privateData->tagInfo.artworkMime = NULL;
}
-
-int _search_id3tag(tMMFILE_AAC_HANDLE *pData)
+static bool __search_id3tag(tMMFILE_AAC_HANDLE *pData)
{
unsigned char tagHeader[MP3_TAGv2_HEADER_LEN] = {0, };
int encSize = 0;
mmfile_seek(pData->hFile, 0, MMFILE_SEEK_SET);
readed = mmfile_read(pData->hFile, tagHeader, MP3_TAGv2_HEADER_LEN);
- if (MP3_TAGv2_HEADER_LEN != readed) {
- debug_msg(RELEASE, "Read Fail");
- return MMFILE_AAC_PARSER_FAIL;
- }
-
- if (!IS_ID3V2_TAG(tagHeader)) {
- debug_msg(RELEASE, "No ID3 Tag");
- goto search_end;
- }
+ mm_file_retvm_if_fails(RELEASE, MP3_TAGv2_HEADER_LEN == readed, false);
+ mm_file_retvm_if_fails(RELEASE, IS_ID3V2_TAG(tagHeader), true);
if (tagHeader[3] == 0xFF || tagHeader[4] == 0xFF ||
tagHeader[6] >= 0x80 || tagHeader[7] >= 0x80 ||
tagHeader[8] >= 0x80 || tagHeader[9] >= 0x80) {
debug_msg(RELEASE, "Read Fail");
- return MMFILE_AAC_PARSER_FAIL;
+ return false;
}
pData->tagVersion = tagHeader[3];
if (pData->tagVersion > 4) {
debug_msg(RELEASE, "\nTag version not supported");
- return MMFILE_AAC_PARSER_FAIL;
+ return false;
}
encSize = GET_INT_NUMBER(&tagHeader[6]);
if (pData->tagInfoSize > pData->streamInfo.fileSize) {
debug_msg(RELEASE, "Invalid size");
- return MMFILE_AAC_PARSER_FAIL;
+ return false;
}
- pData->isTagPresent = TRUE;
+ pData->isTagPresent = true;
pData->tagOffset = 0;
pData->streamOffset = pData->tagInfoSize;
pData->id3Handle.tagV2Info.tagVersion = pData->tagVersion;
pData->id3Handle.tagV2Info.tagLen = pData->tagInfoSize;
-search_end:
- return MMFILE_AAC_PARSER_SUCCESS;
+ return true;
}
-
-int _parse_id3_tag(tMMFILE_AAC_HANDLE *pData)
+static bool __parse_id3_tag(tMMFILE_AAC_HANDLE *pData)
{
unsigned char *tagBuff = NULL;
AvFileContentInfo *hTag = &pData->id3Handle;
- int ret = FALSE;
+ bool ret = false;
int readed = 0;
mmfile_seek(pData->hFile, pData->tagOffset, MMFILE_SEEK_SET);
- mm_file_retvm_if_fails(DEBUG, hTag->fileLen > 0, MMFILE_AAC_PARSER_FAIL);
+ mm_file_retvm_if_fails(DEBUG, hTag->fileLen > 0, false);
+
tagBuff = g_malloc0(hTag->fileLen);
readed = mmfile_read(pData->hFile, tagBuff, hTag->fileLen);
if (readed != hTag->fileLen) {
debug_error(DEBUG, "failed to read. %d, %lld\n", readed, hTag->fileLen);
- goto failure;
+ mmfile_free(tagBuff);
+ return false;
}
switch (hTag->tagV2Info.tagVersion) {
break;
}
- if (ret == FALSE) {
- ret = MMFILE_AAC_PARSER_FAIL;
- debug_warning(DEBUG, "failed to parse\n");
- goto failure;
- }
+ mmfile_free(tagBuff);
+ mm_file_retvm_if_fails(DEBUG, ret, false);
mm_file_id3tag_restore_content_info(hTag);
pData->tagInfo.artworkSize = hTag->imageInfo.imageLen;
pData->tagInfo.artwork = hTag->imageInfo.pImageBuf;
- ret = MMFILE_AAC_PARSER_SUCCESS;
-
-
-failure:
- mmfile_free(tagBuff);
-
- return ret;
+ return true;
}
-
-int _get_range_bits_value(unsigned char *buff, int fieldOffset, int fieldSize)
+static int __get_range_bits_value(unsigned char *buff, int fieldOffset, int fieldSize)
{
int pos = 0;
unsigned int srcByteStartOff = 0;
}
-int _parse_aac_adif_header(tMMFILE_AAC_HANDLE *pData)
+static bool __parse_aac_adif_header(tMMFILE_AAC_HANDLE *pData)
{
unsigned char adifHeader[MMFILE_AAC_ADIF_HEADER_MAX_SIZE] = {0, };
int currentBitOffset = 0;
mmfile_seek(pData->hFile, pData->streamOffset, MMFILE_SEEK_SET);
readed = mmfile_read(pData->hFile, adifHeader, MMFILE_AAC_ADIF_HEADER_MAX_SIZE);
- if (readed < 0) {
- return MMFILE_AAC_PARSER_FAIL;
- }
+ if (readed < 0)
+ return false;
+
+ if (memcmp(adifHeader, "ADIF", 4))
+ return false;
- if (memcmp(adifHeader, "ADIF", 4) != 0) {
- return MMFILE_AAC_PARSER_FAIL;
- }
currentBitOffset += 32;
- copyRightStatus = _get_range_bits_value(adifHeader, currentBitOffset, 1);
+ copyRightStatus = __get_range_bits_value(adifHeader, currentBitOffset, 1);
currentBitOffset += 1;
- if (copyRightStatus) {
- /*skipping Copyright info */
+ /*skipping Copyright info */
+ if (copyRightStatus)
currentBitOffset += 72;
- }
/*Original/copy */
- fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 1);
+ fieldValue = __get_range_bits_value(adifHeader, currentBitOffset, 1);
currentBitOffset += 1;
/*skipping Home status */
currentBitOffset += 1;
/*Bit stream type */
- fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 1);
+ fieldValue = __get_range_bits_value(adifHeader, currentBitOffset, 1);
currentBitOffset += 1;
- if (!fieldValue) {
+ if (!fieldValue)
pData->streamType = AAC_STREAM_CONSTANT;
- } else {
+ else
pData->streamType = AAC_STREAM_VARIABLE;
- }
/*Bit-rate */
- pData->streamInfo.bitRate = _get_range_bits_value(adifHeader, currentBitOffset, 23);
+ pData->streamInfo.bitRate = __get_range_bits_value(adifHeader, currentBitOffset, 23);
currentBitOffset += 23;
/*Num of program config elements */
- fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ fieldValue = __get_range_bits_value(adifHeader, currentBitOffset, 4);
currentBitOffset += 4;
/*skipping adif buffer fullness */
currentBitOffset += 4;
/*Profile */
- pData->streamInfo.profileType = _get_range_bits_value(adifHeader, currentBitOffset, 2);
+ pData->streamInfo.profileType = __get_range_bits_value(adifHeader, currentBitOffset, 2);
currentBitOffset += 2;
/*sampling freq index */
- fieldValue = _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ fieldValue = __get_range_bits_value(adifHeader, currentBitOffset, 4);
currentBitOffset += 4;
pData->streamInfo.samplingRate = Sampling_freq_table[fieldValue];
/*num_front_channel_elements */
- pData->streamInfo.numAudioChannels = _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ pData->streamInfo.numAudioChannels = __get_range_bits_value(adifHeader, currentBitOffset, 4);
currentBitOffset += 4;
/*num_side_channel_elements */
- pData->streamInfo.numAudioChannels += _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ pData->streamInfo.numAudioChannels += __get_range_bits_value(adifHeader, currentBitOffset, 4);
currentBitOffset += 4;
/*num_back_channel_elements */
- pData->streamInfo.numAudioChannels += _get_range_bits_value(adifHeader, currentBitOffset, 4);
+ pData->streamInfo.numAudioChannels += __get_range_bits_value(adifHeader, currentBitOffset, 4);
currentBitOffset += 4;
/*num_lfe_channel_elements */
- pData->streamInfo.numAudioChannels += _get_range_bits_value(adifHeader, currentBitOffset, 2);
-
- return MMFILE_AAC_PARSER_SUCCESS;
+ pData->streamInfo.numAudioChannels += __get_range_bits_value(adifHeader, currentBitOffset, 2);
+ return true;
}
-int _parse_aac_adts_header(tMMFILE_AAC_HANDLE *pData)
+static bool __parse_aac_adts_header(tMMFILE_AAC_HANDLE *pData)
{
unsigned char adtsHeader[MMFILE_AAC_ADTS_HEADER_MAX_SIZE] = {0, };
int currentBitOffset = 0;
mmfile_seek(pData->hFile, pData->streamOffset, MMFILE_SEEK_SET);
readed = mmfile_read(pData->hFile, adtsHeader, MMFILE_AAC_ADTS_HEADER_MAX_SIZE);
- if (readed < 0) {
- return MMFILE_AAC_PARSER_FAIL;
- }
+ if (readed < 0)
+ return false;
+
+ if (!(adtsHeader[0] == 0xff && (adtsHeader[1] & 0xf0) == 0xf0))
+ return false;
- if (!IS_AAC_ADTS_HEADER(adtsHeader)) {
- return MMFILE_AAC_PARSER_FAIL;
- }
currentBitOffset += 12;
/*adtsId */
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 1);
+ fieldValue = __get_range_bits_value(adtsHeader, currentBitOffset, 1);
currentBitOffset += 1;
pData->mpegType = (fieldValue != 0);
/*LayerType */
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 2);
+ fieldValue = __get_range_bits_value(adtsHeader, currentBitOffset, 2);
currentBitOffset += 2;
/*skipping Protection Absent */
currentBitOffset += 1;
/*ProfileType */
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 2);
+ fieldValue = __get_range_bits_value(adtsHeader, currentBitOffset, 2);
currentBitOffset += 2;
pData->streamInfo.profileType = fieldValue;
/*SamplingrateIndex */
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 4);
+ fieldValue = __get_range_bits_value(adtsHeader, currentBitOffset, 4);
currentBitOffset += 4;
pData->streamInfo.samplingRate = Sampling_freq_table[fieldValue];
currentBitOffset += 1;
/*ChannelConfig */
- pData->streamInfo.numAudioChannels = _get_range_bits_value(adtsHeader, currentBitOffset, 3);
+ pData->streamInfo.numAudioChannels = __get_range_bits_value(adtsHeader, currentBitOffset, 3);
currentBitOffset += 3;
/*Original/copy status */
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 1);
+ fieldValue = __get_range_bits_value(adtsHeader, currentBitOffset, 1);
currentBitOffset += 1;
/*skipping Home status */
- fieldValue = _get_range_bits_value(adtsHeader, currentBitOffset, 1);
+ fieldValue = __get_range_bits_value(adtsHeader, currentBitOffset, 1);
- return MMFILE_AAC_PARSER_SUCCESS;
+ return true;
}
-int _get_next_adts_frame_length(tMMFILE_AAC_HANDLE *pData, int *frameLen)
+static bool __get_next_adts_frame_length(tMMFILE_AAC_HANDLE *pData, int *frameLen)
{
unsigned char adtsHeader[MMFILE_AAC_ADTS_HEADER_MAX_SIZE] = {0, };
- int ret = MMFILE_AAC_PARSER_SUCCESS;
+ int ret = true;
long long filePosBefore = mmfile_tell(pData->hFile);
int readed = 0;
readed = mmfile_read(pData->hFile, adtsHeader, MMFILE_AAC_ADTS_HEADER_MAX_SIZE);
if (readed < 0)
- return MMFILE_AAC_PARSER_FAIL;
+ return false;
debug_msg(RELEASE, "\nFILE POS: %lld\n", filePosBefore);
debug_msg(RELEASE, "\nADTS HEADER: [%2x] [%2x] [%2x] [%2x] [%2x] [%2x]\n",
if (mmfile_tell(pData->hFile) >= pData->streamInfo.fileSize) {
*frameLen = 0;
- ret = MMFILE_AAC_PARSER_FILE_END;
+ ret = false;
goto function_end;
}
- if (!IS_AAC_ADTS_HEADER(adtsHeader)) {
+ if (!(adtsHeader[0] == 0xff && (adtsHeader[1] & 0xf0) == 0xf0)) {
*frameLen = 0;
- ret = MMFILE_AAC_PARSER_FAIL;
+ ret = false;
goto function_end;
}
- *frameLen = _get_range_bits_value(adtsHeader, AAC_ADTS_FRAME_LEN_OFFSET, 13);
+ *frameLen = __get_range_bits_value(adtsHeader, AAC_ADTS_FRAME_LEN_OFFSET, 13);
if (*frameLen == 0 || *frameLen > (pData->streamInfo.fileSize - filePosBefore)) {
*frameLen = 0;
- ret = MMFILE_AAC_PARSER_FAIL;
- goto function_end;
+ ret = false;
}
function_end:
-
mmfile_seek(pData->hFile, filePosBefore + *frameLen, MMFILE_SEEK_SET);
return ret;
}
-int mmfile_aacparser_open(MMFileAACHandle *handle, const char *path)
+static bool __mmfile_aacparser_open(MMFileAACHandle *handle, const char *path)
{
tMMFILE_AAC_HANDLE *privateData = NULL;
- int ret = 0;
+ int ret = MMFILE_UTIL_FAIL;
unsigned char header[4] = {0, };
int firstFrameLen = 0;
int readed = 0;
- mm_file_retvm_if_fails(DEBUG, path, MMFILE_AAC_PARSER_FAIL);
+ mm_file_retvm_if_fails(DEBUG, path, false);
privateData = g_new0(tMMFILE_AAC_HANDLE, 1);
}
/* Initialize the members of handle */
- _aac_init_handle(privateData);
+ __aac_init_handle(privateData);
privateData->streamInfo.fileSize = mmfile_get_size(privateData->hFile);
if (privateData->streamInfo.fileSize <= 0) {
}
/* Search the existance of ID3 tag */
- ret = _search_id3tag(privateData);
- if (ret == MMFILE_AAC_PARSER_FAIL) {
+ if (!__search_id3tag(privateData)) {
debug_error(RELEASE, "Error in searching the ID3 tag\n");
goto exception;
}
if (readed != 4)
goto exception;
- if (IS_AAC_ADIF_HEADER(header)) {
+ if (!memcmp(header, "ADIF", 4)) {
privateData->formatType = AAC_FORMAT_ADIF;
debug_msg(RELEASE, "AAC Format: ADIF\n");
- } else if (IS_AAC_ADTS_HEADER(header)) {
+ } else if (header[0] == 0xff && (header[1] & 0xf0) == 0xf0) {
privateData->formatType = AAC_FORMAT_ADTS;
debug_msg(RELEASE, "AAC Format: ADTS\n");
/* Verify whether the first frame size is proper */
mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
- ret = _get_next_adts_frame_length(privateData, &firstFrameLen);
- if (ret == MMFILE_AAC_PARSER_FAIL) {
+ if (!__get_next_adts_frame_length(privateData, &firstFrameLen)) {
debug_error(DEBUG, "Invalid Frame length in ADTS header\n");
goto exception;
}
*handle = privateData;
- return MMFILE_AAC_PARSER_SUCCESS;
+ return true;
exception:
if (privateData) {
mmfile_free(privateData);
*handle = NULL;
}
- return MMFILE_AAC_PARSER_FAIL;
-
+ return false;
}
-
-int mmfile_aacparser_get_stream_info(MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo)
+static bool __mmfile_aacparser_get_stream_info(MMFileAACHandle handle, tMMFILE_AAC_STREAM_INFO *aacinfo)
{
tMMFILE_AAC_HANDLE *privateData = NULL;
int frameLen = 0;
long long totalFrames = 0, totalFrameLength = 0;
unsigned long long streamDataSize = 0;
- int ret = MMFILE_AAC_PARSER_SUCCESS;
- if (NULL == handle || NULL == aacinfo) {
- debug_error(DEBUG, "handle is NULL\n");
- return MMFILE_AAC_PARSER_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, handle, false);
+ mm_file_retvm_if_fails(DEBUG, aacinfo, false);
privateData = (tMMFILE_AAC_HANDLE *) handle;
if (privateData->formatType == AAC_FORMAT_ADIF) {
- ret = _parse_aac_adif_header(privateData);
+ mm_file_retvm_if_fails(DEBUG, __parse_aac_adif_header(privateData), false);
aacinfo->iseekable = 0;
} else {
- ret = _parse_aac_adts_header(privateData);
+ mm_file_retvm_if_fails(DEBUG, __parse_aac_adts_header(privateData), false);
aacinfo->iseekable = 1;
}
- if (ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error(DEBUG, "Error in parsing the stream header\n");
- return ret;
- }
-
mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
if (privateData->formatType == AAC_FORMAT_ADTS) {
-
- while (TRUE) {
- ret = _get_next_adts_frame_length(privateData, &frameLen);
- if (ret != MMFILE_AAC_PARSER_SUCCESS) {
+ while (1) {
+ if (!__get_next_adts_frame_length(privateData, &frameLen))
break;
- }
+
totalFrameLength += frameLen - MMFILE_AAC_ADTS_HEADER_MAX_SIZE;
totalFrames++;
}
- if (ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error(DEBUG, "Found corrupted frames!!! Ignoring\n");
- }
-
debug_msg(RELEASE, "No of ADTS frames: %lld\n", totalFrames);
privateData->streamInfo.frameRate = privateData->streamInfo.samplingRate / AAC_ADTS_SAMPLES_PER_FRAME;
if (privateData->streamInfo.frameRate)
privateData->streamInfo.duration = (totalFrames * 1000) / privateData->streamInfo.frameRate;
- else privateData->streamInfo.duration = 0;
+ else
+ privateData->streamInfo.duration = 0;
if (privateData->streamInfo.duration)
privateData->streamInfo.bitRate = (totalFrameLength * 8 * 1000) / (privateData->streamInfo.duration);
- else privateData->streamInfo.bitRate = 0;
+ else
+ privateData->streamInfo.bitRate = 0;
} else {
streamDataSize = (unsigned long long)privateData->streamInfo.fileSize - privateData->tagInfoSize;
/* Return the stream info structure */
memcpy(aacinfo, &(privateData->streamInfo), sizeof(tMMFILE_AAC_STREAM_INFO));
- return MMFILE_AAC_PARSER_SUCCESS;
+ return true;
}
-int mmfile_aacparser_get_tag_info(MMFileAACHandle handle, tMMFILE_AAC_TAG_INFO *tagInfo)
+static bool __mmfile_aacparser_get_tag_info(MMFileAACHandle handle, tMMFILE_AAC_TAG_INFO *tagInfo)
{
tMMFILE_AAC_HANDLE *privateData = NULL;
- int ret = 0;
- if (NULL == handle || NULL == tagInfo) {
- debug_error(DEBUG, "handle is NULL\n");
- return MMFILE_AAC_PARSER_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, handle, false);
+ mm_file_retvm_if_fails(DEBUG, tagInfo, false);
privateData = (tMMFILE_AAC_HANDLE *) handle;
if (privateData->id3Handle.tagV2Info.tagVersion == 0) {
debug_warning(DEBUG, "There is no Tag info\n");
- return MMFILE_AAC_PARSER_SUCCESS;
+ return true;
}
- ret = _parse_id3_tag(privateData);
- if (ret == MMFILE_AAC_PARSER_FAIL) {
- debug_warning(DEBUG, "Error in parsing the Tag info\n");
- return ret;
- }
+ mm_file_retvm_if_fails(DEBUG, __parse_id3_tag(privateData), false);
/* Return the tag info structure */
memcpy(tagInfo, &(privateData->tagInfo), sizeof(tMMFILE_AAC_TAG_INFO));
- return MMFILE_AAC_PARSER_SUCCESS;
+ return true;
}
-
-int mmfile_aacparser_close(MMFileAACHandle handle)
+static void __mmfile_aacparser_close(MMFileAACHandle handle)
{
- tMMFILE_AAC_HANDLE *privateData = NULL;
+ tMMFILE_AAC_HANDLE *privateData = (tMMFILE_AAC_HANDLE *)handle;
- if (NULL == handle) {
- debug_error(DEBUG, "handle is NULL\n");
- return MMFILE_AAC_PARSER_FAIL;
- }
+ if (!privateData)
+ return;
- privateData = (tMMFILE_AAC_HANDLE *) handle;
mm_file_free_AvFileContentInfo(&privateData->id3Handle);
-
mmfile_close(privateData->hFile);
-
- return MMFILE_AAC_PARSER_SUCCESS;
}
-
/* mm plugin interface */
int mmfile_format_read_stream_aac(MMFileFormatContext *formatContext);
int mmfile_format_read_frame_aac(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
formatContext->videoTotalTrackNum = 0;
formatContext->audioTotalTrackNum = 1;
- res = mmfile_aacparser_open(&handle, formatContext->uriFileName);
- if (MMFILE_AAC_PARSER_FAIL == res) {
- debug_error(DEBUG, "mmfile_aacparser_open\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, __mmfile_aacparser_open(&handle, formatContext->uriFileName), MMFILE_FORMAT_FAIL);
formatContext->privateFormatData = handle;
return MMFILE_FORMAT_SUCCESS;
}
-
int mmfile_format_read_stream_aac(MMFileFormatContext *formatContext)
{
MMFileAACHandle handle = NULL;
tMMFILE_AAC_STREAM_INFO aacinfo = {0, };
MMFileFormatStream *audioStream = NULL;
- int ret = MMFILE_FORMAT_FAIL;
mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
handle = formatContext->privateFormatData;
- ret = mmfile_aacparser_get_stream_info(handle, &aacinfo);
- mm_file_retvm_if_fails(DEBUG, ret == MMFILE_FORMAT_SUCCESS, ret);
+ mm_file_retvm_if_fails(DEBUG, __mmfile_aacparser_get_stream_info(handle, &aacinfo), MMFILE_FORMAT_FAIL);
formatContext->isseekable = aacinfo.iseekable;
formatContext->duration = aacinfo.duration;
mmfile_format_print_contents(formatContext);
#endif
- return ret;
+ return MMFILE_FORMAT_SUCCESS;
}
{
MMFileAACHandle handle = NULL;
tMMFILE_AAC_TAG_INFO aacinfo = {0, };
- int ret = MMFILE_FORMAT_FAIL;
mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
handle = formatContext->privateFormatData;
- ret = mmfile_aacparser_get_tag_info(handle, &aacinfo);
- mm_file_retvm_if_fails(DEBUG, ret == MMFILE_FORMAT_SUCCESS, ret);
+ mm_file_retvm_if_fails(DEBUG, __mmfile_aacparser_get_tag_info(handle, &aacinfo), MMFILE_FORMAT_FAIL);
formatContext->title = g_strdup(aacinfo.title);
formatContext->author = g_strdup(aacinfo.author);
mmfile_format_print_contents(formatContext);
#endif
- return ret;
+ return MMFILE_FORMAT_SUCCESS;
}
-
-
int mmfile_format_read_frame_aac(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
debug_error(DEBUG, "error: mmfile_format_read_frame_aac, no handling\n");
return MMFILE_FORMAT_FAIL;
}
-
-
int mmfile_format_close_aac(MMFileFormatContext *formatContext)
{
MMFileAACHandle handle = NULL;
- int ret = MMFILE_FORMAT_FAIL;
if (NULL == formatContext) {
debug_error(DEBUG, "error: invalid params\n");
handle = formatContext->privateFormatData;
- if (NULL != handle) {
- ret = mmfile_aacparser_close(handle);
- if (ret == MMFILE_AAC_PARSER_FAIL) {
- debug_error(DEBUG, "error: mmfile_format_close_aac\n");
- }
- }
+ if (handle)
+ __mmfile_aacparser_close(handle);
mmfile_free(formatContext->streams[MMFILE_AUDIO_STREAM]);
return MMFILE_FORMAT_SUCCESS;
}
-
projects / platform / core / multimedia / libmm-fileinfo.git / commitdiff