id3.c

瑞星微公司RK27XX系列芯片的SDK开发包

        cTargetBuf[iStringSize] = NULL;
#endif
        return iStringSize;
    }

    return Result;
}

/******************************************************
Name:  ID3_UpdateBufferData
Desc:  更新缓冲数据
Param: 文件指针，目标缓冲，已存长度，偏移
Return:
Global: 无
Note:  无
Author: FSH
Log:
/******************************************************/
int ID3_UpdateBufferData(int fHandle, unsigned char *tempbuf, int iRemainSize, int iOffset)
{
    int result;
    int iReadSize;

    if (iRemainSize < MAX_ID3_FIND_SIZE)
    {
        iReadSize = iRemainSize;
    }
    else
    {
        iReadSize = MAX_ID3_FIND_SIZE;
    }
    result = ID3_SeekData(fHandle, iOffset, FSEEK_SET);
    result = ID3_ReadData(fHandle, (char*)tempbuf, iReadSize);
    if (result <= 0)
    {
        return -1;
    }

    return iReadSize;
}

/******************************************************
Name:  ID3_GetID3_V2X
Desc:  读取ID3 V2数据
Param: 文件指针，ID3 信息，缓冲区
Return:
Global: 无
Note:  无
Author: FSH
Log:
/******************************************************/
int ID3_GetID3_V2X(int fHandle, pstID3V2XInfoType pstID3V2XInfo, unsigned char *tempbuf)
{
    int i, j, ID3tag_headerSize = 10;
    int iFrameOffset;
    int iFrameInfo;
    int iFrameSize;
    int iCopySize;
    int iFileSize;
    int iReadSize;
    int iTotalSize;
    int iRemainSize;
    int iCurrentOffset = 0;
    int iHeaderSize;
    int iMetaCnt = -1;
    int iVersion;
    int iOffset = 0;

    unsigned int  tc = 0, temptrack = 0;
    unsigned char  trackbuf[4];

    pID3V2XFrameInfoType pID3V2XFrameInfo;
    pID3V22FrameInfoType pID3V22FrameInfo;

    iHeaderSize   = (3 + (int)sizeof(ID3V2XHeaderType) + (int)sizeof(ID3V2XHeaderType));
    iFileSize   = RKFIO_FLength((MY_FILE*)fHandle);
    iRemainSize   = iFileSize;
    iTotalSize    = 0;
    iCurrentOffset = 0;

    //////////////////////////////////////////////////////////////////////
    iReadSize = ID3_UpdateBufferData(fHandle, tempbuf, iRemainSize, 0);
    iCurrentOffset = iReadSize;
    iRemainSize    -= iReadSize;

    //if (tempbuf[0] == 'I' && tempbuf[1] == 'D' && tempbuf[2] == '3' && tempbuf[2] == 0x03)  // ID3V2.3
    if (tempbuf[0] == 'I' && tempbuf[1] == 'D' && tempbuf[2] == '3' && tempbuf[3] == 0x03)  // ID3V2.3
    {
        iTotalSize = ID3_GetID3V2xHeader(&tempbuf[0], &iFrameOffset, &iVersion);
        if ((iTotalSize == -1) || (iTotalSize == 0))
        {
            return -1;
        }
    }
    else
    {
        return -1;
    }

    if (iVersion < 3)
    {
        iOffset = sizeof(ID3V22FrameInfoType);
    }
    else
    {
        iOffset = sizeof(ID3V2XFrameInfoType);
    }
    for (i = 3, j = 3 ; i < iFileSize && i < iTotalSize + (ID3tag_headerSize - 3);)

    {
        if (iTotalSize > 0)
        {
            if (j + iOffset + MAX_ID3V2_FIELD > iReadSize)
            {
                iCurrentOffset = i;
                iRemainSize    = iFileSize - i;
                iReadSize = ID3_UpdateBufferData(fHandle, tempbuf, iRemainSize, iCurrentOffset);
                iCurrentOffset += iReadSize;
                iRemainSize    -= iReadSize;
                j = 0;
            }

            iFrameInfo = ID3_GetFrameInfo((char*) & tempbuf[j], iVersion);

            if (iFrameInfo != ID3_NONINFO)
            {
                iMetaCnt = 1;
                if (iVersion < 3)
                {
                    pID3V22FrameInfo = (pID3V22FrameInfoType) & tempbuf[j];
                    iFrameSize = ID3_Get3ByteValue(pID3V22FrameInfo->mSize);

                    //Add by Vincent , May 24th , 2008
                    if (iFrameSize == 0)
                        return (-1);

                    iCopySize = iFrameSize;
                    if (iCopySize > MAX_ID3V2_FIELD)
                    {
                        iCopySize = MAX_ID3V2_FIELD - ID3_UNICODE_START;
                    }
                }
                else
                {
                    pID3V2XFrameInfo = (pID3V2XFrameInfoType) & tempbuf[j];
                    iFrameSize =  ID3_Get4byteIntValue(pID3V2XFrameInfo->mSize);
                    iCopySize = iFrameSize;
                    if (iCopySize > MAX_ID3V2_FIELD)
                    {
                        iCopySize = MAX_ID3V2_FIELD - ID3_UNICODE_START;
                    }
                }

                switch (iFrameInfo)
                {
                    case ID3_TRACK:
                        {
                            int k;
                            int Dec = 1;

                            pstID3V2XInfo->mTrack = 0;

                            for (k = 0 ; k < (iFrameSize - 1);k++)
                            {
                                Dec *= 10;
                            }

                            for (k = 0; k < iFrameSize ; k++)
                            {
                                if (tempbuf[j+k+iOffset] >= '0' && tempbuf[j+k+iOffset] <= '9')
                                {
                                    pstID3V2XInfo->mTrack += (tempbuf[j+k+iOffset] - '0') * Dec;
                                }

                                //iTune TrackNum
                                else if (pstID3V2XInfo->mTrack != 0 && (tempbuf[j+k+iOffset] == 0x2F /*||(tempbuf[j+k+iOffset-1] !=0 && ((k= iFrameSize-1)||tempbuf[j+k+iOffset] !=0))*/))
                                {
                                    for (tc = 1; tc < iFrameSize; tc++)
                                    {
                                        if (tempbuf[j+tc+iOffset] == 0x2F || tempbuf[j+tc+iOffset] == 0)
                                            break;
                                    }

                                    temptrack = tc - 1;
                                    memset(trackbuf, 0, 4);
                                    RKmemcpy(trackbuf, &tempbuf[j+iOffset+1], temptrack);

                                    switch (temptrack)
                                    {
                                        case 1:
                                            pstID3V2XInfo->mTrack  = (trackbuf[0] - '0');
                                            break;
                                        case 2:
                                            pstID3V2XInfo->mTrack  = ((trackbuf[0] - '0') * 10) + (trackbuf[1] - '0');
                                            break;

                                        case 3:
                                            pstID3V2XInfo->mTrack  = ((trackbuf[0] - '0') * 100) + (trackbuf[1] - '0') * 10 + (trackbuf[2] - '0');
                                            break;
                                        case 4:
                                            pstID3V2XInfo->mTrack  = ((trackbuf[0] - '0') * 1000) + (trackbuf[1] - '0') * 100 + (trackbuf[2] - '0') * 10 + (trackbuf[3] - '0');
                                            break;

                                        default:
                                            break;
                                    }
                                }

                                Dec /= 10;
                            }
                        }
                        break;
                    case ID3_YEAR:
                        ID3_GetMetaData((unsigned char*)&tempbuf[j+iOffset], (unsigned char*)&pstID3V2XInfo->mYear, iCopySize, iFrameInfo);
                        break;
                    case ID3_NOTUSEDFRAME:
                        break;
                    default:
                        ID3_GetMetaData((unsigned char*)&tempbuf[j+iOffset], (unsigned char*)&pstID3V2XInfo->mMetaData[iFrameInfo][0], iCopySize, iFrameInfo);
                }

                iFrameSize = (iOffset + iFrameSize);
                j += iFrameSize;
                i += iFrameSize;


                if (j > iReadSize)
                {
                    iCurrentOffset = i;
                    iReadSize = ID3_UpdateBufferData(fHandle, tempbuf, iRemainSize, iCurrentOffset);
                    iCurrentOffset += iReadSize;
                    iRemainSize    -= iReadSize;
                    j = 0;
                }

                if ((tempbuf[j] < '0') || (tempbuf[j] > 'Z'))
                    if ((tempbuf[j+1] < '0') || (tempbuf[j+1] > 'Z'))
                        if ((tempbuf[j+2] < '0') || (tempbuf[j+2] > 'Z'))
                        {
                            iTotalSize = 0;
                            return iMetaCnt;
                        }

            }
            else
            {
                j++;
                i++;
            }
        }

        if (j > iReadSize)
        {
            iReadSize = ID3_UpdateBufferData(fHandle, tempbuf, iRemainSize, iCurrentOffset);
            iCurrentOffset += iReadSize;
            iRemainSize    -= iReadSize;

            j = 0;
        }
    }

    return iMetaCnt;
}

/******************************************************
Name:  ID3_GetID3
Desc:  读取ID3数据
Param: 文件指针
Return:
Global: 无
Note:  无
Author: FSH
Log:
/******************************************************/
int ID3_GetID3(int fHandle)
{
    long fpos = RKFIO_FTell(pRawFileCache);
#ifdef MTP_INCLUDE
    fHandle = fHandle;
#else
    unsigned char   *tempbuf;
    pstID3V2XInfoType pID3V2XInfo;
    int     result;
    unsigned char   emptytitle[10] =  "NO Title";
    unsigned char   emptyArtist[10] =  "NO Artist";

    tempbuf  = ID3TempBuff;
    pID3V2XInfo = (pstID3V2XInfoType) & ID3V2XInfo;

#ifdef LRC3_SUPPORT
    LRC3_State = 0;
#endif
    memset((INT8U *)pID3V2XInfo, 0x00, sizeof(stID3V2XInfoType));

    ID3_GetID3_V2X(fHandle, pID3V2XInfo, tempbuf);
    ID3_GetID3_V1X(fHandle, (pstID3V2XInfoType) pID3V2XInfo, (char *)tempbuf);

    if (pID3V2XInfo->mMetaData[ID3_TITLE][0] == NULL)
        RKmemcpy(&pID3V2XInfo->mMetaData[ID3_TITLE][0], emptytitle, 10);

    if (pID3V2XInfo->mMetaData[ID3_ARTIST][0] == NULL)
        RKmemcpy(&pID3V2XInfo->mMetaData[ID3_ARTIST][0], emptyArtist, 10);

// SCR_ID3TitleScroll(&ID3V2XInfo.mMetaData[ID3_ARTIST][0],0);
// SCR_ID3ArtistScroll(&ID3V2XInfo.mMetaData[ID3_TITLE][0],0);

#ifdef RK_TAG_JPEG

    RKFIO_FSeek(pRawFileCache, 0, 0);

    ID3_Jpeg_Decode(CurrentCodec, 0);

#endif

    RKFIO_FSeek(pRawFileCache, fpos, 0);


#endif
    return 0;
}