#include <string.h> /*memcmp*/
#include <stdlib.h> /*malloc*/
-
#include "mm_file_debug.h"
#include "mm_file_utils.h"
#include "mm_file_format_private.h"
#include "mm_file_format_amr.h"
-
/* Media specific definations */
-#define NUM_AMR_NB_MODES 8
-#define NUM_AMR_WB_MODES 9
-
#define MMFILE_AMR_SINGLE_CH_HEADER_SIZE 6
#define MMFILE_AMR_SINGLE_CH_HEADER "#!AMR\n"
#define MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE 9
#define AMR_MAX_READ_BUF_SZ 4096
-#define AMR_GET_MODE(firstByte) (((firstByte) >> 3) & 0x0F)
-
-
typedef enum _mmfile_amr_format_types {
AMR_FORMAT_NB,
AMR_FORMAT_WB,
}
};
-/* internal APIs */
-
-void _amr_init_handle(tMMFILE_AMR_HANDLE *pData)
+static void __amr_init_handle(tMMFILE_AMR_HANDLE *pData)
{
pData->hFile = NULL;
pData->duration = 0;
pData->amrChannelType = AMR_CHANNEL_TYPE_SINGLE;
}
-int _parse_amr_header(tMMFILE_AMR_HANDLE *pData)
+static bool __parse_amr_header(tMMFILE_AMR_HANDLE *pData)
{
-
+ int header_size = 0;
unsigned char header[MMFILE_AMR_MAX_HEADER_SIZE];
- int ret = MMFILE_AMR_PARSER_SUCCESS;
- ret = mmfile_read(pData->hFile, header, MMFILE_AMR_MAX_HEADER_SIZE);
- if (ret != MMFILE_AMR_MAX_HEADER_SIZE) {
- return MMFILE_AMR_PARSER_FAIL;
- }
+ header_size = mmfile_read(pData->hFile, header, MMFILE_AMR_MAX_HEADER_SIZE);
+ if (header_size != MMFILE_AMR_MAX_HEADER_SIZE)
+ return false;
debug_msg(RELEASE, "\nAMR HEADER: [%2x] [%2x] [%2x] [%2x] [%2x]\n \
[%2x] [%2x] [%2x] [%2x] [%2x]\n \
pData->amrFormat = AMR_FORMAT_NB;
pData->amrChannelType = AMR_CHANNEL_TYPE_SINGLE;
pData->streamOffset = MMFILE_AMR_SINGLE_CH_HEADER_SIZE;
- }
-
- else if (!(memcmp(header, MMFILE_AMR_WB_SINGLE_CH_HEADER, MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE))) {
+ } else if (!(memcmp(header, MMFILE_AMR_WB_SINGLE_CH_HEADER, MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE))) {
pData->amrFormat = AMR_FORMAT_WB;
pData->amrChannelType = AMR_CHANNEL_TYPE_SINGLE;
pData->streamOffset = MMFILE_AMR_WB_SINGLE_CH_HEADER_SIZE;
- }
-
- else if (!(memcmp(header, MMFILE_AMR_MULTI_CH_HEADER, MMFILE_AMR_MULTI_CH_HEADER_SIZE))) {
+ } else if (!(memcmp(header, MMFILE_AMR_MULTI_CH_HEADER, MMFILE_AMR_MULTI_CH_HEADER_SIZE))) {
pData->amrFormat = AMR_FORMAT_NB;
pData->amrChannelType = AMR_CHANNEL_TYPE_MULTIPLE;
pData->streamOffset = MMFILE_AMR_MULTI_CH_HEADER_SIZE;
- }
-
- else if (!(memcmp(header, MMFILE_AMR_WB_MULTI_CH_HEADER, MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE))) {
+ } else if (!(memcmp(header, MMFILE_AMR_WB_MULTI_CH_HEADER, MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE))) {
pData->amrFormat = AMR_FORMAT_WB;
pData->amrChannelType = AMR_CHANNEL_TYPE_MULTIPLE;
pData->streamOffset = MMFILE_AMR_WB_MULTI_CH_HEADER_SIZE;
- }
-
- else {
+ } else {
pData->amrFormat = AMR_FORMAT_UNKNOWN;
pData->amrChannelType = AMR_CHANNEL_TYPE_UNKNOWN;
- ret = MMFILE_AMR_PARSER_FAIL;
+ return false;
}
- return ret;
+ return true;
}
-int _parse_amr_stream(tMMFILE_AMR_HANDLE *pData)
+static void __parse_amr_stream(tMMFILE_AMR_HANDLE *pData)
{
int frameLen = 0;
unsigned char amrMode = 0;
- int ret = MMFILE_AMR_PARSER_SUCCESS;
unsigned char *p;
unsigned char *buf;
int readed;
for (readed = 0;;) {
readed = mmfile_read(pData->hFile, buf, AMR_MAX_READ_BUF_SZ);
- if (readed <= 0) break;
+ if (readed <= 0)
+ break;
for (p = buf, pos = 0;;) {
- amrMode = AMR_GET_MODE((*(char *)p));
+ amrMode = (*p >> 3) & 0x0F;
frameLen = AmrModeConfigTable[pData->amrFormat][amrMode].frameSize;
sum_bitrate += AmrModeConfigTable[pData->amrFormat][amrMode].bitRate;
pData->numFrames++;
pos += frameLen;
if (pos == readed) {
break;
- } else if (pos > readed) {
+ } else if (pos > readed) {
mmfile_seek(pData->hFile, (pos - readed), MMFILE_SEEK_CUR);
break;
}
if (frames_bitrate)
pData->bitRate = sum_bitrate / frames_bitrate;
-
- return ret;
}
-
-int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *path)
+static bool __mmfile_amrparser_open(MMFileAMRHandle *handle, const char *path)
{
tMMFILE_AMR_HANDLE *privateData = NULL;
- int ret = 0;
- mm_file_retvm_if_fails(DEBUG, handle, MMFILE_AMR_PARSER_FAIL);
- mm_file_retvm_if_fails(DEBUG, path, MMFILE_AMR_PARSER_FAIL);
+ mm_file_retvm_if_fails(DEBUG, handle, false);
+ mm_file_retvm_if_fails(DEBUG, path, false);
privateData = g_new0(tMMFILE_AMR_HANDLE, 1);
/* Initialize the members of handle */
- _amr_init_handle(privateData);
+ __amr_init_handle(privateData);
- ret = mmfile_open(&privateData->hFile, path, MMFILE_RDONLY);
- if (ret == MMFILE_UTIL_FAIL) {
+ if (mmfile_open(&privateData->hFile, path, MMFILE_RDONLY) == MMFILE_UTIL_FAIL) {
debug_error(DEBUG, "error: mmfile_open\n");
goto exception;
}
goto exception;
}
- ret = _parse_amr_header(privateData);
- if (ret == MMFILE_AMR_PARSER_FAIL) {
+ if (!__parse_amr_header(privateData)) {
debug_error(DEBUG, "Invalid AMR header\n");
goto exception;
}
*handle = privateData;
- return MMFILE_AMR_PARSER_SUCCESS;
-
+ return true;
exception:
if (privateData) {
mmfile_close(privateData->hFile);
mmfile_free(privateData);
*handle = NULL;
}
- return MMFILE_AMR_PARSER_FAIL;
-
+ return false;
}
-
-int mmfile_amrparser_get_stream_info(MMFileAMRHandle handle, tMMFILE_AMR_STREAM_INFO *amrinfo)
+static bool __mmfile_amrparser_get_stream_info(MMFileAMRHandle handle, tMMFILE_AMR_STREAM_INFO *amrinfo)
{
tMMFILE_AMR_HANDLE *privateData = NULL;
- int ret;
- mm_file_retvm_if_fails(DEBUG, handle, MMFILE_AMR_PARSER_FAIL);
- mm_file_retvm_if_fails(DEBUG, amrinfo, MMFILE_AMR_PARSER_FAIL);
+ mm_file_retvm_if_fails(DEBUG, handle, false);
+ mm_file_retvm_if_fails(DEBUG, amrinfo, false);
privateData = (tMMFILE_AMR_HANDLE *) handle;
mmfile_seek(privateData->hFile, privateData->streamOffset, MMFILE_SEEK_SET);
- ret = _parse_amr_stream(privateData);
- mm_file_retvm_if_fails(DEBUG, ret == MMFILE_AMR_PARSER_SUCCESS, ret);
+ __parse_amr_stream(privateData);
amrinfo->duration = privateData->duration;
amrinfo->fileSize = privateData->fileSize;
else
amrinfo->samplingRate = AMR_WB_SAMPLES_PER_SEC;
- return MMFILE_AMR_PARSER_SUCCESS;
+ return true;
}
-
-int mmfile_amrparser_close(MMFileAMRHandle handle)
+static void __mmfile_amrparser_close(MMFileAMRHandle handle)
{
- tMMFILE_AMR_HANDLE *privateData = NULL;
+ tMMFILE_AMR_HANDLE *privateData = (tMMFILE_AMR_HANDLE *)handle;
- mm_file_retvm_if_fails(DEBUG, handle, MMFILE_AMR_PARSER_FAIL);
-
- privateData = (tMMFILE_AMR_HANDLE *) handle;
+ if (!privateData)
+ return;
mmfile_close(privateData->hFile);
-
- return MMFILE_AMR_PARSER_SUCCESS;
}
-
-
/* mm plugin interface */
int mmfile_format_read_stream_amr(MMFileFormatContext *formatContext);
int mmfile_format_read_frame_amr(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame);
int mmfile_format_close_amr(MMFileFormatContext *formatContext);
-EXPORT_API
int mmfile_format_open_amr(MMFileFormatContext *formatContext)
{
MMFileAMRHandle handle = NULL;
- int res = MMFILE_FORMAT_FAIL;
- if (NULL == formatContext || NULL == formatContext->uriFileName) {
- debug_error(DEBUG, "error: mmfile_format_open_amr\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
+ mm_file_retvm_if_fails(DEBUG, formatContext->uriFileName, MMFILE_FORMAT_FAIL);
formatContext->ReadStream = mmfile_format_read_stream_amr;
formatContext->ReadFrame = mmfile_format_read_frame_amr;
formatContext->videoTotalTrackNum = 0;
formatContext->audioTotalTrackNum = 1;
- res = mmfile_amrparser_open(&handle, formatContext->uriFileName);
- if (MMFILE_AMR_PARSER_FAIL == res) {
- debug_error(DEBUG, "mmfile_amrparser_open\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, __mmfile_amrparser_open(&handle, formatContext->uriFileName), MMFILE_FORMAT_FAIL);
formatContext->privateFormatData = handle;
return MMFILE_FORMAT_SUCCESS;
}
-EXPORT_API
int mmfile_format_read_stream_amr(MMFileFormatContext *formatContext)
{
MMFileAMRHandle handle = NULL;
tMMFILE_AMR_STREAM_INFO amrinfo = {0, };
MMFileFormatStream *audioStream = NULL;
- int ret = MMFILE_FORMAT_FAIL;
mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
handle = formatContext->privateFormatData;
- ret = mmfile_amrparser_get_stream_info(handle, &amrinfo);
- mm_file_retvm_if_fails(DEBUG, ret == MMFILE_FORMAT_SUCCESS, ret);
+ mm_file_retvm_if_fails(DEBUG, __mmfile_amrparser_get_stream_info(handle, &amrinfo), MMFILE_FORMAT_FAIL);
formatContext->duration = amrinfo.duration;
formatContext->videoStreamId = -1;
mmfile_format_print_contents(formatContext);
#endif
- return ret;
+ return MMFILE_FORMAT_SUCCESS;
}
-EXPORT_API
int mmfile_format_read_tag_amr(MMFileFormatContext *formatContext)
{
return MMFILE_FORMAT_SUCCESS;
}
-
-EXPORT_API
int mmfile_format_read_frame_amr(MMFileFormatContext *formatContext, unsigned int timestamp, MMFileFormatFrame *frame)
{
debug_error(DEBUG, "error: mmfile_format_read_frame_amr, no handling\n");
return MMFILE_FORMAT_FAIL;
}
-
-EXPORT_API
int mmfile_format_close_amr(MMFileFormatContext *formatContext)
{
- MMFileAMRHandle handle = NULL;
- int ret = MMFILE_FORMAT_FAIL;
+ MMFileAMRHandle handle = NULL;
- if (NULL == formatContext) {
- debug_error(DEBUG, "error: invalid params\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
handle = formatContext->privateFormatData;
- if (NULL != handle) {
- ret = mmfile_amrparser_close(handle);
- if (ret == MMFILE_AMR_PARSER_FAIL) {
- debug_error(DEBUG, "error: mmfile_format_close_amr\n");
- }
- }
+ if (handle)
+ __mmfile_amrparser_close(handle);
mmfile_free(formatContext->streams[MMFILE_AUDIO_STREAM]);
return MMFILE_FORMAT_SUCCESS;
}
-
-