📄 malib.c
字号:
case 0xA0:
if(dFs > MALIB_MAX_4BIT_STEREO_FS)
return (MASMW_ERROR_CHUNK);
if((UINT32)sdChunkSize <= (dFs / 50))
return (MASMW_ERROR_SHORT_LENGTH);
MAAUDCNV_DBGMSG(("MaAudCnv : YAMAHA 4bit stereo ADPCM\n"));
dFmt = 0x81L;
break;
default:
MAAUDCNV_DBGMSG(("GetDataInfo/ Wave format error\n"));
return (MASMW_ERROR_CHUNK);
}
pAi->pbSource = &(pMtsp[dIndex + 11]);
pAi->dSizeOfSource = (UINT32)sdChunkSize;
pAi->dFs = dFs;
pAi->dFmt = dFmt;
MAAUDCNV_DBGMSG(("MaAudCnv : Fs = %ld[Hz]\n", pAi->dFs));
MAAUDCNV_DBGMSG(("MaAudCnv : pData = %08lX\n", pAi->pbSource));
MAAUDCNV_DBGMSG(("MaAudCnv : Size = %ld[bytes]\n", pAi->dSizeOfSource));
break;
}
if(dFmt == 0xFFL) return (MASMW_ERROR_SHORT_LENGTH);
return (MASMW_SUCCESS);
}
/****************************************************************************
* SmafAudChecker
*
* Function:
* Get data Info from the file
* Argument:
* pbFile pointer to the SMAF/Audio data.
* dFileSize size of data.
* bMode error check mode(0:No 1:Yes 2:Check only)
* pAi pointer to the MALIBAUDINFO structure.
* Return:
* 0 success.
* < 0 error.
*
****************************************************************************/
static SINT32 SmafAudChecker(UINT8* pbFile, UINT32 dFileSize, UINT8 bMode,
PMALIBAUDINFO pAi)
{
UINT32 dType;
UINT32 dClass;
UINT32 dCRC;
UINT32 dChunkID, dChunkNo;
UINT32 dIndex;
SINT32 sdSize;
SINT32 sdTotalSize;
UINT8* pbChunk;
UINT32 dChunkSize;
MAAUDCNV_DBGMSG(("GetDataInfo \n"));
pAi->pbCnti = NULL;
pAi->dCntiSize = 0;
pAi->pbOpda = NULL;
pAi->dOpdaSize = 0;
dIndex = 0L;
dChunkID = MALIB_CHUNKCODE_UNKNOWN;
sdTotalSize = malib_NextChunk(&(pbFile[dIndex]), dFileSize,
MALIB_CHUNK_PHASE_MMMD, &dChunkID, &dChunkNo);
if((sdTotalSize < 0L) || (dChunkID != MALIB_CHUNKCODE_MMMD)) {
MAAUDCNV_DBGMSG(("GetDataInfo/ ID Error\n"));
return (MASMW_ERROR_FILE);
}
sdTotalSize += MALIB_SIZE_OF_CHUNKHEADER;
if(bMode != 0) {
dCRC = (UINT32)(((UINT32)pbFile[sdTotalSize - 2] << 8) +
(UINT32)pbFile[sdTotalSize - 1]);
if(dCRC != (UINT32)malib_MakeCRC((UINT32)sdTotalSize, pbFile)) {
MAAUDCNV_DBGMSG(("GetDataInfo/ CRC error\n"));
return (MASMW_ERROR_FILE);
}
}
dIndex = MALIB_SIZE_OF_CHUNKHEADER;
sdSize = malib_NextChunk(&pbFile[dIndex], (sdTotalSize - dIndex),
MALIB_CHUNK_PHASE_CNTI, &dChunkID, &dChunkNo);
if((sdSize < MALIB_SIZE_OF_MIN_CNTI) || (dChunkID != MALIB_CHUNKCODE_CNTI)) {
MAAUDCNV_DBGMSG(("GetDataInfo/ ID Error\n"));
return (MASMW_ERROR_FILE);
}
dClass = (UINT32)pbFile[16]; /* Contents Class */
dType = (UINT32)pbFile[17]; /* Contents Type */
if( (dClass != (UINT32)MMF_CONTENTS_CLASS_0) &&
(dClass != (UINT32)MMF_CONTENTS_CLASS_1)) {
return (MASMW_ERROR_CONTENTS_CLASS);
}
if (((dType & 0xF0) == MMF_CONTENTS_TYPE_0) ||
((dType & 0xF0) == MMF_CONTENTS_TYPE_1) ||
((dType & 0xF0) == MMF_CONTENTS_TYPE_2) ){
pAi->dSMAFType = 0; /* SMAF MA-1/2 */
}
else if (((dType & 0xF0) == MMF_CONTENTS_TYPE_3) ||
((dType & 0xF0) == MMF_CONTENTS_TYPE_4) ||
((dType & 0xF0) == MMF_CONTENTS_TYPE_5) ){
switch (dType & 0x0F) {
case 0x00 :
case 0x01 :
pAi->dSMAFType = 0; /* SMAF MA-1/2 */
break;
case 0x02 :
case 0x03 :
pAi->dSMAFType = 1; /* SMAF MA-3 */
break;
case 0x04 :
case 0x05 :
case 0x06 :
case 0x07 :
case 0x08 :
pAi->dSMAFType = 2; /* SMAF MA-5 */
break;
default :
return MASMW_ERROR_CONTENTS_TYPE;
}
}
else {
return MASMW_ERROR_CONTENTS_TYPE;
}
dIndex += MALIB_SIZE_OF_CHUNKHEADER;
pAi->pbCnti = &(pbFile[dIndex]);
pAi->dCntiSize = sdSize;
dIndex += (UINT32)sdSize;
MAAUDCNV_DBGMSG(("MaAudCnv : CNTISize = %ld\n", sdSize));
sdSize = malib_NextChunk(&pbFile[dIndex], ((UINT32)sdTotalSize - dIndex),
MALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
if(dChunkID == MALIB_CHUNKCODE_OPDA) { /* Optional Data Chunk */
if((sdSize >= 12L) && (dType >= 0x30)) {
pAi->pbOpda = &(pbFile[dIndex + MALIB_SIZE_OF_CHUNKHEADER]);
pAi->dOpdaSize = (UINT32)sdSize;
}
}
pbChunk = NULL;
dChunkSize = 0;
while((UINT32)sdTotalSize >
(UINT32)(dIndex + MALIB_SIZE_OF_CHUNKHEADER + MALIB_SIZE_OF_CRC)) {
sdSize = malib_NextChunk(&pbFile[dIndex], ((UINT32)sdTotalSize - dIndex),
MALIB_CHUNK_PHASE_MMMDSUB, &dChunkID, &dChunkNo);
if(sdSize < 0L) {
if (sdSize == MALIB_CHUNK_ID_ERROR)
return (MASMW_ERROR_FILE);
else
return (MASMW_ERROR_CHUNK_SIZE);
}
dIndex += MALIB_SIZE_OF_CHUNKHEADER;
switch(dChunkID) {
case MALIB_CHUNKCODE_MTR: /* Score Track Chunk */
if (dChunkNo == 0x05) { /* MTR5 (MA-3) */
if ((pAi->dSMAFType == 1) && (pbChunk == NULL)) {
pbChunk = &pbFile[dIndex];
dChunkSize = (UINT32)sdSize;
}
}
else if (dChunkNo == 0x06) { /* MTR6 (MA-5) */
if ((pAi->dSMAFType == 2) && (pbChunk == NULL)) {
pbChunk = &pbFile[dIndex];
dChunkSize = (UINT32)sdSize;
}
}
break;
case MALIB_CHUNKCODE_ATR: /* Audio Track Chunk */
if (dChunkNo == 0x00) { /* ATR0 (MA-2) */
if ((pAi->dSMAFType == 0) && (pbChunk == NULL)) {
pbChunk = &pbFile[dIndex];
dChunkSize = (UINT32)sdSize;
}
}
break;
default :
break;
}
dIndex += (UINT32)sdSize;
}
if(bMode == 3) return (MASMW_SUCCESS);
if (pbChunk == NULL) return MASMW_ERROR_SHORT_LENGTH;
switch (pAi->dSMAFType) {
case 0 : /* MA-2 */
return GetWaveInfo_2(pbChunk, dChunkSize, pAi);
break;
case 1 : /* MA-3 */
return GetWaveInfo_3(pbChunk, dChunkSize, pAi);
break;
case 2 : /* MA-5 */
return GetWaveInfo_5(pbChunk, dChunkSize, pAi);
break;
default :
return MASMW_ERROR_FILE;
}
}
/****************************************************************************
* malib_smafaudio_checker
*
* Function:
* Get data Info from the file
* Argument:
* pbFile pointer to the SMAF/Audio data.
* dFileSize size of data.
* bMode error check mode(0:No 1:Yes 2:Check only)
* pAi pointer to the MALIBAUDINFO structure.
* Return:
* 0 success.
* < 0 error.
*
****************************************************************************/
SINT32 malib_smafaudio_checker(UINT8* pbData, UINT32 dSize, UINT8 bMode,
void* pvInfo)
{
SINT32 sdRet;
MALIBAUDINFO sInfo;
PMALIBAUDINFO pAi = (PMALIBAUDINFO)pvInfo;
if(pbData == NULL) return (MASMW_ERROR_ARGUMENT);
if(dSize == 0L) return (MASMW_ERROR_ARGUMENT);
if(dSize >= MALIB_AUDIO_SIZE_MAX) return (MASMW_ERROR_ARGUMENT);
if(bMode >= 4) return (MASMW_ERROR_ARGUMENT);
/* call from music API */
if(pAi == NULL) pAi = &sInfo;
/* check data format */
sdRet = SmafAudChecker(pbData, dSize, bMode, pAi);
if ((sdRet < MASMW_SUCCESS) || (bMode == 3)) {
return (sdRet);
}
/* calcurate length[ms] */
if(pAi->dFs == 0) return (MASMW_ERROR);
switch(pAi->dFmt) {
case 0x01L: /* 4bit ADPCM mono */
sdRet = (pAi->dSizeOfSource * 2000L + (pAi->dFs - 1L)) / pAi->dFs;
break;
case 0x02L:
case 0x03L: /* 8bit PCM mono */
case 0x81L: /* 4bit ADPCM stereo */
sdRet = (pAi->dSizeOfSource * 1000L + (pAi->dFs - 1L)) / pAi->dFs;
break;
case 0x82L:
case 0x83L: /* 8bit PCM stereo */
sdRet = (pAi->dSizeOfSource * 500L + (pAi->dFs - 1L)) / pAi->dFs;
break;
default:
return (MASMW_ERROR);
}
pAi->dPlayTime = (UINT32)sdRet;
return (sdRet);
}
/*********************************************************************************
* GetContentsData2
*
* Description:
* get contents information (from MA-2 contents)
* Argument:
* psCI pointer to get contents info structure
* Return:
* 0 success
* < 0 error code
********************************************************************************/
static SINT32 GetContentsData2(
PMALIBGETCINFO psCI
)
{
UINT8 bCode, fbTagMatch, fbDataEnd, bSkip, bData;
SINT32 sdInfoSize;
UINT8* pbBuf;
UINT32 dSize, dIndex;
pbBuf = (psCI->pbCnti + 5);
dSize = (psCI->dCntiSize - 5);
dIndex = 0;
bCode = psCI->pbCnti[2];
if ( (pbBuf == NULL) || (dSize < 4) ||
((psCI->bCode != MALIB_CONTENTS_CODE_BINARY) && (psCI->bCode != bCode)) )
return MASMW_ERROR_UNMATCHED_TAG;
while (dSize >= (dIndex + 4)) {
if ((pbBuf[dIndex] == psCI->bTag[0]) &&
(pbBuf[dIndex+1] == psCI->bTag[1])) {
fbTagMatch = 1;
if (((psCI->bTag[0] == 'L') && (psCI->bTag[1] == '2')) ||
((psCI->bTag[0] == 'M') && (psCI->bTag[1] == '2'))) {
psCI->pbBuf[0] = pbBuf[dIndex+3];
return 1;
}
}
else
fbTagMatch = 0;
fbDataEnd = 0; bSkip = 0; dIndex += 3; sdInfoSize = 0;
while ((dSize >= (dIndex + 1)) && (fbDataEnd == 0)) {
bData = pbBuf[dIndex];
dIndex ++;
if (bSkip == 0) {
if (bData == ',') {
if (fbTagMatch == 1) return sdInfoSize;
fbDataEnd = 1;
continue;
}
if (bData == '\\') {
if ((pbBuf[dIndex] == '\\') || (pbBuf[dIndex] == ','))
bSkip = 1;
continue;
}
if (bCode == MALIB_CONTENTS_CODE_SJIS) {
if (((0x81 <= bData) && (bData <= 0x9F)) ||
((0xE0 <= bData) && (bData <= 0xFC)))
bSkip = 2;
}
if (bCode == MALIB_CONTENTS_CODE_UTF8) {
if ((0xC0 <= bData) && (bData <= 0xDF)) bSkip = 2;
if ((0xE0 <= bData) && (bData <= 0xFC)) bSkip = 3;
}
}
if (fbTagMatch == 1) {
psCI->pbBuf[sdInfoSize] = bData;
sdInfoSize ++;
if (psCI->dBufSize == (UINT32)sdInfoSize) return sdInfoSize;
}
if (bSkip != 0) bSkip --;
}
}
return MASMW_ERROR_UNMATCHED_TAG;
}
/*********************************************************************************
* GetContentsData3
*
* Description:
* get contents information (from MA-3 contents)
* Argument:
* get contents information (from MA-2 contents)
* Return:
* 0 success
* < 0 error code
********************************************************************************/
static SINT32 GetContentsData3(
PMALIBGETCINFO psCI
)
{
UINT8 *pbOpda, *pbDch, *pbInfo;
UINT32 dOSize, dDSize, dISize, dIndex, dTemp;
SINT32 sdChunkSize ;
UINT32 dChunkID, dChunkNo, i;
pbOpda = psCI->pbOption;
dOSize = psCI->dOptionSize;
pbDch = NULL;
dDSize = 0;
pbInfo = NULL;
dISize = 0;
dIndex = 0;
if ((pbOpda == NULL) || (dOSize < 12)) return MASMW_ERROR_UNMATCHED_TAG;
while (dOSize > (dIndex + MALIB_SIZE_OF_CHUNKHEADER)) {
sdChunkSize = malib_NextChunk(&pbOpda[dIndex], (dOSize-dIndex),
MALIB_CHUNK_PHASE_OPDASUB, &dChunkID, &dChunkNo);
if (sdChunkSize < 0) return MASMW_ERROR;
dIndex += MALIB_SIZE_OF_CHUNKHEADER;
if ((dChunkID == MALIB_CHUNKCODE_DCH) && (dChunkNo == psCI->bCode)) {
pbDch = &pbOpda[dIndex];
dDSize = (UINT32)sdChunkSize;
}
dIndex += sdChunkSize;
}
if ((pbDch == NULL) || (dDSize < 4)) return MASMW_ERROR_UNMATCHED_TAG;
dIndex = 0;
while (dDSize >= (dIndex + 4)) {
dTemp = (((UINT32)pbDch[dIndex + 2]) << 8) + pbDch[dIndex + 3];
if (dDSize < dTemp + 4 + dIndex) return MASMW_ERROR;
if ((pbDch[dIndex] == psCI->bTag[0]) &&
(pbDch[dIndex + 1] == psCI->bTag[1])) {
pbInfo = &(pbDch[dIndex + 4]);
dISize = dTemp;
}
dIndex += (dTemp + 4);
}
if (pbInfo == NULL) return MASMW_ERROR_UNMATCHED_TAG;
if (dISize > psCI->dBufSize) dISize = psCI->dBufSize;
for (i = 0; i < dISize; i++) psCI->pbBuf[i] = pbInfo[i];
return dISize;
}
/*********************************************************************************
* malib_GetContentsData
*
* Description:
* get contents information
* Argument:
* psCI pointer to get contents info structure
* Return:
* 0 success
* < 0 error code
********************************************************************************/
SINT32 malib_GetContentsData(
PMALIBGETCINFO psCI
)
{
UINT16 wTag;
wTag = (UINT16)((((UINT16)psCI->bTag[0]) << 8) + (UINT16)psCI->bTag[1]);
if ((psCI->pbBuf == NULL) || (psCI->dBufSize == 0) || (psCI->pbCnti == NULL))
return MASMW_ERROR_ARGUMENT;
switch (wTag) {
case 0x4330 :
*(psCI->pbBuf) = psCI->pbCnti[0];
return 1;
case 0x4331 :
*(psCI->pbBuf) = psCI->pbCnti[1];
return 1;
case 0x4332 :
*(psCI->pbBuf) = psCI->pbCnti[3];
return 1;
case 0x4333 :
*(psCI->pbBuf) = psCI->pbCnti[4];
return 1;
default :
if (psCI->pbCnti[1] < 0x30) return GetContentsData2(psCI);
else return GetContentsData3(psCI);
}
}
/****************************************************************************
* malib_hvscript_checker
*
* Function:
* Check the data is correct HV-Script or not.
* Argument:
* pbFile pointer to the HV-Script data.
* dFileSize size of data.
* Return:
* 0 correct HV-Script.
* < 0 error data.
*
****************************************************************************/
SINT32 malib_hvscript_checker(UINT8* pbData, UINT32 dSize)
{
/* argument check */
if(pbData == NULL ||
dSize <= 4 ||
dSize > 0x7FFFFFFF)
return MASMW_ERROR_ARGUMENT;
/* HV-Script Header Information Check */
if(*pbData != 'H' ||
*(pbData + 1) != 'V' ||
*(pbData + 2) != '#' ||
*(pbData + 3) != 'J')
return MASMW_ERROR_FILE;
return MASMW_SUCCESS;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -