mammfcnv.c

是一个手机功能的模拟程序

    Name        : Search_OffList2
    Description : Search Note OFF List Block (MA-2 FM Note)
    Parameter   : UINT8  ch     ... Channel #
                : UINT32 dwTime ... Note OFF time
    Return      :   0 ... Fail
                :  !0 ... Success(Pointer to Found Note OFF List)
*******************************************************************************/
static POFFLIST Search_OffList2(
    UINT8  ch,
    UINT32 dwTime
)
{
    void **Next;
    POFFLIST pOff;

    Next = &(Play_Info.pNextOFF);
    pOff = (POFFLIST)*Next;
    while (pOff != 0) {
        if ((pOff->dwCh == ch) && (pOff->dwTime > dwTime) && 
            (pOff->dwType != MMF_EVENT_STREAM_OFF_MA2)) {
            *Next = pOff->pNext;
            return pOff;
        }
        Next = &(pOff->pNext);
        pOff = (POFFLIST)*Next;
    }
    return 0;
}


/*******************************************************************************
    Name        : Search_OffListA
    Description : Search Note OFF List Block (MA-2 Stream Note)
    Parameter   : UINT32 dwTime ... Note OFF time
    Return      :   0 ... Fail
                :  !0 ... Success(Pointer to Found Note OFF List)
*******************************************************************************/
static POFFLIST Search_OffListA(
    UINT32 dwTime
)
{
    void **Next;
    POFFLIST pOff;

    Next = &(Play_Info.pNextOFF);
    pOff = (POFFLIST)*Next;
    while (pOff != 0) {
        if ((pOff->dwTime > dwTime) &&
            (pOff->dwType == MMF_EVENT_STREAM_OFF_MA2)) {
            *Next = pOff->pNext;
            return pOff;
        }
        Next = &(pOff->pNext);
        pOff = (POFFLIST)*Next;
    }
    return 0;
}


/*******************************************************************************
    Name        : Search_OffList3
    Description : Search Note OFF List Block (MA-3 Stream Note)
    Parameter   : UINT8  ch     ... Channel #
                : UINT8  key    ... Key #
                : UINT32 dwTime ... Note OFF time
    Return      :   0 ... Fail
                :  !0 ... Success(Pointer to Found Note OFF List)
*******************************************************************************/
static POFFLIST Search_OffList3(
    UINT8  ch,
    UINT8  key,
    UINT32 dwTime
)
{
    void **Next;
    POFFLIST pOff;

    Next = &(Play_Info.pNextOFF);
    pOff = (POFFLIST)*Next;
    while (pOff != 0) {
        if ((pOff->dwCh == ch)&&(pOff->dwKey == key)&&(pOff->dwTime > dwTime)) {
            *Next = pOff->pNext;
            return pOff;
        }
        Next = &(pOff->pNext);
        pOff = (POFFLIST)*Next;
    }
    return 0;
}


/*******************************************************************************
    Name        : Set_EventEOS
    Description : Event Convert Process
    Parameter   : Nothing
    Return      : Number of Set Command
*******************************************************************************/
static SINT32 Set_EventEOS( void )
{
    UINT32 dwTime;

    if (Play_Info.bEOS == 0xFF)
        return 0;
    if (Play_Info.bEOS == 16) {
        MaSndDrv_SetCommand(MmfSeqID, 0, MASNDDRV_CMD_USER_EVENT,
            MASMW_MAX_USEREVENT, 0, 0);
        if(Play_Info.wLED)
            dwEventFlag |= (UINT32)EVENT_LED_OFF;
        if(Play_Info.wMOTOR)
            dwEventFlag |= (UINT32)EVENT_MOTOR_OFF;
        Play_Info.wLED = 0;
        Play_Info.wMOTOR = 0;
        Play_Info.bEOS = 0xFF;
        return 1;
    }
    if ((dwEndTick > Play_Info.dwPastTime) && (Play_Info.bEOS == 0))
        dwTime = (dwEndTick - Play_Info.dwPastTime) * Play_Info.bTimeBaseR;
    else
        dwTime = 0;
    MaSndDrv_SetCommand(MmfSeqID, dwTime, MASNDDRV_CMD_ALL_SOUND_OFF,
        Play_Info.bEOS, 0, 0);
    Play_Info.bEOS++;
    return 1;
}


/*--- Common A    Function ---------------------------------------------------*/
/*--- SMAF MA-1/2 Function ---------------------------------------------------*/

/*******************************************************************************
    Name        : CNTI_Check2
    Description : Contents Info Chunk Check (SMAF MA-1/2)
    Parameter   : UINT8  *pBuffer ... Pointer to CNTI
    Return      :  <0 ... Error
                : =>0 ... Success
*******************************************************************************/
static SINT32 CNTI_Check2(
    UINT8  *pBuffer
)
{
    UINT8  bTemp;

    bTemp = pBuffer[0];                         /* Contents Class             */
    if ((bTemp != CONTENTS_CLASS_1) && (bTemp != CONTENTS_CLASS_2))
        return MMFCNV_ERR_C_CLASS;

    bTemp = (UINT8)(pBuffer[1] & 0xF0);         /* Contents Type              */
    if (bTemp <= 0x2F) {
        if ((bTemp != CONTENTS_TYPE_1) && (bTemp != CONTENTS_TYPE_2)
                && (bTemp != CONTENTS_TYPE_3))
            return MMFCNV_ERR_C_TYPE;
    }
    else {
        if ((bTemp != CONTENTS_TYPE_4) && (bTemp != CONTENTS_TYPE_5)
            && (bTemp != CONTENTS_TYPE_6))
            return MMFCNV_ERR_C_TYPE;
    }
    return F_TRUE;
}


/*******************************************************************************
    Name        : ATR_Check
    Description : Audio Track Chunk Check
    Parameter   : struct *ATR  ... Pointer to Audio Track Chunk Information
                : UINT8  no   ... Array #
    Return      :  >0 ... Error
                :   0 ... Success
*******************************************************************************/
static UINT8 ATR_Check(
    PATRINFO ATR,
    UINT8  no
)
{
    UINT32 index;
    UINT32 result;
    UINT32 dwSize;
    UINT8  *pBuf;
    UINT16 wNextID;
    SINT32 slNextSize;
    UINT32 dwSR;
    UINT8  bWaveN, bWaveF;

    ATR->pPhrase = 0;
    ATR->pSeq    = 0;

    if (ATR->pATR[0] != 0x00) {
        return SMAF_ERR_CHUNK;                  /* Format Type Error!!        */
    }
    if (ATR->pATR[1] != 0x00) {
        return SMAF_ERR_CHUNK;                  /* Sequence Type Error!!      */
    }
    switch (ATR->pATR[2]) {
        case 0x10 :                             /* Mono, ADPCM, 4000Hz        */
            dwSR = 4000;
            break;
        case 0x11 :                             /* Mono, ADPCM, 8000Hz        */
            dwSR = 8000;
            break;
        default :
            return SMAF_ERR_CHUNK;              /* Wave Type Error!!          */
    }
    if ((ATR->pATR[3] & 0xF0) != 0x00) {
        return SMAF_ERR_CHUNK;                  /* Wave Type Error!!          */
    }
    if (ATR->pATR[4] != ATR->pATR[5]) {
        return SMAF_ERR_CHUNK;                  /* Time Base Error!!          */
    }
    result = (UINT32)_get_timebase(ATR->pATR[4]);
    if (result == 0) {
        return SMAF_ERR_CHUNK;                  /* Time Base Error!!          */
    }
    ATR->bTimeBase = (UINT8)result;

    dwSize = ATR->dwSize;
    pBuf   = ATR->pATR;
    index  = 6;
    if ( no ) {
        for (bWaveN = 0; bWaveN < 62; bWaveN++)
            Wave_Info2[bWaveN].pWave = 0;
    }
    bWaveN       = 0;
    bWaveF       = 0;

    while ((dwSize - index) > SIZE_OF_CHUNKHEADER) {
        slNextSize = NextChunk( 6, &pBuf[index], (dwSize - index), &wNextID);
        if (slNextSize < 0) {
            return SMAF_ERR_CHUNK;
        }
        index += SIZE_OF_CHUNKHEADER;
        switch((UINT8)(wNextID & 0x00FF)){
            case 0x0E:                          /* Seek & Phrase Info Chunk   */
                ATR->pPhrase      = &pBuf[index];
                ATR->dwPhraseSize = (UINT32)slNextSize;
                break;
            case 0x10:                          /* Sequense Data Chunk        */
                ATR->pSeq         = &pBuf[index];
                ATR->dwSeqSize    = (UINT32)slNextSize;
                break;
            case 0x11:                          /* Wave Data Chunk            */
                bWaveN = (UINT8)((wNextID >> 8) & 0x00FF);
                if ((bWaveN < 0x01) || (0x3E < bWaveN))
                    break;
                bWaveF = 1;
                if (no == 0)
                    break;
                if (Wave_Info2[bWaveN-1].pWave != 0)
                    break;
                Wave_Info2[bWaveN-1].dwSR       = dwSR;
                Wave_Info2[bWaveN-1].pWave      = &pBuf[index];
                Wave_Info2[bWaveN-1].dwWaveSize = (UINT32)slNextSize;
                break;
            case 0x0F:                          /* Setup Data Chunk           */
            case 0xFF:                          /* Unknown Chunk              */
                break;
            default:
                return SMAF_ERR_CHUNK;
        }
        index += slNextSize;
    }
    if ((ATR->pSeq == 0) || (bWaveF == 0))
        return SMAF_ERR_SHORT_LENGTH;
    else
        return F_TRUE;
}


/*******************************************************************************
    Name        : AspI_Check
    Description : Get Seek & Phrase Information
    Parameter   : struct  *ATR ... Pointer to Audio Track Chunk Information
    Return      : Nothing
*******************************************************************************/
static void AspI_Check(
    PATRINFO ATR
)
{
    UINT8  *pBuf;
    UINT32 dwSize;
    UINT16 tag;

    ATR->Phrase.dwSTp = 0xFFFFFFFF;
    ATR->Phrase.dwSPp = 0xFFFFFFFF;
    ATR->Phrase.dwSTt = 0xFFFFFFFF;
    ATR->Phrase.dwSPt = 0xFFFFFFFF;
    if (ATR->pPhrase == 0)
        return;
    pBuf   = ATR->pPhrase;
    dwSize = ATR->dwPhraseSize;

    while( dwSize >= 8 ) {
        tag = (UINT16)((pBuf[0] << 8)+ pBuf[1]);/* TAG                        */
        pBuf += 3;                              /* Pointer Adjustment         */
        switch( tag ) {
            case 0x7374:                        /* Start Point                */
                ATR->Phrase.dwSTp = _get4b(&pBuf);
                dwSize -= 8;
                break;
            case 0x7370:                        /* Stop Point                 */
                ATR->Phrase.dwSPp = _get4b(&pBuf);
                dwSize -= 8;
                break;
            default:
                dwSize = 0;
                break;
        }
        pBuf ++;                                /* ','                        */
    }
}


/*******************************************************************************
    Name        : Mtsu_Check2
    Description : Setup Data Check
    Parameter   : struct  *MTR ... Pointer to Score Track Chunk Information
                : UINT8  Type ... SMAF Type
    Return      :  >0 ... Error
                :   0 ... Success
*******************************************************************************/
static UINT8 Mtsu_Check2(
    PMTRINFO MTR,
    UINT8  Type
)
{
#if ERROR_CHECK_STRENGTH
    UINT8  *pBuf;
    UINT32 dwSize;
    UINT32 index;

    pBuf   = MTR->pSetup;
    dwSize = MTR->dwSetupSize;
    index  = 0;

    if (pBuf == 0)
        return SMAF_ERR_CHUNK;
    while ((dwSize - index) > 20) {
        if ((pBuf[index] != 0xFF) || (pBuf[index + 1] != 0xF0))
            return SMAF_ERR_CHUNK;
        if (pBuf[index + 3] == 0x43) {
            if ((Type == SMAF_TYPE_MA1) && (pBuf[index + 4] == 0x02))
                return F_TRUE;
            if ((Type == SMAF_TYPE_MA2) && (pBuf[index + 4] == 0x03))
                return F_TRUE;
        }
        index += (pBuf[index + 2] + 3);
    }
    return SMAF_ERR_CHUNK;
#else
    return F_TRUE;
#endif
}


/*******************************************************************************
    Name        : get_flex2
    Description : Check Sequence Data Chunk (Score Track Chunk)
    Parameter   : UINT8  *pBuf  ... Pointer to Sequence Data
                : UINT32 dwSize ... Reamin Sequence Data Size
    Return      :  0xFFFFFFFF: Error
                : !0xFFFFFFFF: Success
*******************************************************************************/
static UINT32 get_flex2(
    UINT8  *pBuf,
    UINT32 dwSize
)
{
    UINT32 dwTemp;

    if ((dwSize < 1) || ((dwSize < 2) && (pBuf[0] >= 0x80)))
        return 0xFFFFFFFF;
    if ((dwSize >= 4) &&
        ((pBuf[0] == 0) && (pBuf[1] == 0) && (pBuf[2] == 0) && (pBuf[3] == 0)))