#include "mm_file_format_mmf.h"
#include "mm_file_format_private.h"
-
/**
*MMF
*
*/
-
#define AV_MMF_CONTENTS_CLASS_0 0x00
#define AV_MMF_CONTENTS_CLASS_1 0x20
#define AV_MMF_CONTENTS_CLASS_2 0x10
#define AV_MMF_CONTENTS_TYPE_4 0x40
#define AV_MMF_CONTENTS_TYPE_5 0x50
-
-#define AVMASMW_SUCCESS (0) /* success */
-#define AVMASMW_ERROR (-1) /* error */
-#define AVMASMW_ERROR_ARGUMENT (-2) /* error of arguments */
-#define AVMASMW_ERROR_RESOURCE_OVER (-3) /* over specified resources */
-#define AVMASMW_ERROR_ID (-4) /* error id number */
-#define AVMASMW_ERROR_TIMEOUT (-5) /* timeout */
-#define AVMASMW_ERROR_SOFTRESET (-6) /* error of soft reset for MA-5 */
-
-#define AVMASMW_ERROR_FILE (-16) /* file error */
-#define AVMASMW_ERROR_CONTENTS_CLASS (-17) /* SAVMAF Contents Class shows can't play */
-#define AVMASMW_ERROR_CONTENTS_TYPE (-18) /* SAVMAF Contents Type shows can't play */
-#define AVMASMW_ERROR_CHUNK_SIZE (-19) /* illegal SMAF Chunk Size value */
-#define AVMASMW_ERROR_CHUNK (-20) /* illegal SMAF Track Chunk value */
-#define AVMASMW_ERROR_UNMATCHED_TAG (-21) /* unmathced specified TAG */
-#define AVMASMW_ERROR_SHORT_LENGTH (-22) /* short sequence */
-#define AVMASMW_ERROR_LONG_LENGTH (-23) /* long sequence */
-#define AVMASMW_ERROR_UNSUPPORTED (-24) /* unsupported format */
-#define AVMASMW_ERROR_NO_INFORMATION (-25) /* no specified information */
-#define AVMASMW_ERROR_HV_CONFLICT (-26) /* conflict about HV resource */
-
#define AVMALIB_MAKEDWORD(a, b, c, d) (unsigned int)(((unsigned int)(a) << 24) | \
((unsigned int)(b) << 16) | ((unsigned int)(c) << 8) | (unsigned int)(d))
* define
****************************************************************************/
#define AVMALIB_SIZE_OF_CHUNKHEADER (8)
-#define AVMALIB_SIZE_OF_CRC (2)
-#define AVMALIB_SIZE_OF_MIN_CNTI (5)
-/* for Phrase */
-#define AVMALIB_CNTI_CLASS_YAMAHA (0x00)
-#define AVMALIB_CNTI_TYPE_PHRASE (0xF0)
-#define AVMALIB_PHRASE_TIMEBASE (20)
/* Chunk ID */
#define AVMALIB_CHUNKID_MMMD 0x4D4D4D44
#define AVMALIB_CHUNKCODE_HVP 0x37
#define AVMALIB_CHUNKCODE_MHSC 0x38
-#define AVMALIB_CHUNKCODE_UNKNOWN 0xFF
-
-#define AVMALIB_CHUNK_ID_ERROR -1
-#define AVMALIB_CHUNK_SIZE_ERROR -2
-
#define AV_MMF_MAX_TRACK_NUM 8
#define AV_MMF_MAX_PHRASE_INFO 7
-#define AV_MMF_MAX_EVENT_NUM 10
-#define AV_MMF_MAX_NOTE_OFF_NUM 256
-#define AV_MMF_MAX_STREAM_DATA_NUM2 62
-#define AV_MMF_MAX_STREAM_DATA_NUM3 32
-#define AV_MMF_MAX_VOICE_DATA_NUM2 16
-#define AV_MMF_MAX_WAVE_DATA_NUM3 127
-#define AV_MMF_CHANNEL_NUM 16
-
-#define AV_MMF_FUNC_SUCCESS AVMASMW_SUCCESS
-#define AV_MMF_FUNC_ERROR AVMASMW_ERROR
-
-#define AV_MMF_ERR_ARGUMENT AVMASMW_ERROR_ARGUMENT
-#define AV_MMF_ERR_FILE AVMASMW_ERROR_FILE
-#define AV_MMF_ERR_CLASS AVMASMW_ERROR_CONTENTS_CLASS
-#define AV_MMF_ERR_TYPE AVMASMW_ERROR_CONTENTS_TYPE
-#define AV_MMF_ERR_SIZE AVMASMW_ERROR_CHUNK_SIZE
-#define AV_MMF_ERR_CHUNK AVMASMW_ERROR_CHUNK
-#define AV_MMF_ERR_NOTAG AVMASMW_ERROR_UNMATCHED_TAG
-#define AV_MMF_ERR_SLENGTH AVMASMW_ERROR_SHORT_LENGTH
-#define AV_MMF_ERR_LLENGTH AVMASMW_ERROR_LONG_LENGTH
-#define AV_MMF_ERR_NODATA AVMASMW_ERROR_NO_INFORMATION
-
-#define AV_MMF_SEQ_ID_NULL -1
#define AV_MMF_STATUS_IDLE 0
#define AV_MMF_STATUS_SAT_PROFILE 1
#define AV_MMF_PLAY_TIME_MAX 0x00200000
#define AV_MMF_MA2_VOICE_NOTFOUND 0
#define AV_MMF_MA2_VOICE_FOUND 1
-#define AV_MMF_FM_VOICE_MODE_4OP 0
-#define AV_MMF_FM_VOICE_MODE_2OP 1
-#define AV_MMF_STREAM_ID_INI 0xFF
-#define AV_MMF_STREAM_ID_REGIST 0x00
#define AV_MMF_MA2_VOICE_NULL 0xFF
-#define AV_MMF_MA3_WAVE_NULL 0xFF
-
-
-
-#define AV_MMF_HUFFMAN_TREE_FAILURE 0
-#define AV_MMF_HUFFMAN_TREE_SUCCESS 1
#define AV_MMF_PHRAZE_SIZE_A 8
#define AV_MMF_PHRAZE_SIZE_B 12
#define AV_MMF_SMAF_TYPE_MA3 3
#define AV_MMF_SMAF_TYPE_MA5 5
-#define AV_MMF_FM_MODE_2OP32 0
-#define AV_MMF_FM_MODE_4OP16 1
-#define AV_MMF_P_SOUNDSET_GMX 0
-#define AV_MMF_P_SOUNDSET_GML1 2
-#define AV_MMF_WT_VOLUME_MA3 0
-#define AV_MMF_WT_VOLUME_MA5 4
-
-#define AV_MMF_RESOUCE_MODE_MA3 2
-#define AV_MMF_RESOUCE_MODE_MA12 3
-#define AV_MMF_RESOUCE_MODE_MA5 4
-#define AV_MMF_RESOUCE_MODE_MA5_64 5
-
-#define AV_MMF_SEQUENCETYPE_DERAYED 0
-#define AV_MMF_AL_CHANNEL_NULL 0xFF
#define AV_MMF_HV_CHANNEL_NULL 16
-
-#define AV_MMF_BANK_NUMBER_DEF 0
-#define AV_MMF_PROGRAM_NUMBER_DEF 0
-#define AV_MMF_RESONANCE_DEF 0x40
-#define AV_MMF_BRIGHTNESS_DEF 0x40
-
-#define AV_MMF_SETVOLUME_3RD_PARAM 0x07
-
-#define AV_MMF_LED_SEQ_SYNC_OFF 0
-#define AV_MMF_LED_SEQ_SYNC_ON 1
-#define AV_MMF_VIB_SEQ_SYNC_OFF 0
-#define AV_MMF_VIB_SEQ_SYNC_ON 1
-#define AV_MMF_KEYCONTROL_ON 2
-#define AV_MMF_KEYCONTROL_OFF 1
-#define AV_MMF_KEYCONTROL_DEFAULT 0
-
-#define AV_MMF_EVNET_EOS 0xFF
-
-#define AV_MMF_CHANNEL_MODE_POLY 0
-#define AV_MMF_CHANNEL_MODE_MONO 1
-
-#define AV_MMF_BANK_NUMBER_DEF 0
-#define AV_MMF_PROGRAM_NUMBER_DEF 0
-#define AV_MMF_RPN_DEF 0x7F
-#define AV_MMF_MODULATION_DEF 0
-#define AV_MMF_CHANNEL_VOLUME_DEF 100
-#define AV_MMF_CHANNEL_PAN_DEF 0x40
-#define AV_MMF_EXPRESSION_DEF 0x7F
-#define AV_MMF_HOLD_DEF 0
-#define AV_MMF_MONO_POLY_MODE_DEF AV_MMF_CHANNEL_MODE_POLY
-#define AV_MMF_PITCH_BEND_DEF 0x40
-#define AV_MMF_BEND_RANGE_DEF 2
-#define AV_MMF_OCTAVE_SHIFT_DEF 4
-#define AV_MMF_VELOCITY_DEF_MA3 90
-#define AV_MMF_VELOCITY_DEF_MA5 100
-#define AV_MMF_BLOCK_FNUM_DEF 0
-#define AV_MMF_STREAM_PAIR_DEF 0xFF
-#define AV_MMF_STREAM_PAN_DEF 0xFF
-#define AV_MMF_STREAM_PAN_OFF 0x80
-
-#define SNDDRV_DEF_STREAM_PAN 255
-#define SNDDRV_DEF_RESONANCE 64
-#define SNDDRV_DEF_BRIGHTNESS 64
-#define SNDDRV_DEF_CHANNEL_VOLUME 100
-#define SNDDRV_DEF_CHANNEL_PANPOT 64
-#define SNDDRV_DEF_EXPRESSION 127
-#define SNDDRV_DEF_BENDRANGE 2
-#define SNDDRV_DEF_PITCHBEND 0x2000
-
-#define AV_MMF_CONVERT_PHASE_PLAY 0x00000000
-#define AV_MMF_CONVERT_PHASE_SEEK_G 0x00010000
-#define AV_MMF_CONVERT_PHASE_SEEK_C 0x00020000
-#define AV_MMF_CONVERT_PHASE_SEEK_END 0x00030000
-#define AV_MMF_CONVERT_PHASE_PLAY_END 0x00FF0000
-
-#define AV_MMF_SEEK_EVENT_END 0xFFFF
-
-/****************************************************************************
- * definition of resources
- ****************************************************************************/
-#define AVMAPLIB_MAX_LV2_VOICES (16)
-
/****************************************************************************
* typedef
****************************************************************************/
HVINFO sHV_Info;
} LOADINFO, *PLOADINFO;
-/* Stream information structure(for MA-2) */
-typedef struct AvTagStreamInfo2 {
- unsigned char bStrmID; /* key number of stream */
- unsigned char *pbWave; /* pointer to Awa body */
- unsigned int dWaveSize; /* size of Awa body */
- unsigned int dFs; /* sampling frequency */
-} STREAMINFO2, *PSTREAMINFO2;
-
-/* Stream information structure(for MA-3/5) */
-typedef struct AvTagStreamInfo3 {
- unsigned char fbNote; /* stream data flag */
- unsigned char bPairID; /* stream pair ID */
- unsigned char bPan; /* stream pan */
-} STREAMINFO3, *PSTREAMINFO3;
-
-/* Stream information structure */
-typedef struct AvTagStreamInfo {
- STREAMINFO2 sStream_Info2[AV_MMF_MAX_STREAM_DATA_NUM2];
- STREAMINFO3 sStream_Info3[AV_MMF_MAX_STREAM_DATA_NUM3];
-} STREAMINFO, *PSTREAMINFO;
-
-/* Voice information structure(for MA-1/2) */
-typedef struct AvTagVoiceInfo2 {
- unsigned char bBank; /* bank number */
- unsigned char bProg; /* program number */
-} VOICEINFO2, *PVOICEINFO2;
-
-/* Wave information structure(for MA-3/5) */
-typedef struct AvTagWaveInfo3 {
- unsigned int dAdrs; /* wave address */
- unsigned int dSize; /* wave data size */
-} WAVEINFO3, *PWAVEINFO3;
-
-/* Voice information structure */
-typedef struct AvTagVoiceInfo {
- VOICEINFO2 sVoice_Info2[AV_MMF_MAX_VOICE_DATA_NUM2];
- WAVEINFO3 sWave_Info3[AV_MMF_MAX_WAVE_DATA_NUM3];
-} VOICEINFO, *PVOICEINFO;
-
-/* Channel information structure */
-typedef struct AvTagChannelInfo {
- unsigned char bBankM; /* bank select MSB */
- unsigned char bBankL; /* bank select LSB */
- unsigned char bBank; /* bank number (sound driver) */
- unsigned char bProg; /* program change */
- unsigned char bRpnM; /* RPN MSB */
- unsigned char bRpnL; /* RPN LSB */
- unsigned char bMod; /* modulation */
- unsigned char bChVol; /* channel volume */
- unsigned char bPan; /* channel pan */
- unsigned char bExp; /* expression */
- unsigned char bHold; /* hold */
- unsigned char bMono; /* channel mode mono/poly */
- unsigned char bPitch; /* pitch bend (MSB) */
- unsigned char bSens1; /* pitch bend lenge 1 */
- unsigned char bSens2; /* pitch bend lenge 2 */
- unsigned char bOct; /* octerve shift */
- unsigned char bVel; /* note on velocity */
- unsigned char bBlockFnum1; /* ma-2 pitch bend (0xB0) */
- unsigned char bBlockFnum2; /* ma-2 pitch bend (0xC0) */
- unsigned char fbLed; /* LED synchronous flag */
- unsigned char fbVib; /* Motor synchronous flag */
-} CHANNELINFO, *PCHANNELINFO;
-
-/* Event information structure */
-typedef struct AvTagEventBlock {
- unsigned int dEventTime; /* event activation time */
- unsigned int dSeqID; /* sequencer ID (sound driver) */
- unsigned int dCmd; /* command ID (sound driver) */
- unsigned int dParam1; /* parameter 1 */
- unsigned int dParam2; /* parameter 2 */
- unsigned int dParam3; /* parameter 3 */
- unsigned char *pbSeq; /* pointer to next event data */
- unsigned int dIndex; /* index of next event */
- unsigned int dTrackNo; /* track no. */
- void *pvNext; /* pointer to next event block */
-} EVENTBLOCK, *PEVENTBLOCK;
-
-/* Note OFF information structure */
-typedef struct AvTagNoteOffBlock {
- unsigned int dOffTime; /* note off activation time */
- unsigned int dSeqID; /* sequencer ID (sound driver) */
- unsigned int dCmd; /* command ID (sound driver) */
- unsigned int dCh; /* channel no. */
- unsigned int dKey; /* key no. */
- void *pvNext; /* pointer to next note off block */
-} OFFBLOCK, *POFFBLOCK;
-
-/* Playback information structure */
-typedef struct AvTagPlayInfo {
- PEVENTBLOCK psNextEvent; /* pointer to next event block */
- PEVENTBLOCK psEmptyEvent; /* pointer to empty event block */
- POFFBLOCK psNextOff; /* pointer to next note off block */
- POFFBLOCK psEmptyOff; /* pointer to empty note off block */
- unsigned int dSmafType; /* SMAF Type */
- unsigned int dHWTimeBase; /* tick to H/W time base */
- unsigned int dPlayTime; /* play time (tick) */
- unsigned int dStartTime; /* start time (start point tick) */
- unsigned int dSeekTime; /* seek time (msec) */
- unsigned int dSeekError; /* seek time error (msec) */
- unsigned int dRamAdrs; /* ram address */
- unsigned int dRamSize; /* ram size */
- unsigned int dSeekParam; /* seek event flag */
- unsigned int dPastTime; /* past time (tick) */
- unsigned char bMasterVol; /* master volume (sequence) */
- unsigned char bEos; /* EOS flag */
- unsigned short fwMono; /* channel mode change flag */
- unsigned char bResonance; /* resonance */
- unsigned char bBrightness; /* brightness */
- unsigned char bStreamReserve; /* stream reserve */
- unsigned char bAlChReserve; /* AL channel number */
- unsigned char bHVChannel; /* HV channel number */
- unsigned char bFmVoice; /* FM Voice Mode 0:4op, 1:2op */
- unsigned char (*pfnGetByte)(void); /* pointer to byte get function */
- int (*pfnGetEvent)(void); /* pointer to event get function */
- STREAMINFO sStream_Info;
- VOICEINFO sVoice_Info;
- CHANNELINFO sChannel_Info[AV_MMF_CHANNEL_NUM + 1];
- EVENTBLOCK sEvent_Block[AV_MMF_MAX_EVENT_NUM];
- OFFBLOCK sNoteOff_Block[AV_MMF_MAX_NOTE_OFF_NUM];
-} PLAYINFO, *PPLAYINFO;
-
/* SMAF information structure */
typedef struct AvTagSmafInfo {
- int sdMmfSeqID; /* sequence id (sound driver) */
unsigned int dStatus; /* converter status */
LOADINFO sLoad_Info[2];
- PLAYINFO sPlay_Info;
} SMAFINFO, *PSMAFINFO;
static SMAFINFO g_sSmaf_Info;
static const unsigned short g_awBitMaskTable2[8] = {0x00FF, 0x01FE, 0x03FC, 0x07F8, 0x0FF0, 0x1FE0, 0x3FC0, 0x7F80};
/* internals */
-static int mmf_file_mmf_get_duration(char *src, int is_xmf);
-
-
+static int __mmf_file_mmf_get_duration(char *src, int is_xmf);
/* mm plugin porting */
/* plugin manadatory API */
int mmfile_format_read_tag_mmf(MMFileFormatContext *formatContext);
int mmfile_format_close_mmf(MMFileFormatContext *formatContext);
-
-
int mmfile_format_open_mmf(MMFileFormatContext *formatContext)
{
- int ret = 0;
-
- if (NULL == formatContext) {
- debug_error(DEBUG, "error: formatContext is NULL\n");
- return MMFILE_FORMAT_FAIL;
- }
-
- ret = MMFileFormatIsValidMMF(NULL, formatContext->uriFileName, 0);
- if (ret == 0) {
- debug_error(DEBUG, "error: it is not MMF file\n");
- return MMFILE_FORMAT_FAIL;
- }
+ mm_file_retvm_if_fails(DEBUG, formatContext, MMFILE_FORMAT_FAIL);
+ mm_file_retvm_if_fails(DEBUG, MMFileFormatIsValidMMF(NULL, formatContext->uriFileName, 0), MMFILE_FORMAT_FAIL);
formatContext->ReadStream = mmfile_format_read_stream_mmf;
formatContext->ReadFrame = mmfile_format_read_frame_mmf;
{
int total = 0;
- total = mmf_file_mmf_get_duration(formatContext->uriFileName, 0 /*not XMF*/);
- mm_file_retvm_if_fails(DEBUG, total >= 0, MMFILE_FORMAT_FAIL);
+ total = __mmf_file_mmf_get_duration(formatContext->uriFileName, 0 /*not XMF*/);
+ mm_file_retvm_if_fails(DEBUG, total > 0, MMFILE_FORMAT_FAIL);
formatContext->duration = total;
formatContext->audioTotalTrackNum = 1;
}
-
int mmfile_format_read_tag_mmf(MMFileFormatContext *formatContext)
{
return MMFILE_FORMAT_SUCCESS;
}
-/*********************************************************************************
- * _mmf_Get4Byte
- *
- * Description:
- * SMAF data load (error check and regist)
- * Argument:
- * pbBuf pointer to top data
- * Return:
- * nothing
- ********************************************************************************/
-static unsigned int
-_mmf_Get4Byte(unsigned char *pbBuf)
+static unsigned int _mmf_Get4Byte(unsigned char *pbBuf)
{
return (unsigned int)((((unsigned int)pbBuf[0]) << 24) +
(((unsigned int)pbBuf[1]) << 16) +
((unsigned int)pbBuf[3]));
}
-
-/*********************************************************************************
- * _mmf_CheckInitial
- *
- * Description:
- * SMAF data load (error check and regist)
- * Argument:
- * psLoad pointer to load information structure
- * Return:
- * nothing
- ********************************************************************************/
-static void
-_mmf_CheckInitial(PLOADINFO psLoad)
+static void _mmf_CheckInitial(PLOADINFO psLoad)
{
unsigned char i;
psLoad->sHV_Info.bHvChannel = AV_MMF_HV_CHANNEL_NULL;
}
-
-/*********************************************************************************
- * _mmf_CheckInitial
- *
- * Description:
- * get time base (data value -> msec/tick)
- * Argument:
- * bData time base (data value)
- * Return:
- * >=0 success(time base (msec/tick))
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_GetTimebase(unsigned char bData)
+static unsigned int _mmf_GetTimebase(unsigned char bData)
{
switch (bData) {
case 0x02:
case 0x13:
return 50; /* 50[msec/tick] */
default:
- return AV_MMF_FUNC_ERROR; /* Time Base Error */
+ return MMFILE_FORMAT_FAIL; /* Time Base Error */
}
}
{ AVMALIB_CHUNKID_HVP, AVMALIB_CHUNKCODE_HVP, AVMALIB_CHUNK_PHASE_MTHVSUB },
};
-static int
-_mmf_MalibNextChunk(unsigned char *pbFile, unsigned int dSize, unsigned int dState, unsigned int *pdChunkID, unsigned int *pdChunkNo)
+static bool __mmf_MalibNextChunk(unsigned char *pbFile,
+ unsigned int dSize,
+ unsigned int dState,
+ unsigned int *pdChunkID,
+ unsigned int *pdChunkNo,
+ unsigned int *pdChunkSize)
{
- unsigned int dChunkID, dChunkSize;
+ unsigned int dChunkID;
unsigned int dIdx = 0;
unsigned int dTableSize = sizeof(_mmf_malib_chunk_table) / sizeof(_mmf_malib_chunk_s);
unsigned int dSubTableSize = sizeof(_mmf_malib_chunk_sub_table) / sizeof(_mmf_malib_chunk_s);
if (dSize < AVMALIB_SIZE_OF_CHUNKHEADER)
- return AVMALIB_CHUNK_SIZE_ERROR;
+ return false;
dChunkID = AVMALIB_MAKEDWORD(pbFile[0], pbFile[1], pbFile[2], pbFile[3]);
- dChunkSize = AVMALIB_MAKEDWORD(pbFile[4], pbFile[5], pbFile[6], pbFile[7]);
+ *pdChunkSize = AVMALIB_MAKEDWORD(pbFile[4], pbFile[5], pbFile[6], pbFile[7]);
- if (dChunkSize > (dSize - AVMALIB_SIZE_OF_CHUNKHEADER))
- return AVMALIB_CHUNK_SIZE_ERROR;
+ if (*pdChunkSize > (dSize - AVMALIB_SIZE_OF_CHUNKHEADER))
+ return false;
for (dIdx = 0; dIdx < dTableSize; dIdx++) {
if (dChunkID == _mmf_malib_chunk_table[dIdx].dChunkID) {
*pdChunkID = _mmf_malib_chunk_table[dIdx].dChunkCode;
if (dState != _mmf_malib_chunk_table[dIdx].dState)
- return AVMALIB_CHUNK_ID_ERROR;
+ return false;
break;
}
}
if ((dChunkID & 0xFFFFFF00) == _mmf_malib_chunk_sub_table[dIdx].dChunkID) {
*pdChunkID = _mmf_malib_chunk_sub_table[dIdx].dChunkCode;
if (dState != _mmf_malib_chunk_sub_table[dIdx].dState)
- return AVMALIB_CHUNK_ID_ERROR;
+ return false;
break;
}
}
}
- return (int)dChunkSize;
+ return true;
}
-
-
-/*********************************************************************************
- * _mmf_MTRCheck
- *
- * Description:
- * score track chunk check (header information and chunk construction)
- * Argument:
- * psTrack pointer to track information structure
- * bSmafType SMAF type
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_MTRCheck(PTRACKINFO psTrack, unsigned char bSmafType)
+static bool __mmf_MTRCheck(PTRACKINFO psTrack, unsigned char bSmafType)
{
- int sdResult, sdChunkSize;
- unsigned int dSize, dIndex;
- unsigned char *pbBuf;
- unsigned int dChunkID, dChunkNo;
+ unsigned int dSize, dIndex, dResult, dChunkSize;
+ unsigned char *pbBuf;
+ unsigned int dChunkID, dChunkNo;
- /* Check Format Type */
+ /* Check Format Type */
switch (bSmafType) {
case AV_MMF_SMAF_TYPE_MA1:
case AV_MMF_SMAF_TYPE_MA2:
- if (psTrack->pbMtr[0] != 0x00) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (psTrack->pbMtr[0] != 0x00)
+ return false;
break;
case AV_MMF_SMAF_TYPE_MA3:
- if ((psTrack->pbMtr[0] != 0x01) && (psTrack->pbMtr[0] != 0x02)) {
- return AV_MMF_ERR_CHUNK;
- }
+ if ((psTrack->pbMtr[0] != 0x01) && (psTrack->pbMtr[0] != 0x02))
+ return false;
break;
case AV_MMF_SMAF_TYPE_MA5:
- if (psTrack->pbMtr[0] != 0x02) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (psTrack->pbMtr[0] != 0x02)
+ return false;
break;
default:
break;
}
- /* Check Sequence Type */
- if (psTrack->pbMtr[1] != 0x00) {
- return AV_MMF_ERR_CHUNK;
- }
+ /* Check Sequence Type */
+ mm_file_retv_if_fails(psTrack->pbMtr[1] == 0x00, false);
- /* Check Time Base */
- if (psTrack->pbMtr[2] != psTrack->pbMtr[3]) {
- return AV_MMF_ERR_CHUNK;
- }
- sdResult = _mmf_GetTimebase(psTrack->pbMtr[2]);
- if (sdResult == AV_MMF_FUNC_ERROR) {
- return AV_MMF_ERR_CHUNK;
- }
- psTrack->dTimeBase = (unsigned int)sdResult;
+ /* Check Time Base */
+ mm_file_retv_if_fails(psTrack->pbMtr[2] == psTrack->pbMtr[3], false);
+
+ dResult = _mmf_GetTimebase(psTrack->pbMtr[2]);
+ mm_file_retv_if_fails(dResult != MMFILE_FORMAT_FAIL, false);
+
+ psTrack->dTimeBase = dResult;
/* Check sub chunk disposition */
if ((bSmafType == AV_MMF_SMAF_TYPE_MA1) || (bSmafType == AV_MMF_SMAF_TYPE_MA2))
dIndex = AV_MMF_MINIMUM_TRACKSIZE2;
else
dIndex = AV_MMF_MINIMUM_TRACKSIZE3;
+
pbBuf = psTrack->pbMtr;
dSize = psTrack->dMtrSize;
+
while (dSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE)) {
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_MTRSUB, &dChunkID, &dChunkNo);
- if (sdChunkSize < 0) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (!__mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_MTRSUB, &dChunkID, &dChunkNo, &dChunkSize))
+ return false;
+
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
switch (dChunkID) {
case AVMALIB_CHUNKCODE_MSPI:
psTrack->pbMspi = &(pbBuf[dIndex]);
- psTrack->dMspiSize = sdChunkSize;
+ psTrack->dMspiSize = dChunkSize;
break;
case AVMALIB_CHUNKCODE_MTSU:
psTrack->pbMtsu = &(pbBuf[dIndex]);
- psTrack->dMtsuSize = sdChunkSize;
+ psTrack->dMtsuSize = dChunkSize;
break;
case AVMALIB_CHUNKCODE_MTSQ:
psTrack->pbMtsq = &(pbBuf[dIndex]);
- psTrack->dMtsqSize = sdChunkSize;
+ psTrack->dMtsqSize = dChunkSize;
break;
case AVMALIB_CHUNKCODE_MTSP:
psTrack->pbMtsp = &(pbBuf[dIndex]);
- psTrack->dMtspSize = sdChunkSize;
+ psTrack->dMtspSize = dChunkSize;
break;
case AVMALIB_CHUNKCODE_MTHV:
psTrack->pbMthv = &(pbBuf[dIndex]);
- psTrack->dMthvSize = sdChunkSize;
+ psTrack->dMthvSize = dChunkSize;
break;
default:
break;
}
- dIndex += sdChunkSize;
+ dIndex += dChunkSize;
}
- if ((psTrack->pbMtsq == NULL) || (psTrack->dMtsqSize == 0)) {
- return AV_MMF_ERR_SLENGTH;
- }
- return AV_MMF_FUNC_SUCCESS;
-}
+ if ((psTrack->pbMtsq == NULL) || (psTrack->dMtsqSize == 0))
+ return false;
+ return true;
+}
-/*********************************************************************************
- * _mmf_ATRCheck
- *
- * Description:
- * audio track chunk check (header information and chunk construction)
- * Argument:
- * psTrack pointer to track information structure
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_ATRCheck(PTRACKINFO psTrack)
+static bool __mmf_ATRCheck(PTRACKINFO psTrack)
{
- int sdResult, sdChunkSize;
- unsigned int dSize, dIndex;
- unsigned char *pbBuf;
- unsigned int dChunkID, dChunkNo;
- unsigned char fbWave;
-
- /* Check Format Type */
- if (psTrack->pbMtr[0] != 0x00) {
- return AV_MMF_ERR_CHUNK;
- }
+ unsigned int dSize, dIndex, dResult, dChunkSize;
+ unsigned char *pbBuf;
+ unsigned int dChunkID, dChunkNo;
+ unsigned char fbWave = AV_MMF_MA2_VOICE_NULL;
- /* Check Sequence Type */
- if (psTrack->pbMtr[1] != 0x00) {
- return AV_MMF_ERR_CHUNK;
- }
+ /* Check Format Type */
+ mm_file_retv_if_fails(psTrack->pbMtr[0] == 0x00, false);
- /* Check Wave Type */
- if (((psTrack->pbMtr[2] != 0x10) && (psTrack->pbMtr[2] != 0x11)) || ((psTrack->pbMtr[3] & 0xF0) != 0x00)) {
- return AV_MMF_ERR_CHUNK;
- }
+ /* Check Sequence Type */
+ mm_file_retv_if_fails(psTrack->pbMtr[1] == 0x00, false);
- /* Check Time Base */
- if (psTrack->pbMtr[4] != psTrack->pbMtr[5]) {
- return AV_MMF_ERR_CHUNK;
- }
- sdResult = _mmf_GetTimebase(psTrack->pbMtr[4]);
- if (sdResult == AV_MMF_FUNC_ERROR) {
- return AV_MMF_ERR_CHUNK;
- }
- psTrack->dTimeBase = (unsigned int)sdResult;
+ /* Check Wave Type */
+ mm_file_retv_if_fails(psTrack->pbMtr[2] == 0x10 || psTrack->pbMtr[2] == 0x11, false);
+ mm_file_retv_if_fails((psTrack->pbMtr[3] & 0xF0) == 0x00, false);
+
+ /* Check Time Base */
+ mm_file_retv_if_fails(psTrack->pbMtr[4] == psTrack->pbMtr[5], false);
+
+ dResult = _mmf_GetTimebase(psTrack->pbMtr[4]);
+ mm_file_retv_if_fails(dResult != MMFILE_FORMAT_FAIL, false);
+
+ psTrack->dTimeBase = dResult;
pbBuf = psTrack->pbMtr;
dSize = psTrack->dMtrSize;
dIndex = 6;
- fbWave = AV_MMF_MA2_VOICE_NULL;
/* Check sub chunk disposition */
while (dSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE)) {
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_ATRSUB, &dChunkID, &dChunkNo);
- if (sdChunkSize < 0) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (!__mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_ATRSUB, &dChunkID, &dChunkNo, &dChunkSize))
+ return false;
+
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
switch (dChunkID) {
case AVMALIB_CHUNKCODE_ASPI:
psTrack->pbMspi = &(pbBuf[dIndex]);
- psTrack->dMspiSize = sdChunkSize;
+ psTrack->dMspiSize = dChunkSize;
break;
case AVMALIB_CHUNKCODE_ATSQ:
psTrack->pbMtsq = &(pbBuf[dIndex]);
- psTrack->dMtsqSize = sdChunkSize;
+ psTrack->dMtsqSize = dChunkSize;
break;
case AVMALIB_CHUNKCODE_AWA:
if ((0x01 <= dChunkNo) && (dChunkNo <= 0x3E))
default:
break;
}
- dIndex += sdChunkSize;
+ dIndex += dChunkSize;
}
- if ((psTrack->pbMtsq == NULL) || (psTrack->dMtsqSize == 0) || (fbWave == AV_MMF_MA2_VOICE_NULL)) {
- return AV_MMF_ERR_SLENGTH;
- }
- return AV_MMF_FUNC_SUCCESS;
-}
+ if ((psTrack->pbMtsq == NULL) || (psTrack->dMtsqSize == 0) || (fbWave == AV_MMF_MA2_VOICE_NULL))
+ return false;
+ return true;
+}
-/*********************************************************************************
- * _mmf_MspICheck
- *
- * Description:
- * seek & phrase info chunk check (get phrase information)
- * Argument:
- * psTrack pointer to track information structure
- * psPhrase pointer to phrase information structure
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static void
-_mmf_MspICheck(PTRACKINFO psTrack, PPHRASEINFO psPhrase)
+static void __mmf_MspICheck(PTRACKINFO psTrack, PPHRASEINFO psPhrase)
{
- unsigned char *pbBuf;
- unsigned int dSize, dIndex;
- unsigned short wTag;
+ unsigned char *pbBuf;
+ unsigned int dSize, dIndex;
+ unsigned short wTag;
if (psTrack->pbMspi == NULL)
return;
while (dSize >= dIndex + AV_MMF_PHRAZE_SIZE_A) {
wTag = (unsigned short)((((unsigned short)pbBuf[dIndex]) << 8) + (unsigned short)pbBuf[dIndex + 1]);
switch (wTag) {
- case AV_MMF_TAG_STARTPOINT: /* start point */
+ case AV_MMF_TAG_STARTPOINT: /* start point */
psTrack->dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
dIndex += AV_MMF_PHRAZE_SIZE_A;
break;
- case AV_MMF_TAG_STOPPOINT: /* stop point */
+ case AV_MMF_TAG_STOPPOINT: /* stop point */
psTrack->dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
dIndex += AV_MMF_PHRAZE_SIZE_A;
break;
- case AV_MMF_TAG_PHRASE_A: /* A melody */
+ case AV_MMF_TAG_PHRASE_A: /* A melody */
if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
return;
psPhrase[0].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
psPhrase[0].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
dIndex += AV_MMF_PHRAZE_SIZE_B;
break;
- case AV_MMF_TAG_PHRASE_B: /* B melody */
+ case AV_MMF_TAG_PHRASE_B: /* B melody */
if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
return;
psPhrase[1].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
psPhrase[1].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
dIndex += AV_MMF_PHRAZE_SIZE_B;
break;
- case AV_MMF_TAG_PHRASE_E: /* Ending */
+ case AV_MMF_TAG_PHRASE_E: /* Ending */
if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
return;
psPhrase[2].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
psPhrase[2].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
dIndex += AV_MMF_PHRAZE_SIZE_B;
break;
- case AV_MMF_TAG_PHRASE_I: /* Intro */
+ case AV_MMF_TAG_PHRASE_I: /* Intro */
if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
return;
psPhrase[3].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
psPhrase[3].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
dIndex += AV_MMF_PHRAZE_SIZE_B;
break;
- case AV_MMF_TAG_PHRASE_K: /* Interlude */
+ case AV_MMF_TAG_PHRASE_K: /* Interlude */
if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
return;
psPhrase[4].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
psPhrase[4].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
dIndex += AV_MMF_PHRAZE_SIZE_B;
break;
- case AV_MMF_TAG_PHRASE_R: /* Refrain */
+ case AV_MMF_TAG_PHRASE_R: /* Refrain */
if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
return;
psPhrase[5].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
psPhrase[5].dStopPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 7]));
dIndex += AV_MMF_PHRAZE_SIZE_B;
break;
- case AV_MMF_TAG_PHRASE_S: /* Bridge */
+ case AV_MMF_TAG_PHRASE_S: /* Bridge */
if (dSize < dIndex + AV_MMF_PHRAZE_SIZE_B)
return;
psPhrase[6].dStartPoint = _mmf_Get4Byte(&(pbBuf[dIndex + 3]));
return;
}
}
- return;
}
-
-/*********************************************************************************
- * _mmf_STSPCheck
- *
- * Description:
- * track chunk check (offset of start point and stop point)
- * Argument:
- * psTrack pointer to track information structure
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_STSPCheck(PTRACKINFO psTrack)
+static bool __mmf_STSPCheck(PTRACKINFO psTrack)
{
- unsigned int dStart, dStop, dSize;
+ unsigned int dStart, dStop, dSize;
- dSize = psTrack->dMtsqSize;
+ dSize = psTrack->dMtsqSize;
if (psTrack->dStartPoint == AV_MMF_STSP_OFFSET_NULL)
dStart = 0;
dStop = psTrack->dStopPoint;
if ((dStart >= dStop) || (dStart > dSize) || (dStop > dSize))
- return AV_MMF_ERR_CHUNK;
+ return false;
- return AV_MMF_FUNC_SUCCESS;
+ return true;
}
-
-/*********************************************************************************
- * _mmf_MtsuCheck2
- *
- * Description:
- * track chunk check (existence voice parameter)
- * Argument:
- * psTrack pointer to track information structure
- * bSmafType SMAF type
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_MtsuCheck2(PTRACKINFO psTrack, unsigned char bSmafType)
+static bool __mmf_MtsuCheck2(PTRACKINFO psTrack, unsigned char bSmafType)
{
- unsigned char *pbBuf;
- unsigned int dSize, dIndex;
+ unsigned char *pbBuf;
+ unsigned int dSize, dIndex;
- if (psTrack->pbMtsu == NULL) {
- return AV_MMF_MA2_VOICE_NOTFOUND;
- }
+ mm_file_retv_if_fails(psTrack->pbMtsu, false);
pbBuf = psTrack->pbMtsu;
dSize = psTrack->dMtsuSize;
dIndex = 0;
while (dSize > dIndex + 20) {
- if ((pbBuf[dIndex] != 0xFF) || (pbBuf[dIndex + 1] != 0xF0)) {
- return AV_MMF_MA2_VOICE_NOTFOUND;
- }
+ if ((pbBuf[dIndex] != 0xFF) || (pbBuf[dIndex + 1] != 0xF0))
+ return false;
+
if (pbBuf[dIndex + 3] == 0x43) {
if ((bSmafType == AV_MMF_SMAF_TYPE_MA1) && (pbBuf[dIndex + 4] == 0x02))
- return AV_MMF_MA2_VOICE_FOUND;
+ return true;
if ((bSmafType == AV_MMF_SMAF_TYPE_MA2) && (pbBuf[dIndex + 4] == 0x03))
- return AV_MMF_MA2_VOICE_FOUND;
+ return true;
}
dIndex += (pbBuf[dIndex + 2] + 3);
}
- return AV_MMF_MA2_VOICE_NOTFOUND;
+ return false;
}
-
-/*********************************************************************************
- * _mmf_GetFlex2L
- *
- * Description:
- * get flex data (duration, gate time)
- * Argument:
- * pbBuf pointer to data top
- * dSize size of data (remain)
- * pdRead pointer to size of flex data
- * Return:
- * >=0 success(flex data value)
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_GetFlex2L(unsigned char *pbBuf, unsigned int dSize, unsigned int *pbRead)
+static bool __mmf_GetFlex2L(unsigned char *pbBuf, unsigned int dSize, unsigned int *pbRead, unsigned int *pdFlex)
{
- int sdTemp;
+ unsigned int dTemp = 0;
if ((dSize < 1) || ((dSize < 2) && (pbBuf[0] >= 0x80)))
- return AV_MMF_FUNC_ERROR;
+ return false;
if (dSize >= 4) {
- sdTemp = pbBuf[0] + pbBuf[1] + pbBuf[2] + pbBuf[3];
- if (sdTemp == 0)
- return AV_MMF_FUNC_ERROR;
+ dTemp = pbBuf[0] + pbBuf[1] + pbBuf[2] + pbBuf[3];
+ if (dTemp == 0)
+ return false;
}
+
if (pbBuf[0] >= 0x80) {
- sdTemp = (int)((((int)(pbBuf[0] & 0x7F)) << 7) + ((int)(pbBuf[1] & 0x7F)) + 128);
+ *pdFlex = (((unsigned int)(pbBuf[0] & 0x7F)) << 7) + ((unsigned int)(pbBuf[1] & 0x7F)) + 128;
*pbRead = 2;
} else {
- sdTemp = (int)(pbBuf[0] & 0x7F);
+ *pdFlex = (unsigned int)(pbBuf[0] & 0x7F);
*pbRead = 1;
}
- return sdTemp;
-}
+ return true;
+}
-/*********************************************************************************
- * _mmf_SeqDataCheck2
- *
- * Description:
- * track chunk check (sequence massage)
- * Argument:
- * psTrack pointer to track information structure
- * bSmafType SMAF type
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_SeqDataCheck2(PTRACKINFO psTrack, unsigned char bSmafType)
+static bool __mmf_SeqDataCheck2(PTRACKINFO psTrack, unsigned char bSmafType)
{
- unsigned char *pbBuf;
- unsigned int dSize, dIndex;
- int sdTemp;
- unsigned int dPast, dGate, dFlexSize;
+ unsigned char *pbBuf;
+ unsigned int dSize, dIndex;
+ unsigned int dPast, dGate, dFlexSize, dTemp;
- if (psTrack->pbMtsq == NULL) {
- return AV_MMF_ERR_SLENGTH;
- }
+ mm_file_retv_if_fails(psTrack->pbMtsq, false);
dPast = 0;
dGate = 0;
}
if (dSize >= dIndex + 4) {
- sdTemp = pbBuf[dIndex] + pbBuf[dIndex + 1] + pbBuf[dIndex + 2] + pbBuf[dIndex + 3];
- if (sdTemp == 0) {
+ dTemp = pbBuf[dIndex] + pbBuf[dIndex + 1] + pbBuf[dIndex + 2] + pbBuf[dIndex + 3];
+ if (dTemp == 0) {
/* EOS */
if (bSmafType == AV_MMF_SMAF_TYPE_MA1)
psTrack->dStopTick = dPast + dGate;
}
}
- sdTemp = _mmf_GetFlex2L(&pbBuf[dIndex], (dSize - dIndex), &dFlexSize);
- if (sdTemp < 0) {
- return AV_MMF_ERR_CHUNK;
- }
- dPast += sdTemp;
- if (dPast >= AV_MMF_PLAY_TIME_MAX) {
- return AV_MMF_ERR_LLENGTH;
- }
+ if (!__mmf_GetFlex2L(&pbBuf[dIndex], (dSize - dIndex), &dFlexSize, &dTemp))
+ return false;
- if ((unsigned int)sdTemp >= dGate) /* calculate remain of GT */
+ dPast += dTemp;
+ if (dPast >= AV_MMF_PLAY_TIME_MAX)
+ return false;
+
+ if (dTemp >= dGate) /* calculate remain of GT */
dGate = 0;
else
- dGate -= sdTemp;
+ dGate -= dTemp;
dIndex += dFlexSize;
- if (dSize < dIndex + 2) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (dSize < dIndex + 2)
+ return false;
switch (pbBuf[dIndex]) {
case 0x00:
dIndex += 2;
break;
case 0xF0:
- if (dSize < dIndex + 3) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (dSize < dIndex + 3)
+ return false;
+
dIndex += (pbBuf[dIndex + 2] + 3);
- if (dSize < dIndex) {
- return AV_MMF_ERR_CHUNK;
- }
- if (pbBuf[dIndex - 1] != 0xF7) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (dSize < dIndex)
+ return false;
+
+ if (pbBuf[dIndex - 1] != 0xF7)
+ return false;
break;
default:
- return AV_MMF_ERR_CHUNK;
+ return false;
}
break;
default:
- sdTemp = _mmf_GetFlex2L(&pbBuf[dIndex + 1], (dSize - dIndex - 1), &dFlexSize);
- if (sdTemp < 0) {
- return AV_MMF_ERR_CHUNK;
- }
- if (dGate < (unsigned int)sdTemp)
- dGate = (unsigned int)sdTemp;
+ if (!__mmf_GetFlex2L(&pbBuf[dIndex + 1], (dSize - dIndex - 1), &dFlexSize, &dTemp))
+ return false;
+
+ if (dGate < dTemp)
+ dGate = dTemp;
+
dIndex += (1 + dFlexSize);
break;
}
- if (dSize < dIndex) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (dSize < dIndex)
+ return false;
}
if (psTrack->dStartTick == AV_MMF_STSP_TIME_NULL) {
- if (psTrack->dStartPoint != AV_MMF_STSP_OFFSET_NULL) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (psTrack->dStartPoint != AV_MMF_STSP_OFFSET_NULL)
+ return false;
+
psTrack->dStartTick = 0;
}
/* check start/stop point potision */
if (psTrack->dStopTick == AV_MMF_STSP_TIME_NULL) {
- if ((psTrack->dStopPoint != AV_MMF_STSP_OFFSET_NULL) && (psTrack->dStopPoint != dIndex)) {
- return AV_MMF_ERR_CHUNK;
- }
+ if ((psTrack->dStopPoint != AV_MMF_STSP_OFFSET_NULL) && (psTrack->dStopPoint != dIndex))
+ return false;
+
if (bSmafType == AV_MMF_SMAF_TYPE_MA1)
psTrack->dStopTick = dPast + dGate;
else
debug_msg(RELEASE, "Play time: %u\n", psTrack->dPlayTime);
- return AV_MMF_FUNC_SUCCESS;
+ return true;
}
-
-/*********************************************************************************
- * TrackChunk_Check2
- *
- * Description:
- * MA-1/2 track chunk check
- * Argument:
- * psLoad pointer to load information structure
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_TrackChunkCheck2(PLOADINFO psLoad)
+static bool __mmf_TrackChunkCheck2(PLOADINFO psLoad)
{
- PTRACKINFO psTrack;
- int sdResult;
- unsigned char i, fbVoice;
+ PTRACKINFO psTrack;
+ unsigned char i;
+ bool bVoice = false;
- /* delete track information of MA-3/5 */
+ /* delete track information of MA-3/5 */
psLoad->sTrack_Info[5].pbMtr = NULL;
psLoad->sTrack_Info[5].dMtrSize = 0;
psLoad->sTrack_Info[6].pbMtr = NULL;
psLoad->sTrack_Info[6].dMtrSize = 0;
- /* fix SMAF Type */
+ /* fix SMAF Type */
psLoad->dSmafType = AV_MMF_SMAF_TYPE_MA1;
for (i = 1; i < 5; i++) {
if (psLoad->sTrack_Info[i].pbMtr != NULL) {
psLoad->dSmafType = AV_MMF_SMAF_TYPE_MA2;
if (psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA1) {
- /* MA-1 */
- if (psLoad->sTrack_Info[0].pbMtr == NULL) {
- return AV_MMF_ERR_SLENGTH;
- }
+ /* MA-1 */
+ mm_file_retv_if_fails(psLoad->sTrack_Info[0].pbMtr, false);
+
psTrack = &(psLoad->sTrack_Info[0]);
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE2) {
- return AV_MMF_ERR_CHUNK;
- }
- sdResult = _mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA1);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
- _mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
- sdResult = _mmf_STSPCheck(psTrack);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
- sdResult = _mmf_MtsuCheck2(psTrack, AV_MMF_SMAF_TYPE_MA1);
- if (sdResult != AV_MMF_MA2_VOICE_FOUND) {
- return AV_MMF_ERR_CHUNK;
- }
- sdResult = _mmf_SeqDataCheck2(psTrack, AV_MMF_SMAF_TYPE_MA1);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
+ mm_file_retv_if_fails(psTrack->dMtrSize > AV_MMF_MINIMUM_TRACKSIZE2, false);
+ mm_file_retv_if_fails(__mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA1), false);
+
+ __mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
+ mm_file_retv_if_fails(__mmf_STSPCheck(psTrack), false);
+ mm_file_retv_if_fails(__mmf_MtsuCheck2(psTrack, AV_MMF_SMAF_TYPE_MA1), false);
+ mm_file_retv_if_fails(__mmf_SeqDataCheck2(psTrack, AV_MMF_SMAF_TYPE_MA1), false);
+
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
- return AV_MMF_FUNC_SUCCESS;
+ return true;
} else {
- /* MA-2 */
+ /* MA-2 */
psLoad->sTrack_Info[0].pbMtr = NULL;
psLoad->sTrack_Info[0].dMtrSize = 0;
psTrack = &(psLoad->sTrack_Info[i]);
if (psTrack->pbMtr == NULL)
continue;
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE2) {
- return AV_MMF_ERR_CHUNK;
- }
- sdResult = _mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA2);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
- _mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
- sdResult = _mmf_STSPCheck(psTrack);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
- sdResult = _mmf_SeqDataCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
+
+ mm_file_retv_if_fails(psTrack->dMtrSize > AV_MMF_MINIMUM_TRACKSIZE2, false);
+ mm_file_retv_if_fails(__mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA2), false);
+
+ __mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
+ mm_file_retv_if_fails(__mmf_STSPCheck(psTrack), false);
+ mm_file_retv_if_fails(__mmf_SeqDataCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2), false);
+
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
if (psLoad->sTrack_Info[AV_MMF_ATR_TRACK_NO].pbMtr != NULL) {
psTrack = &(psLoad->sTrack_Info[AV_MMF_ATR_TRACK_NO]);
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE2) {
- return AV_MMF_ERR_CHUNK;
- }
- sdResult = _mmf_ATRCheck(psTrack);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
- _mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
- sdResult = _mmf_STSPCheck(psTrack);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
- sdResult = _mmf_SeqDataCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
+ mm_file_retv_if_fails(psTrack->dMtrSize > AV_MMF_MINIMUM_TRACKSIZE2, false);
+ mm_file_retv_if_fails(__mmf_ATRCheck(psTrack), false);
+
+ __mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
+ mm_file_retv_if_fails(__mmf_STSPCheck(psTrack), false);
+ mm_file_retv_if_fails(__mmf_SeqDataCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2), false);
+
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
if (psTrack->pbMtr == NULL)
continue;
- if (psLoad->dPlayTime < psTrack->dPlayTime)
- psLoad->dPlayTime = psTrack->dPlayTime;
- if (psLoad->dTimeBase != psTrack->dTimeBase) {
- return AV_MMF_ERR_CHUNK;
- }
- if (psLoad->dStartTime != psTrack->dStartTick) {
- return AV_MMF_ERR_CHUNK;
- }
- if (_mmf_MtsuCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2) == AV_MMF_FUNC_SUCCESS)
- fbVoice = AV_MMF_MA2_VOICE_FOUND;
+ if (psLoad->dPlayTime < psTrack->dPlayTime)
+ psLoad->dPlayTime = psTrack->dPlayTime;
+
+ mm_file_retv_if_fails(psLoad->dTimeBase == psTrack->dTimeBase, false);
+ mm_file_retv_if_fails(psLoad->dStartTime == psTrack->dStartTick, false);
}
- fbVoice = AV_MMF_MA2_VOICE_FOUND;
for (i = 1; i < 5; i++) {
psTrack = &(psLoad->sTrack_Info[i]);
if (psTrack->pbMtr == NULL)
continue;
- if (_mmf_MtsuCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2) == AV_MMF_MA2_VOICE_FOUND) {
- fbVoice = AV_MMF_MA2_VOICE_FOUND;
+
+ if (__mmf_MtsuCheck2(psTrack, AV_MMF_SMAF_TYPE_MA2)) {
+ bVoice = true;
break;
- } else
- fbVoice = AV_MMF_MA2_VOICE_NOTFOUND;
+ }
}
- if (fbVoice == AV_MMF_MA2_VOICE_NOTFOUND) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (!bVoice)
+ return false;
}
debug_msg(RELEASE, "Play time: %u\n", psLoad->dPlayTime);
- return AV_MMF_FUNC_SUCCESS;
+ return true;
}
-static unsigned char
-_mmf_GetByte3L(PHUFFMANINFO psHuf)
+static unsigned char __mmf_GetByte3L(PHUFFMANINFO psHuf)
{
psHuf->dReadSize++;
- if (psHuf->dReadSize > psHuf->dMtsqSize) {
+ if (psHuf->dReadSize > psHuf->dMtsqSize)
return 0;
- }
+
return *(psHuf->psBuffer++);
}
-
-/*********************************************************************************
- * _mmf_GetFlex3L
- *
- * Description:
- * MA-3 sequence data check
- * Argument:
- * psLoad pointer to load information structure
- * pdRead pointer to size of flex data
- * Return:
- * >=0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_GetFlex3L(PLOADINFO psLoad, unsigned int *pdRead)
+static bool __mmf_GetFlex3L(PLOADINFO psLoad, unsigned int *pdRead, unsigned int *pdFlex)
{
- unsigned int dTemp, dRead;
- unsigned char bTemp;
+ unsigned int dTemp, dRead;
+ unsigned char bTemp;
dRead = 1;
bTemp = psLoad->pfnGetByte(&(psLoad->sHuffman_Info));
dTemp = (unsigned int)(bTemp & 0x7F);
while (bTemp & 0x80) {
if (dRead >= 4)
- return AV_MMF_FUNC_ERROR;
+ return false;
dRead++;
bTemp = psLoad->pfnGetByte(&(psLoad->sHuffman_Info));
dTemp = (dTemp << 7) + (unsigned int)(bTemp & 0x7F);
}
if (dTemp >= AV_MMF_PLAY_TIME_MAX)
- return AV_MMF_FUNC_ERROR;
+ return false;
+
*pdRead = dRead;
- return (int)dTemp;
-}
+ *pdFlex = dTemp;
+ return true;
+}
-/*********************************************************************************
- * _mmf_SeqDataCheck3
- *
- * Description:
- * MA-3 sequence data check
- * Argument:
- * psLoad pointer to load information structure
- * bSmafType SMAF type
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_SeqDataCheck3(PLOADINFO psLoad, unsigned char bSmafType)
+static bool __mmf_SeqDataCheck3(PLOADINFO psLoad, unsigned char bSmafType)
{
PTRACKINFO psTrk;
PPHRASEINFO psPhr;
PHUFFMANINFO psHuf;
- unsigned int dIndex, fdPhrase, dSize, dPast, dGate, dReadSize, i;
- unsigned int dStartTick, dStopTick;
- int sdTemp;
- unsigned char bTemp;
+ unsigned int dIndex, fdPhrase, dSize, dPast, dGate, dReadSize, i;
+ unsigned int dStartTick, dStopTick, dTemp;
+ unsigned char bTemp;
if (bSmafType == AV_MMF_SMAF_TYPE_MA3) {
/* MA-3 */
dGate = 0;
dSize = psHuf->dSeqSize;
- if (psHuf->dSeqSize == 0) {
- return AV_MMF_ERR_SLENGTH;
- }
+ mm_file_retv_if_fails(psHuf->dSeqSize > 0, false);
for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++) {
if (psPhr[i].dStartPoint != AV_MMF_STSP_OFFSET_NULL)
/* scanning sequence data to EOS or stop point */
while (dSize >= dIndex) {
-
if (psTrk->dStartPoint == dIndex)
psTrk->dStartTick = dPast;
if (psTrk->dStopPoint == dIndex) /* stop point */
if ((psTrk->dStopTick != AV_MMF_STSP_TIME_NULL) || (dSize == dIndex))
break;
- sdTemp = _mmf_GetFlex3L(psLoad, &dReadSize); /* Duration */
- if (sdTemp < 0) {
- return AV_MMF_ERR_CHUNK;
- }
- dPast += (unsigned int)sdTemp;
- if (dPast >= AV_MMF_PLAY_TIME_MAX) {
- return AV_MMF_ERR_LLENGTH;
- }
+ /* Duration */
+ mm_file_retv_if_fails(__mmf_GetFlex3L(psLoad, &dReadSize, &dTemp), false);
+
+ dPast += dTemp;
+ mm_file_retv_if_fails(dPast < AV_MMF_PLAY_TIME_MAX, false);
- if ((unsigned int)sdTemp >= dGate)
+ if (dTemp >= dGate)
dGate = 0;
else
- dGate -= (unsigned int)sdTemp;
+ dGate -= dTemp;
dIndex += dReadSize;
bTemp = psLoad->pfnGetByte(psHuf);
dIndex++;
psLoad->pfnGetByte(psHuf); /*Key Velocity*/
dIndex++;
- sdTemp = _mmf_GetFlex3L(psLoad, &dReadSize);
- if (sdTemp < 0) {
- return AV_MMF_ERR_CHUNK;
- }
+ mm_file_retv_if_fails(__mmf_GetFlex3L(psLoad, &dReadSize, &dTemp), false);
+
dIndex += dReadSize;
- if ((unsigned int)sdTemp > dGate)
- dGate = sdTemp;
+ if (dTemp > dGate)
+ dGate = dTemp;
break;
case 0x80:
psLoad->pfnGetByte(psHuf); /*Note number*/
dIndex++;
- sdTemp = _mmf_GetFlex3L(psLoad, &dReadSize);
- if (sdTemp < 0) {
- return AV_MMF_ERR_CHUNK;
- }
+ mm_file_retv_if_fails(__mmf_GetFlex3L(psLoad, &dReadSize, &dTemp), false);
+
dIndex += dReadSize;
- if ((unsigned int)sdTemp > dGate)
- dGate = sdTemp;
+ if (dTemp > dGate)
+ dGate = dTemp;
break;
case 0xA0:
case 0xB0:
default:
switch (bTemp) {
case 0xF0:
- sdTemp = _mmf_GetFlex3L(psLoad, &dReadSize);
- if (sdTemp < 0) {
- return AV_MMF_ERR_CHUNK;
- }
- for (i = 0; i < (unsigned int)sdTemp; i++)
+ mm_file_retv_if_fails(__mmf_GetFlex3L(psLoad, &dReadSize, &dTemp), false);
+
+ for (i = 0; i < dTemp; i++)
bTemp = psLoad->pfnGetByte(psHuf);
- if (bTemp != 0xF7) {
- return AV_MMF_ERR_CHUNK;
- }
- dIndex += (unsigned int)sdTemp + dReadSize;
+ mm_file_retv_if_fails(bTemp == 0xF7, false);
+
+ dIndex += dTemp + dReadSize;
break;
case 0xFF:
bTemp = psLoad->pfnGetByte(psHuf);
case 0x2F:
bTemp = psLoad->pfnGetByte(psHuf);
dIndex++;
- if (bTemp != 0x00) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (bTemp != 0x00)
+ return false;
+
dGate = 0;
psTrk->dStopTick = dPast;
dIndex = dSize;
break;
default:
- return AV_MMF_ERR_CHUNK;
+ return false;
}
break;
default:
- return AV_MMF_ERR_CHUNK;
+ return false;
}
break;
}
- if ((dSize < dIndex) || (psHuf->dReadSize > psHuf->dMtsqSize)) {
- return AV_MMF_ERR_CHUNK;
- }
+ if ((dSize < dIndex) || (psHuf->dReadSize > psHuf->dMtsqSize))
+ return false;
+
}
if (bSmafType == AV_MMF_SMAF_TYPE_MA3) {
/* MA-3 */
/* check start point */
if (psTrk->dStartTick == AV_MMF_STSP_TIME_NULL) {
- if (psTrk->dStartPoint != AV_MMF_STSP_OFFSET_NULL) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (psTrk->dStartPoint != AV_MMF_STSP_OFFSET_NULL)
+ return false;
+
psTrk->dStartPoint = 0;
psTrk->dStartTick = 0;
}
/* check stop point */
if (psTrk->dStopTick == AV_MMF_STSP_TIME_NULL) {
- if (psTrk->dStopPoint != AV_MMF_STSP_OFFSET_NULL) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (psTrk->dStopPoint != AV_MMF_STSP_OFFSET_NULL)
+ return false;
+
psTrk->dStopPoint = dSize;
psTrk->dStopTick = dPast + dGate;
}
} else {
/* MA-5 */
/* check stop point */
- if (dStopTick > dPast) {
- return AV_MMF_ERR_CHUNK;
- }
+ if (dStopTick > dPast)
+ return false;
+
psTrk->dStartTick = dStartTick;
psTrk->dStopTick = dStopTick;
}
debug_msg(RELEASE, "Play time: %u\n", psTrk->dPlayTime);
- return AV_MMF_FUNC_SUCCESS;
+ return true;
}
-
-
-
-/*********************************************************************************
- * _mmf_DecodeGetbitL
- *
- * Description:
- * get 1 bit with error check
- * Argument:
- * psHuf pointer to huffman information structure
- * Return:
- * read data
- ********************************************************************************/
-
-
-static unsigned char
-_mmf_DecodeGetbitL(PHUFFMANINFO psHuf)
+static unsigned char __mmf_DecodeGetbitL(PHUFFMANINFO psHuf)
{
char czero = 0;
psHuf->bByte = *(psHuf->psBuffer++);
psHuf->dReadSize++;
}
- return (unsigned char)(psHuf->bByte & g_abBitMaskTable1[(int)(psHuf->sbBitC)]);
+ return (psHuf->bByte & g_abBitMaskTable1[(int)(psHuf->sbBitC)]);
}
-
-/*********************************************************************************
- * _mmf_DecodeGetbits
- *
- * Description:
- * get 8 bit
- * Argument:
- * psHuf pointer to huffman information structure
- * Return:
- * read data
- ********************************************************************************/
-static unsigned char
-_mmf_DecodeGetbits(PHUFFMANINFO psHuf)
+static unsigned char __mmf_DecodeGetbits(PHUFFMANINFO psHuf)
{
- unsigned short wTemp;
- unsigned char bData1, bData2;
+ unsigned short wTemp;
+ unsigned char bData1, bData2;
if (psHuf->dReadSize >= psHuf->dMtsqSize)
return 0;
+
bData1 = psHuf->bByte;
bData2 = *(psHuf->psBuffer++);
psHuf->bByte = bData2;
return (unsigned char)((wTemp & g_awBitMaskTable2[(int)(psHuf->sbBitC)]) >> psHuf->sbBitC);
}
-
-/*********************************************************************************
- * _mmf_DecodeTree
- *
- * Description:
- * make MA-3 huffman decode tree
- * Argument:
- * psHuf pointer to huffman information structure
- * Return:
- * !0 success(sequence data size)
- * 0 error
- ********************************************************************************/
-static int
-_mmf_DecodeTree(PHUFFMANINFO psHuf)
+static bool __mmf_DecodeTree(PHUFFMANINFO psHuf)
{
- unsigned int dNode, dEmpty, dIndex, i;
- short *pswLeft, *pswRight, *pswPNode;
- unsigned char bTemp;
+ unsigned int dNode, dEmpty, dIndex, i;
+ short *pswLeft, *pswRight, *pswPNode;
+ unsigned char bTemp;
- if (_mmf_DecodeGetbitL(psHuf)) {
+ if (__mmf_DecodeGetbitL(psHuf)) {
if (psHuf->dReadSize >= psHuf->dMtsqSize)
- return AV_MMF_HUFFMAN_TREE_FAILURE;
+ return false;
pswLeft = &(psHuf->swLeft[256]);
pswRight = &(psHuf->swRight[256]);
dEmpty = 1;
dIndex = 0;
} else
- return AV_MMF_HUFFMAN_TREE_FAILURE;
+ return false;
while (dNode != 0) {
if ((dEmpty >= 256) || (dNode >= 257))
- return AV_MMF_HUFFMAN_TREE_FAILURE;
+ return false;
- bTemp = _mmf_DecodeGetbitL(psHuf);
+ bTemp = __mmf_DecodeGetbitL(psHuf);
if (psHuf->dReadSize >= psHuf->dMtsqSize)
- return AV_MMF_HUFFMAN_TREE_FAILURE;
+ return false;
if (bTemp) {
dNode++;
dEmpty++;
} else {
dNode--;
- bTemp = _mmf_DecodeGetbits(psHuf);
+ bTemp = __mmf_DecodeGetbits(psHuf);
if (psHuf->dReadSize >= psHuf->dMtsqSize)
- return AV_MMF_HUFFMAN_TREE_FAILURE;
+ return false;
if (pswLeft[dIndex] == -1)
pswLeft[dIndex] = (short)bTemp;
if (pswRight[i] == -1)
pswRight[i] = 0;
}
- return AV_MMF_HUFFMAN_TREE_SUCCESS;
+ return true;
}
-
-/*********************************************************************************
- * _mmf_DecodeInit
- *
- * Description:
- * make MA-3 huffman decode tree
- * Argument:
- * psHuf pointer to huffman information structure
- * Return:
- * !0 success(sequence data size)
- * 0 error
- ********************************************************************************/
-static unsigned int
-_mmf_DecodeInit(PHUFFMANINFO psHuf)
+static unsigned int __mmf_DecodeInit(PHUFFMANINFO psHuf)
{
- unsigned int dSeqSize;
+ unsigned int dSeqSize;
- if (psHuf->dMtsqSize <= 5) {
- return AV_MMF_HUFFMAN_TREE_FAILURE;
- }
+ if (psHuf->dMtsqSize <= 5)
+ return 0;
dSeqSize = _mmf_Get4Byte(psHuf->psBuffer);
psHuf->psBuffer += 4;
psHuf->dReadSize = 4;
psHuf->sbBitC = 0;
psHuf->bByte = 0;
- if (_mmf_DecodeTree(psHuf) == AV_MMF_HUFFMAN_TREE_FAILURE)
- return AV_MMF_HUFFMAN_TREE_FAILURE;
+ if (!__mmf_DecodeTree(psHuf))
+ return 0;
else
return dSeqSize;
}
-
-/*********************************************************************************
- * _mmf_DecodeByte3L
- *
- * Description:
- * get 1 byte (from compressed data)
- * Argument:
- * psHuf pointer to huffman information structure
- * Return:
- * unsigned char success(read data)
- * 0 error code
- ********************************************************************************/
-static unsigned char
-_mmf_DecodeByte3L(PHUFFMANINFO psHuf)
+static unsigned char __mmf_DecodeByte3L(PHUFFMANINFO psHuf)
{
- unsigned int bData, bIndex;
+ unsigned int bData, bIndex;
char czero = 0;
bIndex = 256;
while (bIndex >= 256) {
return (unsigned char)bIndex;
}
-
-/*********************************************************************************
- * _mmf_TrackChunkCheck3
- *
- * Description:
- * MA-3 track chunk check
- * Argument:
- * psLoad pointer to load information structure
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_TrackChunkCheck3(PLOADINFO psLoad)
+static bool __mmf_TrackChunkCheck3(PLOADINFO psLoad)
{
- PTRACKINFO psTrack;
- int sdResult;
+ PTRACKINFO psTrack;
+
+ mm_file_retv_if_fails(psLoad->sTrack_Info[5].pbMtr, false);
- if (psLoad->sTrack_Info[5].pbMtr == NULL) {
- return AV_MMF_ERR_SLENGTH;
- }
psTrack = &(psLoad->sTrack_Info[5]);
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE3) {
- return AV_MMF_ERR_CHUNK;
- }
- sdResult = _mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA3);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
- _mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
+ mm_file_retv_if_fails(psTrack->dMtrSize > AV_MMF_MINIMUM_TRACKSIZE3, false);
+ mm_file_retv_if_fails(__mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA3), false);
+
+ __mmf_MspICheck(psTrack, &(psLoad->sPhrase_Info[0]));
psLoad->sHuffman_Info.psBuffer = psTrack->pbMtsq;
psLoad->sHuffman_Info.dMtsqSize = psTrack->dMtsqSize;
/* Initialize Huffman information structure */
if (psTrack->pbMtr[0] == 0x01) {
/* Compressed Foramt */
- psLoad->sHuffman_Info.dSeqSize = _mmf_DecodeInit(&(psLoad->sHuffman_Info));
- if (psLoad->sHuffman_Info.dSeqSize == AV_MMF_HUFFMAN_TREE_FAILURE) {
- return AV_MMF_ERR_CHUNK;
- }
- psLoad->pfnGetByte = _mmf_DecodeByte3L;
+ psLoad->sHuffman_Info.dSeqSize = __mmf_DecodeInit(&(psLoad->sHuffman_Info));
+ mm_file_retv_if_fails(psLoad->sHuffman_Info.dSeqSize > 0, false);
+
+ psLoad->pfnGetByte = __mmf_DecodeByte3L;
psLoad->sHuffman_Info.psFBuf = psLoad->sHuffman_Info.psBuffer;
psLoad->sHuffman_Info.sbFBit = psLoad->sHuffman_Info.sbBitC;
psLoad->sHuffman_Info.bFByte = psLoad->sHuffman_Info.bByte;
} else {
/* No Compressed Foramt */
- psLoad->pfnGetByte = _mmf_GetByte3L;
+ psLoad->pfnGetByte = __mmf_GetByte3L;
psLoad->sHuffman_Info.dSeqSize = psTrack->dMtsqSize;
psLoad->sHuffman_Info.dReadSize = 0;
psLoad->sHuffman_Info.psFBuf = psTrack->pbMtsq;
}
psTrack->dMtsqSize = psLoad->sHuffman_Info.dSeqSize;
- sdResult = _mmf_STSPCheck(psTrack);
psTrack->dMtsqSize = psLoad->sHuffman_Info.dMtsqSize;
+ mm_file_retv_if_fails(__mmf_STSPCheck(psTrack), false);
+ mm_file_retv_if_fails(__mmf_SeqDataCheck3(psLoad, AV_MMF_SMAF_TYPE_MA3), false);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
- sdResult = _mmf_SeqDataCheck3(psLoad, AV_MMF_SMAF_TYPE_MA3);
- if (sdResult != AV_MMF_FUNC_SUCCESS) {
- return sdResult;
- }
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
debug_msg(RELEASE, "Play time: %u\n", psLoad->dPlayTime);
- return AV_MMF_FUNC_SUCCESS;
+ return true;
}
-
-/*********************************************************************************
- * _mmf_CheckM5P
- *
- * Description:
- * MA-5 profile data chunk check
- * Argument:
- * psLoad pointer to load information structure
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_CheckM5P(PLOADINFO psLoad)
+static bool __mmf_CheckM5P(PLOADINFO psLoad)
{
- PTRACKINFO psTrk;
- PPHRASEINFO psPhr;
- POPTIONINFO psOptn;
- unsigned char *pbOpda, *pbM5p;
- unsigned int dOSize, dMSize, dIndex, dPhraseFlag, i;
- unsigned int dChunkID, dChunkNo;
- int sdChunkSize;
+ PTRACKINFO psTrk;
+ PPHRASEINFO psPhr;
+ POPTIONINFO psOptn;
+ unsigned char *pbOpda, *pbM5p;
+ unsigned int dOSize, dMSize, dIndex, dPhraseFlag, i;
+ unsigned int dChunkID, dChunkNo, dChunkSize;
psOptn = &(psLoad->sOption_Info);
psTrk = &(psLoad->sTrack_Info[6]);
/* search Pro5 Chunk */
while (dOSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE)) {
- sdChunkSize = _mmf_MalibNextChunk(&pbOpda[dIndex], (dOSize - dIndex), AVMALIB_CHUNK_PHASE_OPDASUB, &dChunkID, &dChunkNo);
- if (sdChunkSize < AVMASMW_SUCCESS) return AVMASMW_ERROR;
+ if (!__mmf_MalibNextChunk(&pbOpda[dIndex], (dOSize - dIndex), AVMALIB_CHUNK_PHASE_OPDASUB, &dChunkID, &dChunkNo, &dChunkSize))
+ return false;
+
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
if ((dChunkID == AVMALIB_CHUNKCODE_M5P) && (dChunkNo == 0x05)) {
pbM5p = &pbOpda[dIndex];
- dMSize = (unsigned int)sdChunkSize;
+ dMSize = dChunkSize;
break;
}
- dIndex += sdChunkSize;
+ dIndex += dChunkSize;
}
- if ((pbM5p == NULL) || (dMSize < 12)) return AVMASMW_ERROR;
+ if ((pbM5p == NULL) || (dMSize < 12))
+ return false;
dPhraseFlag = _mmf_Get4Byte(&pbM5p[0]);
psTrk->dStartTick = _mmf_Get4Byte(&pbM5p[4]); /* start point */
psTrk->dStopTick = _mmf_Get4Byte(&pbM5p[8]); /* stop point */
dIndex = 12;
- if (psTrk->dStartTick >= psTrk->dStopTick) return AVMASMW_ERROR;
+ if (psTrk->dStartTick >= psTrk->dStopTick)
+ return false;
for (i = 0; i < AV_MMF_MAX_PHRASE_INFO; i++) {
if (dMSize < (dIndex + 8)) break;
dIndex += 8;
}
}
- return AVMASMW_SUCCESS;
+ return true;
}
-
-/*********************************************************************************
- * _mmf_TrackChunkCheck5
- *
- * Description:
- * MA-5 track chunk check
- * Argument:
- * psLoad pointer to load information structure
- * dMode load mode
- * Return:
- * 0 success
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_TrackChunkCheck5(PLOADINFO psLoad)
+static bool __mmf_TrackChunkCheck5(PLOADINFO psLoad)
{
- PTRACKINFO psTrack;
- int sdResult;
+ PTRACKINFO psTrack;
+
+ mm_file_retv_if_fails(psLoad->sTrack_Info[6].pbMtr, false);
- if (psLoad->sTrack_Info[6].pbMtr == NULL) {
- return AV_MMF_ERR_SLENGTH;
- }
psTrack = &(psLoad->sTrack_Info[6]);
- if (psTrack->dMtrSize <= AV_MMF_MINIMUM_TRACKSIZE3) {
- return AV_MMF_ERR_CHUNK;
- }
- sdResult = _mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA5);
- if (sdResult != AV_MMF_FUNC_SUCCESS) return sdResult;
+ mm_file_retv_if_fails(psTrack->dMtrSize > AV_MMF_MINIMUM_TRACKSIZE3, false);
+ mm_file_retv_if_fails(__mmf_MTRCheck(psTrack, AV_MMF_SMAF_TYPE_MA5), false);
psLoad->sHuffman_Info.psBuffer = psTrack->pbMtsq;
psLoad->sHuffman_Info.dMtsqSize = psTrack->dMtsqSize;
psLoad->sHuffman_Info.dSeqSize = psTrack->dMtsqSize;
psLoad->sHuffman_Info.dReadSize = 0;
- psLoad->pfnGetByte = _mmf_GetByte3L;
-
+ psLoad->pfnGetByte = __mmf_GetByte3L;
- sdResult = _mmf_SeqDataCheck3(psLoad, AV_MMF_SMAF_TYPE_MA5);
- if (sdResult != AV_MMF_FUNC_SUCCESS) return sdResult;
+ mm_file_retv_if_fails(__mmf_SeqDataCheck3(psLoad, AV_MMF_SMAF_TYPE_MA5), false);
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
debug_msg(RELEASE, "Play time: %u\n", psLoad->dPlayTime);
- return AV_MMF_FUNC_SUCCESS;
+ return true;
}
-/*********************************************************************************
- * _mmf_GetHvData
- *
- * Description:
- * HV Data Chunk Check
- * Argument:
- * psLoad pointer to load information structure
- * bCType Contents Type
- * Return:
- * nothing
- ********************************************************************************/
-static void
-_mmf_GetHvData(PLOADINFO psLoad, unsigned char bCType)
+
+
+static void __mmf_GetHvData(PLOADINFO psLoad, unsigned char bCType)
{
- unsigned char *pbHvData;
- unsigned int dHvDataSize;
+ unsigned char *pbHvData;
+ unsigned int dHvDataSize;
- unsigned char *pbVoice;
- unsigned char *pbScript;
- unsigned char *pbSetup;
- unsigned int dVoiceSize, dScriptSize, dSetupSize, dIndex;
- unsigned char bHvCh;
- unsigned short wTag, wSize;
+ unsigned char *pbVoice;
+ unsigned char *pbScript;
+ unsigned char *pbSetup;
+ unsigned int dVoiceSize, dScriptSize, dSetupSize, dIndex;
+ unsigned char bHvCh;
+ unsigned short wTag, wSize;
- unsigned int dChunkID, dChunkNo;
- int sdChunkSize;
+ unsigned int dChunkID, dChunkNo, dChunkSize;
if ((psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA1) || (psLoad->dSmafType == AV_MMF_SMAF_TYPE_MA2))
return;
dIndex = 0;
while (dHvDataSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE)) {
- sdChunkSize = _mmf_MalibNextChunk(&(pbHvData[dIndex]), (dHvDataSize - dIndex), AVMALIB_CHUNK_PHASE_MTHVSUB, &dChunkID, &dChunkNo);
- if (sdChunkSize < 0) return;
+ if (!__mmf_MalibNextChunk(&(pbHvData[dIndex]), (dHvDataSize - dIndex), AVMALIB_CHUNK_PHASE_MTHVSUB, &dChunkID, &dChunkNo, &dChunkSize))
+ return;
+
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
switch (dChunkID) {
case AVMALIB_CHUNKCODE_MHVS:
pbSetup = &(pbHvData[dIndex]);
- dSetupSize = (unsigned int)sdChunkSize;
+ dSetupSize = dChunkSize;
break;
case AVMALIB_CHUNKCODE_HVP:
- if (dChunkNo != 0) break;
+ if (dChunkNo != 0)
+ break;
pbVoice = &(pbHvData[dIndex - AV_MMF_CHUNK_HEADER_SIZE]);
- dVoiceSize = (unsigned int)(sdChunkSize + AV_MMF_CHUNK_HEADER_SIZE);
+ dVoiceSize = dChunkSize + AV_MMF_CHUNK_HEADER_SIZE;
break;
case AVMALIB_CHUNKCODE_MHSC:
pbScript = &(pbHvData[dIndex]);
- dScriptSize = (unsigned int)sdChunkSize;
+ dScriptSize = dChunkSize;
break;
default:
break;
}
- dIndex += sdChunkSize;
+ dIndex += dChunkSize;
}
if (pbSetup == NULL) {
wTag = (unsigned short)(((unsigned short)(pbSetup[dIndex]) << 8) + pbSetup[dIndex + 1]);
wSize = (unsigned short)(((unsigned short)(pbSetup[dIndex + 2]) << 8) + pbSetup[dIndex + 3]);
dIndex += 4;
- if (dSetupSize < (dIndex + wSize)) return;
- if ((wTag == 0x4348) && (wSize == 1)) bHvCh = pbSetup[dIndex];
+ if (dSetupSize < (dIndex + wSize))
+ return;
+ if ((wTag == 0x4348) && (wSize == 1))
+ bHvCh = pbSetup[dIndex];
dIndex += wSize;
}
psLoad->sHV_Info.pbScript = pbScript;
psLoad->sHV_Info.dScriptSize = dScriptSize;
psLoad->sHV_Info.bHvChannel = bHvCh;
-
- return;
}
-/*********************************************************************************
- * Avdecode_byte3
- *
- * Description:
- * get 1 byte (from compressed data)
- * Argument:
- * nothing
- * Return:
- * unsigned char success(read data)
- ********************************************************************************/
-static unsigned short
-_mmf_MalibMakeCRC(unsigned int dSize, unsigned char *pbData)
+
+static unsigned short __mmf_MalibMakeCRC(unsigned int dSize, unsigned char *pbData)
{
- unsigned short wRes;
- unsigned char bData;
+ unsigned short wRes = 0xFFFFU;
+ unsigned char bData;
- wRes = 0xFFFFU;
while (--dSize >= 2) {
bData = *pbData++;
wRes = (unsigned short)((wRes << 8) ^ g_crc_tbl[(unsigned char)(wRes >> 8) ^ bData]);
}
+
return (unsigned short)(~wRes & 0xFFFFU);
}
-
-/*********************************************************************************
- * _mmf_MALoad
- *
- * Description:
- * SMAF data load (error check and regist)
- * Argument:
- * pbFile pointer to SMAF data
- * dFsize size of SMAF data
- * dMode load mode
- * Return:
- * 0 or 1 success(file id)
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_MALoad(unsigned char *pbFile, unsigned int dFSize)
+static int __mmf_MALoad(unsigned char *pbFile, unsigned int dFSize)
{
- PLOADINFO psLoad_Info;
- unsigned int bNo = 0;
- unsigned int dChunkID = 0, dChunkNo = 0;
- unsigned char *pbBuf = NULL;
- unsigned int dSize = 0, dIndex = 0;
- int sdChunkSize = 0, sdResult = 0;
- unsigned int dCalcCrc = 0, dFileCrc = 0;
- int rVal = 0;
+ PLOADINFO psLoad_Info;
+ unsigned int bNo = 0;
+ unsigned int dChunkID = 0, dChunkNo = 0, dChunkSize = 0;
+ unsigned char *pbBuf = NULL;
+ unsigned int dSize = 0, dIndex = 0;
+ unsigned int dCalcCrc = 0, dFileCrc = 0;
+ int rVal = 0;
pbBuf = pbFile;
dSize = dFSize;
psLoad_Info = &(g_sSmaf_Info.sLoad_Info[bNo]);
_mmf_CheckInitial(psLoad_Info);
- /* check File Chunk(ID/Size) */
- sdChunkSize = _mmf_MalibNextChunk(pbBuf, dSize, AVMALIB_CHUNK_PHASE_MMMD, &dChunkID, &dChunkNo);
- if ((sdChunkSize < 0) || (dChunkID != AVMALIB_CHUNKCODE_MMMD)) {
- return AV_MMF_ERR_FILE;
- }
- dSize = (unsigned int)(sdChunkSize + AV_MMF_CHUNK_HEADER_SIZE);
+ /* check File Chunk(ID/Size) */
+ if (!__mmf_MalibNextChunk(pbBuf, dSize, AVMALIB_CHUNK_PHASE_MMMD, &dChunkID, &dChunkNo, &dChunkSize)
+ || dChunkID != AVMALIB_CHUNKCODE_MMMD)
+ return -1;
+
+ dSize = dChunkSize + AV_MMF_CHUNK_HEADER_SIZE;
dCalcCrc = AV_MMF_CRC_NULL;
- dCalcCrc = _mmf_MalibMakeCRC(dSize, pbBuf);
+ dCalcCrc = __mmf_MalibMakeCRC(dSize, pbBuf);
dFileCrc = (unsigned int)((((unsigned int)pbBuf[dSize - 2]) << 8) + pbBuf[dSize - 1]);
if (dCalcCrc != dFileCrc) {
- return AV_MMF_ERR_FILE;
+ return -1;
}
- /* check Contents Info Chunk */
+ /* check Contents Info Chunk */
dIndex = AV_MMF_CHUNK_HEADER_SIZE;
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_CNTI, &dChunkID, &dChunkNo);
- if ((sdChunkSize < 5) || (dChunkID != AVMALIB_CHUNKCODE_CNTI)) {
- return AV_MMF_ERR_FILE;
- }
+ if (!__mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_CNTI, &dChunkID, &dChunkNo, &dChunkSize)
+ || dChunkSize < 5
+ || dChunkID != AVMALIB_CHUNKCODE_CNTI)
+ return -1;
/* check Contents Class */
if ((pbBuf[AV_MMF_POSITION_OF_CCLASS] != AV_MMF_CONTENTS_CLASS_0) &&
(pbBuf[AV_MMF_POSITION_OF_CCLASS] != AV_MMF_CONTENTS_CLASS_1) &&
(pbBuf[AV_MMF_POSITION_OF_CCLASS] != AV_MMF_CONTENTS_CLASS_2)) {
- return AV_MMF_ERR_CLASS;
+ return -1;
}
/* check Contents Type */
psLoad_Info->dSmafType = AV_MMF_SMAF_TYPE_MA5;
break;
default:
- return AV_MMF_ERR_TYPE;
+ return -1;
}
} else {
- return AV_MMF_ERR_TYPE;
+ return -1;
}
/* get pointer & size of option information */
psLoad_Info->sOption_Info.pbCnti = &pbBuf[dIndex];
- psLoad_Info->sOption_Info.dCntiSize = (unsigned int)(sdChunkSize);
- dIndex += sdChunkSize;
+ psLoad_Info->sOption_Info.dCntiSize = dChunkSize;
+ dIndex += dChunkSize;
if (pbBuf[AV_MMF_POSITION_OF_CTYPE] >= 0x30) {
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
- if ((sdChunkSize >= 12) && (dChunkID == AVMALIB_CHUNKCODE_OPDA)) {
+ if (__mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo, &dChunkSize)
+ && dChunkSize >= 12
+ && dChunkID == AVMALIB_CHUNKCODE_OPDA) {
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
psLoad_Info->sOption_Info.pbOpda = &pbBuf[dIndex];
- psLoad_Info->sOption_Info.dOpdaSize = (unsigned int)sdChunkSize;
- dIndex += sdChunkSize;
+ psLoad_Info->sOption_Info.dOpdaSize = dChunkSize;
+ dIndex += dChunkSize;
}
}
/* get Track Chunk information */
while (dSize > (dIndex + AV_MMF_CHUNK_HEADER_SIZE + AV_MMF_FILE_CRC_SIZE)) {
- sdChunkSize = _mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
- if (sdChunkSize < 0) {
- if (sdChunkSize == AVMALIB_CHUNK_ID_ERROR) {
- return AV_MMF_ERR_FILE;
- } else {
- return AV_MMF_ERR_SIZE;
- }
- }
+ if (!__mmf_MalibNextChunk(&pbBuf[dIndex], (dSize - dIndex), AVMALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo, &dChunkSize))
+ return -1;
+
dIndex += AV_MMF_CHUNK_HEADER_SIZE;
switch (dChunkID) {
case AVMALIB_CHUNKCODE_MTR:
if (dChunkNo > 6)
break;
psLoad_Info->sTrack_Info[dChunkNo].pbMtr = &(pbBuf[dIndex]);
- psLoad_Info->sTrack_Info[dChunkNo].dMtrSize = (unsigned int)sdChunkSize;
+ psLoad_Info->sTrack_Info[dChunkNo].dMtrSize = dChunkSize;
break;
case AVMALIB_CHUNKCODE_ATR:
if (dChunkNo != 0)
break;
psLoad_Info->sTrack_Info[AV_MMF_ATR_TRACK_NO].pbMtr = &(pbBuf[dIndex]);
- psLoad_Info->sTrack_Info[AV_MMF_ATR_TRACK_NO].dMtrSize = (unsigned int)sdChunkSize;
+ psLoad_Info->sTrack_Info[AV_MMF_ATR_TRACK_NO].dMtrSize = dChunkSize;
break;
default:
break;
}
- dIndex += sdChunkSize;
+ dIndex += dChunkSize;
}
-
-
/* Error Check of Track Chunk */
switch (psLoad_Info->dSmafType) {
case AV_MMF_SMAF_TYPE_MA2:
- sdResult = _mmf_TrackChunkCheck2(psLoad_Info);
+ mm_file_retvm_if_fails(DEBUG, __mmf_TrackChunkCheck2(psLoad_Info), -1);
break;
case AV_MMF_SMAF_TYPE_MA3:
- sdResult = _mmf_TrackChunkCheck3(psLoad_Info);
+ mm_file_retvm_if_fails(DEBUG, __mmf_TrackChunkCheck3(psLoad_Info), -1);
break;
default:
- if (_mmf_CheckM5P(psLoad_Info) != AV_MMF_FUNC_SUCCESS) return AV_MMF_ERR_CHUNK;
- sdResult = _mmf_TrackChunkCheck5(psLoad_Info);
+ mm_file_retvm_if_fails(DEBUG, __mmf_CheckM5P(psLoad_Info), -1);
+ mm_file_retvm_if_fails(DEBUG, __mmf_TrackChunkCheck5(psLoad_Info), -1);
break;
}
- /* check playback time */
- if (sdResult != AV_MMF_FUNC_SUCCESS) return sdResult;
-
debug_msg(RELEASE, "SUM %u\n", psLoad_Info->dPlayTime * psLoad_Info->dTimeBase);
- if ((psLoad_Info->dPlayTime * psLoad_Info->dTimeBase) <= AV_MMF_PLAY_TIME_MIN) {
- return AV_MMF_ERR_SLENGTH;
- }
- if ((psLoad_Info->dPlayTime * psLoad_Info->dTimeBase) >= AV_MMF_PLAY_TIME_MAX) {
- return AV_MMF_ERR_LLENGTH;
- }
rVal = psLoad_Info->dPlayTime * psLoad_Info->dTimeBase;
- _mmf_GetHvData(psLoad_Info, pbBuf[AV_MMF_POSITION_OF_CTYPE]);
+ mm_file_retvm_if_fails(DEBUG, rVal > AV_MMF_PLAY_TIME_MIN && rVal < AV_MMF_PLAY_TIME_MAX, -1);
+
+ __mmf_GetHvData(psLoad_Info, pbBuf[AV_MMF_POSITION_OF_CTYPE]);
psLoad_Info->pbMmmd = pbBuf;
psLoad_Info->dMmmdSize = dSize;
- psLoad_Info->dCrc = (unsigned int)dCalcCrc;
+ psLoad_Info->dCrc = dCalcCrc;
+
return rVal;
}
-
-/*********************************************************************************
- * _mmf_RenewalProfile
- *
- * Description:
- * renew profile data
- * Argument:
- * pbFile pointer to SMAF data
- * Return:
- * 0 or 1 success(file id)
- * < 0 error code
- ********************************************************************************/
-static int
-_mmf_RenewalProfile(unsigned char *pbFile)
+static bool __mmf_RenewalProfile(unsigned char *pbFile)
{
PLOADINFO psLoad;
POPTIONINFO psOptn;
psHuf->dMtsqSize = psTrk->dMtsqSize;
if (psTrk->pbMtr[0] == 0x01) {
- psHuf->dSeqSize = _mmf_DecodeInit(psHuf);
- if (psHuf->dSeqSize == AV_MMF_HUFFMAN_TREE_FAILURE) {
- return AV_MMF_FUNC_ERROR;
- }
+ psHuf->dSeqSize = __mmf_DecodeInit(psHuf);
+ if (psHuf->dSeqSize == 0)
+ return false;
}
+
psHuf->psFBuf = psHuf->psBuffer;
psHuf->sbFBit = psHuf->sbBitC;
psHuf->bFByte = psHuf->bByte;
- return AV_MMF_FUNC_SUCCESS;
+ return true;
}
-
-
-
-
-
-static int
-_mmf_ParseSkipXmf2Mmf(unsigned char *pbFile, unsigned int dFSize)
+static bool __mmf_ParseSkipXmf2Mmf(unsigned char *pbFile, unsigned int dFSize, unsigned int *pdSkipOffSet)
{
unsigned int skipVal = 0, sizeOfpbFile = dFSize;
char cmpXmfCMMD[5];
+
if (pbFile)
memcpy(cmpXmfCMMD, pbFile, 4);
else {
debug_error(DEBUG, "NULL pointer!\n");
- return -1;
+ return false;
}
cmpXmfCMMD[4] = 0;
skipVal++;
if (skipVal >= sizeOfpbFile) {
debug_msg(RELEASE, "MMMD Header is not found!\n");
- return -1;
+ return false;
}
}
}
debug_msg(RELEASE, "skip value: %d\n", skipVal);
+ *pdSkipOffSet = skipVal;
- return skipVal;
+ return true;
}
-static int
-mmf_file_mmf_get_duration(char *src, int is_xmf)
+static int __mmf_file_mmf_get_duration(char *src, int is_xmf)
{
- int readed = 0;
- int xmf_skip_offset = 0;
- MMFileIOHandle *fp = NULL;
- unsigned char *buf = 0;
- long long src_size = 0L;
-
- PLOADINFO load_info;
- unsigned char *p_crc = NULL;
- unsigned int dCrc = 0;
- int ret = 0;
+ int readed = 0;
+ unsigned int xmf_skip_offset = 0;
+ MMFileIOHandle *fp = NULL;
+ unsigned char *buf = 0;
+ long long src_size = 0L;
+
+ PLOADINFO load_info;
+ unsigned char *p_crc = NULL;
+ unsigned int dCrc = 0;
+ int ret = 0;
/*total time (millisecond)*/
int ret_msec = 0;
/*if XMF, get skip offset.*/
if (is_xmf) {
- xmf_skip_offset = _mmf_ParseSkipXmf2Mmf(buf, src_size);
- if (xmf_skip_offset == -1) {
+ if (!__mmf_ParseSkipXmf2Mmf(buf, src_size, &xmf_skip_offset)) {
ret_msec = -1;
goto _RELEASE_RESOURCE;
}
}
if (dCrc == load_info->dCrc) {
- if (_mmf_RenewalProfile(buf + xmf_skip_offset) == AV_MMF_FUNC_SUCCESS) {
+ if (__mmf_RenewalProfile(buf + xmf_skip_offset)) {
g_sSmaf_Info.dStatus = AV_MMF_STATUS_LOADED;
ret_msec = -1;
goto _RELEASE_RESOURCE;
}
}
- ret_msec = _mmf_MALoad(buf + xmf_skip_offset, src_size);
+ ret_msec = __mmf_MALoad(buf + xmf_skip_offset, src_size);
_RELEASE_RESOURCE:
projects / platform / core / multimedia / libmm-fileinfo.git / blobdiff