mammfcnv.c

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

        return 0xFFFFFFFF;
    if (pBuf[0] >= 0x80)
        dwTemp = (UINT32)(((pBuf[0] & 0x7F) << 7) + (pBuf[1] & 0x7F) + 128);
    else
        dwTemp = (UINT32)(pBuf[0]);
    return dwTemp;
}


/*******************************************************************************
    Name        : SeqData_Check2
    Description : Check Sequence Data Chunk
    Parameter   : UINT8  *pBuf    ... Pointer to Track Chunk Information
                : UINT32 dwSize   ... Track Chunk Size
                : struct *pPhrase ... Pointer to Phrase Inforamtion
                : UINT8  Type ... SMAF Type
    Return      :  >0: Error
                :   0: Success
*******************************************************************************/
static UINT8 SeqData_Check2(
    UINT8  *pBuf,
    UINT32 dwSize,
    PPHRA  pPhrase,
    UINT8  Type
)
{
    UINT32 i;                                   /* Reference Point            */
    UINT32 dwDelta;                             /* Duration                   */
    UINT32 dwGate;                              /* Gate Time                  */
    UINT32 dwTime;                              /* Past Time                  */
    UINT32 dwTemp;

    i      = 0;
    dwTime = 0;
    dwGate = 0;

    if (pBuf == 0) {
        return SMAF_ERR_SHORT_LENGTH;           /* Mtsq not Exist             */
    }

    while (dwSize > i) {
        if(i == pPhrase->dwSTp)
            pPhrase->dwSTt = dwTime;
        if(i == pPhrase->dwSPp) {
            pPhrase->dwSPt = dwTime;
            break;
        }

        if ((dwSize - i) >= 4) {
            if ((pBuf[i] + pBuf[i+1] + pBuf[i+2] + pBuf[i+3]) == 0) {
                if (Type == SMAF_TYPE_MA1)
                    pPhrase->dwSPt = dwTime + dwGate;
                else
                    pPhrase->dwSPt = dwTime;
                break;
            }
        }

        dwDelta = get_flex2(&(pBuf[i]), (dwSize - i));
        if (dwDelta == 0xFFFFFFFF) {
            return SMAF_ERR_CHUNK;
        }
        if (dwDelta >= 128)
            i++;
        i++;
        dwTime += dwDelta;

        if (dwDelta < dwGate)
            dwGate -= dwDelta;
        else
            dwGate = 0;

        if ((dwSize - i) < 2) {
            return SMAF_ERR_CHUNK;
        }
        if (pBuf[i] == 0x00) {                  /* Control Event              */
            if ((pBuf[i+1] & 0x30) != 0x30)     /* 2 Byte Event               */
                i += 2;
            else                                /* 3 Byte Event               */
                i += 3;
        }
        else if (pBuf[i] == 0xFF) {             /* Exclusive or NOP Event     */
            if (pBuf[i+1] == 0x00)              /* NOP                        */
                i += 2;
            else if (pBuf[i+1] == 0xF0) {       /* Exclusive                  */
                if ((dwSize - i) < 4) {
                    return SMAF_ERR_CHUNK;      /* Size Error                 */
                }
                i += pBuf[i+2] + 3;
                if (dwSize < i) {
                    return SMAF_ERR_CHUNK;      /* Size Error                 */
                }
#if ERROR_CHECK_STRENGTH
                if (pBuf[i-1] != 0xF7) {
                    return SMAF_ERR_CHUNK;      /* Format Error               */
                }
#endif
            }
            else {
                return SMAF_ERR_CHUNK;          /* Event Format Error         */
            }
        }
        else {                                  /* Note Event                 */
            dwTemp = get_flex2(&(pBuf[i+1]), (dwSize - i - 1));
            if (dwTemp == 0xFFFFFFFF) {
                return SMAF_ERR_CHUNK;
            }
            if (dwGate < dwTemp)
                dwGate = dwTemp;
            if (dwTemp >= 128)
                i += 3;
            else
                i += 2;
        }
        if (dwSize < i) {
            return SMAF_ERR_CHUNK;
        }
    } /* while (dwSize > i) */

#if ERROR_CHECK_STRENGTH
    if ((pPhrase->dwSTt == 0xFFFFFFFF) && (pPhrase->dwSTp != 0xFFFFFFFF)) {
        return SMAF_ERR_CHUNK;
    }
#endif
    if (pPhrase->dwSTt == 0xFFFFFFFF)
        pPhrase->dwSTt = 0;

#if ERROR_CHECK_STRENGTH
    if ((pPhrase->dwSPt == 0xFFFFFFFF) && (pPhrase->dwSPp != 0xFFFFFFFF) &&
        (pPhrase->dwSPp != i)) {
        return SMAF_ERR_CHUNK;
    }
#endif
    if (pPhrase->dwSPt == 0xFFFFFFFF) {
        if (Type == SMAF_TYPE_MA1)
            pPhrase->dwSPt = dwTime + dwGate;
        else
            pPhrase->dwSPt = dwTime;
    }
    return F_TRUE;
}


/*******************************************************************************
    Name        : TrackChunk_Check2
    Description : Score Track Chunk Check
    Parameter   : struct  *SmafCheck ... Pointer to File Information
                : UINT8  no         ... Array #(0:旕搊榐,1:搊榐)
    Return      :  >0 ... Error
                :   0 ... Success
*******************************************************************************/
static UINT8 TrackChunk_Check2(
    PSMAFINFO SmafCheck,
    UINT8  no
)
{
    UINT8  result;
    UINT8  i;
    UINT32 dwPlayTime;
    PMTRINFO pMTR;
    PATRINFO pATR;

    result = 0;

    for (i = 1; i < 5; i++) {
        if (SmafCheck->ScoreTrack[i].pMTR != 0)
            result ++;
    }
    if ((result == 0) && (SmafCheck->AudioTrack.pATR == 0)) {
        if (SmafCheck->ScoreTrack[0].pMTR == 0) {
            return SMAF_ERR_SHORT_LENGTH;       /* Track Chunk Nothing        */
        }
        SmafCheck->bSmafType = SMAF_TYPE_MA1;
    }

    if (SmafCheck->bSmafType == SMAF_TYPE_MA1) {/* SMAF Type MA-1             */
        if (SmafCheck->ScoreTrack[0].dwSize <= 6) {
            return SMAF_ERR_CHUNK;              /* Lack Header Information    */
        }
        pMTR = &(SmafCheck->ScoreTrack[0]);
        result = MTR_Check(pMTR, SMAF_TYPE_MA1);
        if (result != 0)
            return result;
        MspI_Check(pMTR);
        result = ST_SP_Check(&(pMTR->Phrase[0]), pMTR->dwSeqSize);
        if (result)
            return result;
        result = Mtsu_Check2(pMTR, SMAF_TYPE_MA1);
        if (result) {
            return result;                      /* Voice Info not Exist       */
        }
        result = SeqData_Check2(pMTR->pSeq, pMTR->dwSeqSize, 
                                &(pMTR->Phrase[0]), SMAF_TYPE_MA1);
        if (result)
            return result;
        pMTR->dwPlayTime = pMTR->Phrase[0].dwSPt - pMTR->Phrase[0].dwSTt;
        SmafCheck->bTimeBase   = pMTR->bTimeBase;
        SmafCheck->dwStartTime = pMTR->Phrase[0].dwSTt;
        SmafCheck->dwPlayTime  = pMTR->dwPlayTime;
    }
    else {                                      /* SMAF Type MA-2             */
        SmafCheck->ScoreTrack[0].pMTR = 0;      /* Erase MA-1 Score Track     */
        SmafCheck->ScoreTrack[0].pSeq = 0;      /* Erase MA-1 Sequence Data   */
        for (i = 1; i < 5; i++) {               /* MTR* Check                 */
            if (SmafCheck->ScoreTrack[i].pMTR != 0) {
                if (SmafCheck->ScoreTrack[i].dwSize <= 6) {
                    return SMAF_ERR_CHUNK;      /* Lack Header Information    */
                }
                pMTR = &(SmafCheck->ScoreTrack[i]);
                result = MTR_Check(pMTR, SMAF_TYPE_MA2);
                if (result != 0)
                    return result;
                MspI_Check(pMTR);
                result = ST_SP_Check(&(pMTR->Phrase[0]), pMTR->dwSeqSize);
                if (result)
                    return result;
                result = SeqData_Check2(pMTR->pSeq, pMTR->dwSeqSize,
                    &(pMTR->Phrase[0]), SMAF_TYPE_MA2);
                if (result)
                    return result;
                pMTR->dwPlayTime = pMTR->Phrase[0].dwSPt -
                    pMTR->Phrase[0].dwSTt;
            }
            else {                              /* Empty Track                */
                pMTR = &(SmafCheck->ScoreTrack[i]);
                pMTR->pPhrase = 0;
                pMTR->pSetup  = 0;
                pMTR->pSeq    = 0;
            }
        }
        if (SmafCheck->AudioTrack.pATR != 0) {  /* ATR0 Check                 */
            if (SmafCheck->AudioTrack.dwSize <= 6) {
                return SMAF_ERR_CHUNK;          /* Lack Header Information    */
            }
            pATR = &(SmafCheck->AudioTrack);
            result = ATR_Check(pATR, no);
            if (result != 0)
                return result;
            AspI_Check(pATR);
            result = ST_SP_Check(&(pATR->Phrase), pATR->dwSeqSize);
            if (result)
                return result;
            result = SeqData_Check2(pATR->pSeq, pATR->dwSeqSize, 
                                    &(pATR->Phrase), SMAF_TYPE_MA2);
            if (result)
                return result;
            pATR->dwPlayTime = pATR->Phrase.dwSPt - pATR->Phrase.dwSTt;
        }
        dwPlayTime = 0;

        for (i = 1; i < 5; i++) {
            if (SmafCheck->ScoreTrack[i].pMTR != 0) {
                pMTR = &(SmafCheck->ScoreTrack[i]);
                SmafCheck->bTimeBase   = pMTR->bTimeBase;
                SmafCheck->dwStartTime = pMTR->Phrase[0].dwSTt;
                SmafCheck->dwPlayTime  = pMTR->dwPlayTime;
                break;
            }
        }
        if (i == 5) {
            SmafCheck->bTimeBase   = SmafCheck->AudioTrack.bTimeBase;
            SmafCheck->dwStartTime = SmafCheck->AudioTrack.Phrase.dwSTt;
            SmafCheck->dwPlayTime  = SmafCheck->AudioTrack.dwPlayTime;
        }
        for (i = i; i < 5; i++) {
            if (SmafCheck->ScoreTrack[i].pMTR == 0)
                continue;
            pMTR = &(SmafCheck->ScoreTrack[i]);
            if ((SmafCheck->bTimeBase   != pMTR->bTimeBase) ||
                (SmafCheck->dwStartTime != pMTR->Phrase[0].dwSTt)) {
                return SMAF_ERR_CHUNK;
            }
            if (SmafCheck->dwPlayTime < pMTR->dwPlayTime)
                SmafCheck->dwPlayTime = pMTR->dwPlayTime;
        }
        if (SmafCheck->AudioTrack.pATR != 0) {
            pATR = &(SmafCheck->AudioTrack);
            if ((SmafCheck->bTimeBase   != pATR->bTimeBase) ||
                (SmafCheck->dwStartTime != pATR->Phrase.dwSTt)) {
                return SMAF_ERR_CHUNK;
            }
            if (SmafCheck->dwPlayTime < pATR->dwPlayTime)
                SmafCheck->dwPlayTime = pATR->dwPlayTime;
        }

        for (i = 1; i < 5; i++) {
            if (SmafCheck->ScoreTrack[i].pMTR == 0)
                continue;
            result = Mtsu_Check2(&(SmafCheck->ScoreTrack[i]), SMAF_TYPE_MA2);
            if (result == F_TRUE)
                break;
        }
        if (result) {
            return result;                      /* Voice Info not Exist       */
        }
    }

    return F_TRUE;
}


/*******************************************************************************
    Name        : Get_LM_Status1
    Description : Get LED Motor Status
    Parameter   : Nothing
    Return      : Nothing
*******************************************************************************/
static void Get_LM_Status1( void )
{
    UINT8  i;
    UINT16 wLed, wMotor;
    SINT32 ret;
    MASMW_CONTENTSINFO Led_State;

    wLed = 0;
    wMotor = 0;
    i = 0;

    Led_State.code   = 0xFF;
    Led_State.tag[0] = 'L';
    Led_State.tag[1] = '2';
    Led_State.buf    = &i;
    Led_State.size   = 1;
    ret = MaMmfCnv_Control(1, MASMW_GET_CONTENTSDATA, &Led_State, 0);
    if (ret == 1) {
		i = (UINT8)(i & 0x0F);
        if (i <= 4)
            wLed = (UINT16)(1 << i);
        if (i == 0x0C)
            wLed = 0x000F;
    }

    i = Smaf_Info[1].ScoreTrack[0].pMTR[4];
    if (i & 0x40)
        wMotor += 1;
    if (i & 0x04)
        wMotor += 2;
    i = Smaf_Info[1].ScoreTrack[0].pMTR[5];
    if (i & 0x40)
        wMotor += 4;
    if (i & 0x04)
        wMotor += 8;

    for (i = 0; i < 16; i++) {
        if (wLed & (1 << i))
            ChInfo[i].bLed = 1;
        else
            ChInfo[i].bLed = 0;
        if (wMotor & (1 << i))
            ChInfo[i].bMotor = 1;
        else
            ChInfo[i].bMotor = 0;
    }
}


/*******************************************************************************
    Name        : Get_LM_Status2
    Description : Get LED Motor Status
    Parameter   : Nothing
    Return      : Nothing
*******************************************************************************/
static void Get_LM_Status2( void )
{
    UINT8  i, j;
    UINT16 wLed, wMotor;
    SINT32 ret;
    MASMW_CONTENTSINFO Led_State;

    wLed = 0;
    wMotor = 0;
    i = 0;