Format AMR cleanup

Change-Id: If3f3a99f621f9119a22ca7a05758708aaab8cd63
Signed-off-by: Minje Ahn <minje.ahn@samsung.com>

diff --git a/formats/ffmpeg/include/mm_file_format_amr.h b/formats/ffmpeg/include/mm_file_format_amr.h
index 08df8fc..1386db2 100755 (executable)
--- a/formats/ffmpeg/include/mm_file_format_amr.h
+++ b/formats/ffmpeg/include/mm_file_format_amr.h
@@ -28,9 +28,6 @@ extern "C" {
 
 #include "mm_file_formats.h"
 
-#define MMFILE_AMR_PARSER_SUCCESS   1
-#define MMFILE_AMR_PARSER_FAIL      0
-
 typedef void* MMFileAMRHandle;
 
 typedef struct _mmfileamrstreaminfo {
@@ -43,11 +40,6 @@ typedef struct _mmfileamrstreaminfo {
        unsigned int    numTracks;
 } tMMFILE_AMR_STREAM_INFO;
 
-
-int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *path);
-int mmfile_amrparser_get_stream_info(MMFileAMRHandle handle, tMMFILE_AMR_STREAM_INFO *amrinfo);
-int mmfile_amrparser_close(MMFileAMRHandle handle);
-
 #ifdef __cplusplus
 }
 #endif

diff --git a/formats/ffmpeg/mm_file_format_amr.c b/formats/ffmpeg/mm_file_format_amr.c
index 39a8674..8812732 100644 (file)
--- a/formats/ffmpeg/mm_file_format_amr.c
+++ b/formats/ffmpeg/mm_file_format_amr.c
@@ -23,17 +23,12 @@
 #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
@@ -52,9 +47,6 @@
 
 #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,
@@ -106,9 +98,7 @@ static const tAmrModeConfig AmrModeConfigTable[2][16] = {
        }
 };
 
-/* 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;
@@ -123,16 +113,14 @@ void _amr_init_handle(tMMFILE_AMR_HANDLE *pData)
        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   \
@@ -145,41 +133,32 @@ int _parse_amr_header(tMMFILE_AMR_HANDLE *pData)
                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;
@@ -191,10 +170,11 @@ int _parse_amr_stream(tMMFILE_AMR_HANDLE *pData)
 
        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++;
@@ -204,7 +184,7 @@ int _parse_amr_stream(tMMFILE_AMR_HANDLE *pData)
                        pos += frameLen;
                        if (pos == readed) {
                                break;
-                       } else  if (pos > readed) {
+                       } else if (pos > readed) {
                                mmfile_seek(pData->hFile, (pos - readed), MMFILE_SEEK_CUR);
                                break;
                        }
@@ -218,26 +198,21 @@ int _parse_amr_stream(tMMFILE_AMR_HANDLE *pData)
 
        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;
        }
@@ -248,8 +223,7 @@ int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *path)
                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;
        }
@@ -263,33 +237,28 @@ int mmfile_amrparser_open(MMFileAMRHandle *handle, const char *path)
 
        *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;
@@ -303,25 +272,19 @@ int mmfile_amrparser_get_stream_info(MMFileAMRHandle handle, tMMFILE_AMR_STREAM_
        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);
@@ -329,16 +292,12 @@ int mmfile_format_read_tag_amr(MMFileFormatContext *formatContext);
 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;
@@ -348,31 +307,24 @@ int mmfile_format_open_amr(MMFileFormatContext *formatContext)
        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;
@@ -396,17 +348,14 @@ int mmfile_format_read_stream_amr(MMFileFormatContext *formatContext)
        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");
@@ -414,26 +363,16 @@ int mmfile_format_read_frame_amr(MMFileFormatContext *formatContext, unsigned in
        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]);
 
@@ -444,5 +383,3 @@ int mmfile_format_close_amr(MMFileFormatContext *formatContext)
 
        return MMFILE_FORMAT_SUCCESS;
 }
-
-