📄 mammfcnv.c
字号:
psPhr[i].dStartTick = psTrk->dStartTick;
if (psPhr[i].dStopPoint >= psTrk->dStopPoint)
psPhr[i].dStopTick = psTrk->dStopTick;
if (psPhr[i].dStopPoint <= psTrk->dStartPoint)
psPhr[i].dStopTick = MMF_STSP_TIME_NULL;
}
}
else { /* MA-5 */
/* check stop point */
if (dStopTick > dPast) {
return MMF_ERR_CHUNK;
}
psTrk->dStartTick = dStartTick;
psTrk->dStopTick = dStopTick;
}
/* calculate playback time of this track */
psTrk->dPlayTime = psTrk->dStopTick - psTrk->dStartTick;
return MMF_FUNC_SUCCESS;
}
/*********************************************************************************
* TrackChunk_Check3
*
* Description:
* MA-3 track chunk check
* Argument:
* psLoad pointer to load information structure
* Return:
* 0 success
* < 0 error code
********************************************************************************/
static SINT32 TrackChunk_Check3(
PLOADINFO psLoad
)
{
PTRACKINFO psTrack;
SINT32 sdResult;
if (psLoad->sTrack_Info[5].pbMtr == NULL) {
return MMF_ERR_SLENGTH;
}
psTrack = &(psLoad->sTrack_Info[5]);
if (psTrack->dMtrSize <= MMF_MINIMUM_TRACKSIZE3) {
return MMF_ERR_CHUNK;
}
sdResult = MTR_Check(psTrack, MMF_SMAF_TYPE_MA3);
if (sdResult != MMF_FUNC_SUCCESS) {
return sdResult;
}
MspI_Check(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 = Decode_init( &(psLoad->sHuffman_Info) );
if (psLoad->sHuffman_Info.dSeqSize == MMF_HUFFMAN_TREE_FAILURE) {
return MMF_ERR_CHUNK;
}
psLoad->pfnGetByte = decode_byte3L;
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 = get_byte3L;
psLoad->sHuffman_Info.dSeqSize = psTrack->dMtsqSize;
psLoad->sHuffman_Info.dReadSize = 0;
psLoad->sHuffman_Info.psFBuf = psTrack->pbMtsq;
psLoad->sHuffman_Info.sbFBit = 0;
psLoad->sHuffman_Info.bFByte = 0;
}
psTrack->dMtsqSize = psLoad->sHuffman_Info.dSeqSize;
sdResult = ST_SP_Check(psTrack);
psTrack->dMtsqSize = psLoad->sHuffman_Info.dMtsqSize;
if (sdResult != MMF_FUNC_SUCCESS) {
return sdResult;
}
sdResult = SeqData_Check3(psLoad, MMF_SMAF_TYPE_MA3);
if (sdResult != MMF_FUNC_SUCCESS) {
return sdResult;
}
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
return MMF_FUNC_SUCCESS;
}
/*********************************************************************************
* CheckM5P
*
* Description:
* MA-5 profile data chunk check
* Argument:
* psLoad pointer to load information structure
* Return:
* 0 success
* < 0 error code
********************************************************************************/
static SINT32 CheckM5P(
PLOADINFO psLoad
)
{
PTRACKINFO psTrk;
PPHRASEINFO psPhr;
POPTIONINFO psOptn;
UINT8 *pbOpda, *pbM5p;
UINT32 dOSize, dMSize, dIndex, dPhraseFlag, i;
UINT32 dChunkID, dChunkNo;
SINT32 sdChunkSize;
psOptn = &(psLoad->sOption_Info);
psTrk = &(psLoad->sTrack_Info[6]);
psPhr = &(psLoad->sPhrase_Info[0]);
pbOpda = psOptn->pbOpda;
dOSize = psOptn->dOpdaSize;
dIndex = 0;
pbM5p = NULL;
dMSize = 0;
/* search Pro5 Chunk */
while (dOSize > (dIndex + MMF_CHUNK_HEADER_SIZE)) {
sdChunkSize = malib_NextChunk(&pbOpda[dIndex], (dOSize - dIndex),
MALIB_CHUNK_PHASE_OPDASUB, &dChunkID, &dChunkNo);
if (sdChunkSize < MASMW_SUCCESS) return MASMW_ERROR;
dIndex += MMF_CHUNK_HEADER_SIZE;
if ((dChunkID == MALIB_CHUNKCODE_M5P) && (dChunkNo == 0x05)) {
pbM5p = &pbOpda[dIndex];
dMSize = (UINT32)sdChunkSize;
break;
}
dIndex += sdChunkSize;
}
if ((pbM5p == NULL) || (dMSize < 12)) return MASMW_ERROR;
dPhraseFlag = get_4byte(&pbM5p[0]);
psTrk->dStartTick = get_4byte(&pbM5p[4]); /* start point */
psTrk->dStopTick = get_4byte(&pbM5p[8]); /* stop point */
dIndex = 12;
if (psTrk->dStartTick >= psTrk->dStopTick) return MASMW_ERROR;
for (i = 0; i < MMF_MAX_PHRASE_INFO; i ++) {
if (dMSize < (dIndex + 8)) break;
if (dPhraseFlag & (0x80000000 >> i)) {
psPhr[i].dStartTick = get_4byte(&pbM5p[dIndex]);
psPhr[i].dStopTick = get_4byte(&pbM5p[dIndex + 4]);
if (psPhr[i].dStartTick >= psPhr[i].dStopTick) {
psPhr[i].dStartTick = MMF_STSP_TIME_NULL;
psPhr[i].dStopTick = MMF_STSP_TIME_NULL;
}
if (psPhr[i].dStartTick < psTrk->dStartTick)
psPhr[i].dStartTick = psTrk->dStartTick;
if (psPhr[i].dStopTick > psTrk->dStopTick)
psPhr[i].dStopTick = psTrk->dStopTick;
dIndex += 8;
}
}
return MASMW_SUCCESS;
}
/*********************************************************************************
* TrackChunk_Check5
*
* Description:
* MA-5 track chunk check
* Argument:
* psLoad pointer to load information structure
* dMode load mode
* Return:
* 0 success
* < 0 error code
********************************************************************************/
static SINT32 TrackChunk_Check5(
PLOADINFO psLoad,
UINT32 dMode
)
{
PTRACKINFO psTrack;
SINT32 sdResult;
if (psLoad->sTrack_Info[6].pbMtr == NULL) {
return MMF_ERR_SLENGTH;
}
psTrack = &(psLoad->sTrack_Info[6]);
if (psTrack->dMtrSize <= MMF_MINIMUM_TRACKSIZE3) {
return MMF_ERR_CHUNK;
}
sdResult = MTR_Check(psTrack, MMF_SMAF_TYPE_MA5);
if (sdResult != MMF_FUNC_SUCCESS) return sdResult;
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 = get_byte3L;
if (dMode == 0) {
psTrack->dPlayTime = psTrack->dStopTick - psTrack->dStartTick;
}
else {
sdResult = SeqData_Check3(psLoad, MMF_SMAF_TYPE_MA5);
if (sdResult != MMF_FUNC_SUCCESS) return sdResult;
}
psLoad->dPlayTime = psTrack->dPlayTime;
psLoad->dStartTime = psTrack->dStartTick;
psLoad->dTimeBase = psTrack->dTimeBase;
return MMF_FUNC_SUCCESS;
}
/*********************************************************************************
* Get_HvData
*
* Description:
* HV Data Chunk Check
* Argument:
* psLoad pointer to load information structure
* bCType Contents Type
* Return:
* nothing
********************************************************************************/
static void Get_HvData(
PLOADINFO psLoad,
UINT8 bCType
)
{
UINT8* pbHvData;
UINT32 dHvDataSize;
UINT8* pbVoice;
UINT8* pbScript;
UINT8* pbSetup;
UINT32 dVoiceSize, dScriptSize, dSetupSize, dIndex;
UINT8 bHvCh;
UINT16 wTag, wSize;
UINT32 dChunkID, dChunkNo;
SINT32 sdChunkSize;
if ((psLoad->dSmafType == MMF_SMAF_TYPE_MA1) ||
(psLoad->dSmafType == MMF_SMAF_TYPE_MA2))
return ;
if ((bCType & 0x0F) == 0x08)
return ;
if (psLoad->dSmafType == MMF_SMAF_TYPE_MA3) {
pbHvData = psLoad->sTrack_Info[5].pbMthv;
dHvDataSize = psLoad->sTrack_Info[5].dMthvSize;
}
else {
pbHvData = psLoad->sTrack_Info[6].pbMthv;
dHvDataSize = psLoad->sTrack_Info[6].dMthvSize;
}
if ((pbHvData == NULL) || (dHvDataSize < MMF_CHUNK_HEADER_SIZE))
return ;
pbVoice = NULL;
pbScript = NULL;
pbSetup = NULL;
dVoiceSize = 0;
dScriptSize = 0;
dSetupSize = 0;
bHvCh = MMF_HV_CHANNEL_NULL;
dIndex = 0;
while (dHvDataSize > (dIndex + MMF_CHUNK_HEADER_SIZE)) {
sdChunkSize = malib_NextChunk(&(pbHvData[dIndex]), (dHvDataSize - dIndex),
MALIB_CHUNK_PHASE_MTHVSUB, &dChunkID, &dChunkNo);
if (sdChunkSize < 0) return ;
dIndex += MMF_CHUNK_HEADER_SIZE;
switch (dChunkID) {
case MALIB_CHUNKCODE_MHVS :
pbSetup = &(pbHvData[dIndex]);
dSetupSize = (UINT32)sdChunkSize;
break;
case MALIB_CHUNKCODE_HVP :
if (dChunkNo != 0) break;
pbVoice = &(pbHvData[dIndex - MMF_CHUNK_HEADER_SIZE]);
dVoiceSize = (UINT32)(sdChunkSize + MMF_CHUNK_HEADER_SIZE);
break;
case MALIB_CHUNKCODE_MHSC :
pbScript = &(pbHvData[dIndex]);
dScriptSize = (UINT32)sdChunkSize;
break;
}
dIndex += sdChunkSize;
}
dIndex = 0;
while (dSetupSize >= dIndex + 4 ) {
wTag = (UINT16)((pbSetup[dIndex ] << 8) + pbSetup[dIndex + 1]);
wSize = (UINT16)((pbSetup[dIndex + 2] << 8) + pbSetup[dIndex + 3]);
dIndex += 4;
if (dSetupSize < (dIndex + wSize)) return ;
if ((wTag == 0x4348) && (wSize == 1)) bHvCh = pbSetup[dIndex];
dIndex += wSize;
}
if ((pbScript == NULL) || (bHvCh >= MMF_HV_CHANNEL_NULL))
return ;
psLoad->sHV_Info.pbVoice = pbVoice;
psLoad->sHV_Info.dVoiceSize = dVoiceSize;
psLoad->sHV_Info.pbScript = pbScript;
psLoad->sHV_Info.dScriptSize = dScriptSize;
psLoad->sHV_Info.bHvChannel = bHvCh;
return ;
}
/*********************************************************************************
* Ma_Load
*
* 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 SINT32 Ma_Load(
UINT8* pbFile,
UINT32 dFSize,
UINT32 dMode
)
{
PLOADINFO psLoad_Info;
UINT8 bNo;
UINT32 dChunkID, dChunkNo;
UINT8* pbBuf;
UINT32 dSize, dIndex;
SINT32 sdChunkSize, sdResult;
UINT32 dCalcCrc, dFileCrc;
if ((dMode == 0) || (dMode == 1))
bNo = 1;
else
bNo = 0;
pbBuf = pbFile;
dSize = dFSize;
psLoad_Info = &(gsSmaf_Info.sLoad_Info[bNo]);
Check_Initial( psLoad_Info );
/* check File Chunk(ID/Size) */
sdChunkSize = malib_NextChunk(pbBuf, dSize, MALIB_CHUNK_PHASE_MMMD,
&dChunkID, &dChunkNo);
if ((sdChunkSize < 0) || (dChunkID != MALIB_CHUNKCODE_MMMD)) {
return MMF_ERR_FILE;
}
dSize = (UINT32)(sdChunkSize + MMF_CHUNK_HEADER_SIZE);
dCalcCrc = MMF_CRC_NULL;
if (dMode != 0) { /* Load mode-1/2/3 */
dCalcCrc = malib_MakeCRC(dSize, pbBuf);
dFileCrc = (UINT32)((((UINT32)pbBuf[dSize - 2]) << 8) + pbBuf[dSize - 1]);
if (dCalcCrc != dFileCrc) {
return MMF_ERR_FILE;
}
}
/* check Contents Info Chunk */
dIndex = MMF_CHUNK_HEADER_SIZE;
sdChunkSize = malib_NextChunk(&pbBuf[dIndex], (dSize-dIndex),
MALIB_CHUNK_PHASE_CNTI, &dChunkID, &dChunkNo);
if ((sdChunkSize < 5) || (dChunkID != MALIB_CHUNKCODE_CNTI)) {
return MMF_ERR_FILE;
}
/* check Contents Class */
if ((pbBuf[MMF_POSITION_OF_CCLASS] != MMF_CONTENTS_CLASS_0) &&
(pbBuf[MMF_POSITION_OF_CCLASS] != MMF_CONTENTS_CLASS_1) ) {
return MMF_ERR_CLASS;
}
/* check Contents Type */
dIndex += MMF_CHUNK_HEADER_SIZE;
if (((pbBuf[MMF_POSITION_OF_CTYPE] & 0xF0) == MMF_CONTENTS_TYPE_0) ||
((pbBuf[MMF_POSITION_OF_CTYPE] & 0xF0) == MMF_CONTENTS_TYPE_1) ||
((pbBuf[MMF_POSITION_OF_CTYPE] & 0xF0) == MMF_CONTENTS_TYPE_2) ){
psLoad_Info->dSmafType = MMF_SMAF_TYPE_MA2;
}
else if (((pbBuf[MMF_POSITION_OF_CTYPE] & 0xF0) == MMF_CONTENTS_TYPE_3) ||
((pbBuf[MMF_POSITION_OF_CTYPE] & 0xF0) == MMF_CONTENTS_TYPE_4) ||
((pbBuf[MMF_POSITION_OF_CTYPE] & 0xF0) == MMF_CONTENTS_TYPE_5) ){
switch (pbBuf[MMF_POSITION_OF_CTYPE] & 0x0F) {
case 0x00 :
case 0x01 :
psLoad_Info->dSmafType = MMF_SMAF_TYPE_MA2;
break;
case 0x02 :
case 0x03 :
psLoad_Info->dSmafType = MMF_SMAF_TYPE_MA3;
break;
case 0x04 :
case 0x05 :
case 0x06 :
case 0x07 :
case 0x08 :
psLoad_Info->dSmafType = MMF_SMAF_TYPE_MA5;
break;
default :
return MMF_ERR_TYPE;
}
}
else {
return MMF_ERR_TYPE;
}
/* get pointer & size of option information */
psLoad_Info->sOption_Info.pbCnti = &pbBuf[dIndex];
psLoad_Info->sOption_Info.dCntiSize = (UINT32)(sdChunkSize);
dIndex += sdChunkSize;
if (pbBuf[MMF_POSITION_OF_CTYPE] >= 0x30) {
sdChunkSize = malib_NextChunk(&pbBuf[dIndex], (dSize-dIndex),
MALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
if ((sdChunkSize >= 12) && (dChunkID == MALIB_CHUNKCODE_OPDA)) {
dIndex += MMF_CHUNK_HEADER_SIZE;
psLoad_Info->sOption_Info.pbOpda = &pbBuf[dIndex];
psLoad_Info->sOption_Info.dOpdaSize = (UINT32)sdChunkSize;
dIndex += sdChunkSize;
}
}
/* get Track Chunk information */
while (dSize > (dIndex + MMF_CHUNK_HEADER_SIZE + MMF_FILE_CRC_SIZE)) {
sdChunkSize = malib_NextChunk(&pbBuf[dIndex], (dSize-dIndex),
MALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
if (sdChunkSize < 0) {
if (sdChunkSize == MALIB_CHUNK_ID_ERROR) {
return MMF_ERR_FILE;
}
else {
return MMF_ERR_SIZE;
}
}
dIndex += MMF_CHUNK_HEADER_SIZE;
switch (d⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -