avifile.c

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

        }
        aviPointer->Video->ReadSize = tempReadSize;
#ifdef ON_RKFS
//        if(aviPointer->VideoData->Offset != moviPos.Offset + aviPointer->Video->CurOffset + aviPointer->Video->ReadSize)
//            tempTest++;

#ifdef SEEK_TABLE
        if ((moviPos.Offset + chunk.dwOffset) < (long)aviPointer->VideoData->Offset)
        {
            for (j = 0; j < (AVI_VIDEO_POS_INFO_NUM - 1); j++)
            {
                if (((moviPos.Offset + chunk.dwOffset) > videoDataPosInfo[j].Offset) && ((moviPos.Offset + chunk.dwOffset) < videoDataPosInfo[j+1].Offset))
                    break;
            }
            if (j < AVI_VIDEO_POS_INFO_NUM)
                AviFastFseek(aviPointer->VideoData, videoDataPosInfo[j].Offset, videoDataPosInfo[j].Clus);
        }
#endif
        AviFseek(aviPointer->VideoData, (long)moviPos.Offset + (long)chunk.dwOffset - (long)aviPointer->VideoData->Offset, SEEK_CUR);

        /*if(aviPointer->VideoData->Offset != moviPos.Offset + chunk.dwOffset){
            aviPointer->Video->ReadSize = 0;
            continue;
        }*/
#else
        AviFseek(aviPointer->VideoData, chunk.dwOffset - aviPointer->Video->CurOffset - aviPointer->Video->ReadSize, SEEK_CUR);
#endif
        if (chunk.dwSize <= (DWORD)i)
        {
            if (AviFread(buffer + *size - i, chunk.dwSize, 1, aviPointer->VideoData) < chunk.dwSize)
                return -1;
            aviPointer->Video->ReadSize = chunk.dwSize;
        }
        else
        {
            if (AviFread(buffer + *size - i, i, 1, aviPointer->VideoData) < i)
                return -1;
            aviPointer->Video->ReadSize = i;
        }
        aviPointer->Video->CurChunkSize = chunk.dwSize;
        aviPointer->Video->CurOffset = chunk.dwOffset;
        tempReadSize = aviPointer->Video->ReadSize;
        //AviFseek(aviPointer->VideoData, (0-aviPointer->Video->CurOffset-aviPointer->Video->ReadSize), SEEK_CUR);
    }

    return 0;
}

/********************************************************************************************
 Func:
  AviAudioGetDataToSDRAM()
 Description:
  Get next video chunk information.
 Param:
  AviFilePointer *aviPointer - avi file pointer.
  char *buffer - Buffer for video data.
  DWORD *size - size to read.
 Return:
  0:  Success.
  -1: Get data error.
  >0: Size got.
 Author:
  ljn
 Date:
  2007-9-19 10:28
 Log:

********************************************************************************************/

int AviAudioGetDataToSDRAM(AviFilePointer *aviPointer, char *buffer, DWORD *size)
{
    long i, remainSize, sizeToGet = *size;
    idx1 chunk;

    remainSize = aviPointer->Audio->CurChunkSize - aviPointer->Audio->ReadSize;   //last chunk remain

    if (remainSize > 0)
    {
        if (remainSize <= sizeToGet)     // Read all remain data to SDRAM
        {
            if (AviFread(buffer, remainSize, 1, aviPointer->AudioData) < remainSize)
                return -1;
            sizeToGet -= remainSize;
            aviPointer->Audio->ReadSize = aviPointer->Audio->CurChunkSize;
        }
        else            // read size required to SDRAM
        {
            if (AviFread(buffer, sizeToGet, 1, aviPointer->AudioData) < sizeToGet)
                return -1;
            aviPointer->Audio->ReadSize += sizeToGet;
            sizeToGet = 0;
        }
    }

    for (i = sizeToGet;i > 0;i -= aviPointer->Audio->ReadSize)
    {
        if (AviAudioGetNextChunkInfo(aviPointer, &chunk) < 0)
        {
            size -= i;
            return -1;
        }
#ifdef ON_RKFS
        AviFseek(aviPointer->AudioData, (long)moviPos.Offset + (long)chunk.dwOffset - (long)aviPointer->AudioData->Offset, SEEK_CUR);
        if (aviPointer->AudioData->Offset != moviPos.Offset + chunk.dwOffset)
            return -1;
#else
        AviFseek(aviPointer->AudioData, chunk.dwOffset - aviPointer->Audio->CurOffset - aviPointer->Audio->ReadSize, SEEK_CUR);
#endif
        if (chunk.dwSize <= (DWORD)i)
        {
            if (AviFread(buffer + *size - i, chunk.dwSize, 1, aviPointer->AudioData) < chunk.dwSize)
                return -1;
            aviPointer->Audio->ReadSize = chunk.dwSize;
        }
        else
        {
            if (AviFread(buffer + *size - i, i, 1, aviPointer->AudioData) < i)
                return -1;
            aviPointer->Audio->ReadSize = i;
        }
        aviPointer->Audio->CurChunkSize = chunk.dwSize;
        aviPointer->Audio->CurOffset = chunk.dwOffset;
        //AviFseek(aviPointer->AudioData, (0-aviPointer->Audio->CurOffset-aviPointer->Audio->ReadSize), SEEK_CUR);
    }
    return 0;
}

/********************************************************************************************
 Func:
  AviAudioSeek()
 Description:
  Seek function for audio decode.
 Param:
  AviFilePointer *aviPointer - avi file pointer.
  long offset - offset.
  int origin - SEEK_SET/SEEK_CUR/SEEK_END.
 Return:
  0:  Success.
  -1: Seek error.
 Author:
  ljn
 Date:
  2007-9-20 10:28
 Log:

********************************************************************************************/
int AviAudioSeek(AviFilePointer *aviPointer, long offset, int origin)
{
    long i, remainSize, sizeToGet = offset;
    DWORD riffType;
    int indexSize;
    idx1 chunk;

    /* mp3 and mp2 audio can only seek to file head. */
    if (aviWavex.wFormatTag == SIGN_WAVE_FORAMT_MPEGLAYER3)
        offset = 0;
    if ((aviWavex.wFormatTag != SIGN_WAVE_FORAMT_AC3) && (offset != 0))
        return 0;

#ifdef ON_RKFS
    AviFastFseek(aviPointer->AudioData, moviPos.Offset, moviPos.Clus);
#else
    if (AviGetChunkPointer(aviPointer->AudioData, SIGN_MOVI))
        return AVI_FILE_NO_MOVI_CHUNK;
    AviFseek(aviPointer->AudioData, 4, SEEK_CUR);
#endif

    if (aviPointer)
    {
        switch (origin)
        {
            case SEEK_SET:
                aviPointer->AudioChunkNum = 0;
                audioBytePos = 0;
#ifdef ON_RKFS
                AviFastFseek(aviPointer->AudioIndex, idx1Pos.Offset, idx1Pos.Clus);
#else
                if (AviGetChunkPointer(aviPointer->AudioIndex, SIGN_IDX1))
                    return -1;
#endif
                if (offset > 0)
                {
                    for (i = offset;i > 0;i -= aviPointer->Audio->ReadSize)
                    {
                        if (AviAudioGetNextChunkInfo(aviPointer, &chunk) < 0)
                        {
                            return 1;
                        }
                        if ((long)chunk.dwSize <= i)
                        {
                            aviPointer->Audio->ReadSize = chunk.dwSize;
                        }
                        else
                        {
                            aviPointer->Audio->ReadSize = i;
                        }
                        aviPointer->Audio->CurChunkSize = chunk.dwSize;
                        aviPointer->Audio->CurOffset = chunk.dwOffset;
                    }
                    AviFseek(aviPointer->AudioData, aviPointer->Audio->CurOffset + aviPointer->Audio->ReadSize, SEEK_CUR);
                }
                else
                {
                    aviPointer->Audio->ReadSize = 0;
                    aviPointer->Audio->CurOffset = 0;
                    aviPointer->Audio->CurChunkSize = 0;
                    aviPointer->AudioChunkNum = 0;
                    audioBytePos = 0;
                }
                break;
            case SEEK_CUR:
                if (offset == 0)
                    break;
                if (offset > 0)
                {
                    remainSize = aviPointer->Audio->CurChunkSize - aviPointer->Audio->ReadSize;
                    if (remainSize > 0)
                    {
                        if (remainSize <= sizeToGet)
                        {
                            sizeToGet -= remainSize;
                            aviPointer->Audio->ReadSize = aviPointer->Audio->CurChunkSize;
                        }
                        else
                        {
                            aviPointer->Audio->ReadSize += sizeToGet;
                            sizeToGet = 0;
                        }
                    }

                    for (i = sizeToGet;i > 0;i -= aviPointer->Audio->ReadSize)
                    {
                        if (AviAudioGetNextChunkInfo(aviPointer, &chunk) < 0)
                        {
                            return 1;
                        }
                        if ((long)chunk.dwSize <= i)
                        {
                            aviPointer->Audio->ReadSize = chunk.dwSize;
                        }
                        else
                        {
                            aviPointer->Audio->ReadSize = i;
                        }
                        aviPointer->Audio->CurChunkSize = chunk.dwSize;
                        aviPointer->Audio->CurOffset = chunk.dwOffset;
                    }
                }
                else
                {
                    if (aviPointer->Audio->ReadSize > 0)
                    {
                        if ((long)(0 - aviPointer->Audio->ReadSize) >= sizeToGet)
                        {
                            sizeToGet += aviPointer->Audio->ReadSize;
                            aviPointer->Audio->ReadSize = 0;
                        }
                        else
                        {
                            aviPointer->Audio->ReadSize += sizeToGet;
                            sizeToGet = 0;
                        }
                    }

                    for (i = sizeToGet;i < 0;)
                    {
                        if (AviAudioGetPreChunkInfo(aviPointer, &chunk) < 0)
                        {
                            return 1;
                        }
                        if ((long)(0 -chunk.dwSize) >= i)
                        {
                            aviPointer->Audio->ReadSize = 0;
                            i += chunk.dwSize;
                        }
                        else
                        {
                            aviPointer->Audio->ReadSize = chunk.dwSize + i;
                            i = 0;
                        }
                        aviPointer->Audio->CurChunkSize = chunk.dwSize;
                        aviPointer->Audio->CurOffset = chunk.dwOffset;
                    }
                }
                break;
            case SEEK_END:
                if (AviGetChunkPointer(aviPointer->AudioIndex, SIGN_IDX1))
                    return -1;

                AviFseek(aviPointer->AudioIndex, indexSize, SEEK_CUR);

                if (offset < 0)
                {
                    for (i = offset;i < 0;)
                    {
                        if (AviAudioGetPreChunkInfo(aviPointer, &chunk) < 0)
                        {
                            return 1;
                        }
                        if ((long)(0 -chunk.dwSize) >= i)
                        {
                            aviPointer->Audio->ReadSize = 0;
                            i += chunk.dwSize;
                        }
                        else
                        {
                            aviPointer->Audio->ReadSize = chunk.dwSize + i;
                            i = 0;
                        }
                        aviPointer->Audio->CurChunkSize = chunk.dwSize;
                        aviPointer->Audio->CurOffset = chunk.dwOffset;
                    }
                }
                else
                {
                    AviAudioGetPreChunkInfo(aviPointer, &chunk);
                    aviPointer->Audio->ReadSize = chunk.dwSize;
                    aviPointer->Audio->CurOffset = chunk.dwOffset;
                    aviPointer->Audio->CurChunkSize = chunk.dwSize;
                }
                break;
            default :
                return -1;
        }
        return 0;
    }
    return -1;
}

/********************************************************************************************
 Func:
  ResetAudioPointer()
 Description:
  Reset Audio Pointer .
 Param:
  AviFilePointer *aviPointer - avi file pointer.
 Return:
  0:  Success.
  -1: Failed.
 Author:
  ljn
 Date:
  2007-9-17 15:53
 Log:

********************************************************************************************/
int ResetAudioPointer(AviFilePointer *aviPointer)
{
    DWORD riffType;
    struct
    {
        FOURCC CkID;
        DWORD Size;
        DWORD Type;
    } list;
#ifdef ON_RKFS

    /***********************************************************
    If we run this program on rk27 file system, in order to seek
    to the 'movi' and 'idx1' position fast, we can save the file
    pointer information when we parse the file. Now, we can use
    fast file seek.
    ************************************************************/

    AviFastFseek(aviPointer->AudioIndex, idx1Pos.Offset, idx1Pos.Clus);
    AviFastFseek(aviPointer->AudioData, moviPos.Offset, moviPos.Clus);
#else
    /***************************************
       [1] get file point