avifile.c

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

    {
#ifdef ON_RKFS
        aviPointer->Video->ReadSize = 0;
        aviPointer->Video->CurOffset = videoChunkSkipTo.CurOffset;
        aviPointer->Video->CurChunkSize = videoChunkSkipTo.CurChunkSize;
        dstIndexPos.Clus = aviPointer->VideoIndex->Clus;
        dstIndexPos.Offset = aviPointer->VideoIndex->Offset;
        beingSkip = AVI_FRAME_SKIP_NONE; //skip mode @ LJN
        skipResume = AVI_RESUME_FIRST_CHUNK;

//get file pointer of 'movi' for video
        dstDataPos = (moviPos.Offset + aviPointer->Video->CurOffset + aviPointer->Video->ReadSize);
#ifdef SEEK_TABLE
        for (i = 0; i < (AVI_VIDEO_POS_INFO_NUM - 1); i++)
        {
            if ((dstDataPos > videoDataPosInfo[i].Offset) && (dstDataPos < videoDataPosInfo[i+1].Offset))
                break;
        }
        if (i < AVI_VIDEO_POS_INFO_NUM)
            AviFastFseek(aviPointer->VideoData, videoDataPosInfo[i].Offset, videoDataPosInfo[i].Clus);
#else
        AviFastFseek(aviPointer->VideoData, moviPos.Offset, moviPos.Clus);
#endif
        AviFseek(aviPointer->VideoData, (long)(dstDataPos) - (long)(aviPointer->VideoData->Offset), SEEK_CUR);
#else
        if (AviGetChunkPointer(aviPointer->VideoData, SIGN_MOVI))
            return -1;
        aviPointer->Video->ReadSize = aviPointer->Video->CurChunkSize;
        AviFseek(aviPointer->VideoData, aviPointer->Video->CurChunkSize - aviPointer->Video->ReadSize, SEEK_CUR);
#endif
        lastSkipPoint = 0;
    }
    return 0;
}

/********************************************************************************************
 Func:
  AviVideoGetNextChunkInfo()
 Description:
  Get next video chunk information.
 Param:
  AviFilePointer *aviPointer - avi file pointer.
  idx1 *videoChunkInfo - chunk information.
 Return:
  0:  Success.
  -1: Get chunk error.
  1: It is a ND frame.
 Author:
  ljn
 Date:
  2007-9-19 9:22
 Log:

********************************************************************************************/
int AviVideoGetNextChunkInfo(AviFilePointer *aviPointer, idx1 *videoChunkInfo)
{

#ifdef ON_RKFS
    /* use this to correct Video Index file pointer if it is wrong. */
    if ((aviPointer->VideoIndex->Offset - idx1Pos.Offset) % (sizeof(idx1)))
        AviFseek(aviPointer->VideoIndex, (sizeof(idx1) - (aviPointer->VideoIndex->Offset - idx1Pos.Offset) % (sizeof(idx1))), SEEK_CUR);
#endif

//Get next video index
    if ((AviFread(videoChunkInfo, sizeof(idx1), 1, aviPointer->VideoIndex)) < sizeof(idx1))
        return -1;
    aviPointer->TotalChunkNum++;

    /* seek video chunk. */
    while (!IS_VIDEO_IDX(videoChunkInfo->dwChunkid))
    {
#ifdef ON_RKFS
        /* return error if reach the end of 'idx1'. */
        if ((aviPointer->VideoIndex->Offset - idx1Pos.Offset) > (indexSize - sizeof(idx1)))     //check if all index is read .
            return -1;

        /* return error if reach the end of file. */
        if ((AviGFSize(aviPointer->VideoIndex)) - (AviFtell(aviPointer->VideoIndex)) < sizeof(idx1))
            return -1;

        /* all video chunks are got out. */
        if (aviPointer->VideoChunkNum >= avih.dwTotalFrames)
            return -1;
#endif
        /* read index. */
        if ((AviFread(videoChunkInfo, sizeof(idx1), 1, aviPointer->VideoIndex)) < sizeof(idx1))
            return -1;
        aviPointer->TotalChunkNum = ((aviPointer->VideoIndex->Offset - idx1Pos.Offset) >> 4);   //aviPointer->TotalChunkNum++;
    }
    aviPointer->VideoChunkNum++;

    if (stream_supported_flag.VideoCodecLib == VIDEO_CODEC_LIB_DIV3)
    {
        videoChunkInfo->dwOffset -= 8;                //都是以movi开始计算offset的，没有问题
        videoChunkInfo->dwSize  += (8 + (videoChunkInfo->dwSize & 0x1));   //将00dc和chunk size计算在内
    }
    else if (stream_supported_flag.VideoCodecLib == VIDEO_CODEC_LIB_MJPG)
    {
        videoChunkInfo->dwOffset -= 4;                //都是以movi开始计算offset的，没有问题
        videoChunkInfo->dwSize  += (4 + (videoChunkInfo->dwSize & 0x1));   //将chunk size计算在内
    }
    else
    {
        ;
    }


    /* if we do not create seek table in the begin , we should save key frame information here for fast positon. */
    if ((videoChunkInfo->dwFlags & 0x00000010) == 0x10)
    {
#ifndef  SEEK_TABLE
        keyFrameList[aviPointer->KeyFrameNum].dwSize = videoChunkInfo->dwSize;
        keyFrameList[aviPointer->KeyFrameNum].dwOffset = videoChunkInfo->dwOffset;
#ifndef ON_RKFS
        keyFrameList[aviPointer->KeyFrameNum].dwNumber = aviPointer->TotalChunkNum;
#else
        keyFrameList[aviPointer->KeyFrameNum].dwNumber = ((aviPointer->VideoIndex->Offset - idx1Pos.Offset) >> 4);
#endif
        keyFrameList[aviPointer->KeyFrameNum].dwVideoFrameNum = aviPointer->VideoChunkNum;
#endif
        aviPointer->KeyFrameNum++;
    }

    if (((long)(videoChunkInfo->dwOffset)) >= ((long)moviCkSize - 8))   /* it is a correct index? */
        return -1;

    if (videoChunkInfo->dwSize == 0)    //ND Frame
    {
        return 1;
    }

    return 0;
}

/********************************************************************************************
 Func:
  AviAudioGetNextChunkInfo()
 Description:
  Get next audio chunk information.
 Param:
  AviFilePointer *aviPointer - avi file pointer.
  idx1 *audioChunkInfo - chunk information.
  char *audioBuffer - Buffer for audio data.
 Return:
  0:  Success.
  -1: Get chunk error.
 Author:
  ljn
 Date:
  2007-9-18 9:58
 Log:

********************************************************************************************/
int AviAudioGetNextChunkInfo(AviFilePointer *aviPointer, idx1 *audioChunkInfo)
{
    int i;

#if 0//#ifdef ON_RKFS
    if ((aviPointer->AudioIndex->Offset - idx1Pos.Offset) % (sizeof(idx1)))
        AviFseek(aviPointer->AudioIndex, (sizeof(idx1) - (aviPointer->AudioIndex->Offset - idx1Pos.Offset) % (sizeof(idx1))), SEEK_CUR);
#endif

//Get next audio index
    if (AviFread(audioChunkInfo, sizeof(idx1), 1, aviPointer->AudioIndex) < sizeof(idx1))
        return -1;

    /* seek audio chunk. */
    //while((audioChunkInfo->dwChunkid & 0xffff0000) != AUDIO_INDEX){
    while (!IS_AUDIO_NO1_IDX(audioChunkInfo->dwChunkid))        //jianhuan
    {
#ifdef ON_RKFS

        // if(aviPointer->AudioChunkNum >=audioChunkNum)
        //  return -1;
        /* use this to ensure the audio index file pointer is in the index. */
        if ((aviPointer->AudioIndex->Offset - idx1Pos.Offset) > (indexSize - sizeof(idx1)))
            return -1;
        /* use this to ensure the audio index file pointer is in the file. */
        if ((AviGFSize(aviPointer->AudioIndex)) - (AviFtell(aviPointer->AudioIndex)) < sizeof(idx1))
            return -1;
#endif
        /* read index. */
        if (AviFread(audioChunkInfo, sizeof(idx1), 1, aviPointer->AudioIndex) < sizeof(idx1))
            return -1;
    }
    aviPointer->AudioChunkNum++;

    audioBytePos += audioChunkInfo->dwSize;

#ifndef SEEK_TABLE
#ifdef ON_RKFS /* Save index pos information for fast position. */
    if ((aviPointer->AudioChunkNum % ((audioChunkNum >> 6) + 1)) == 0)
    {
        i = (aviPointer->AudioChunkNum) / ((audioChunkNum >> 6) + 1);
        audioIndexPosInfo[i].filePos.Clus = aviPointer->AudioIndex->Clus;
        audioIndexPosInfo[i].filePos.Offset = aviPointer->AudioIndex->Offset;
        audioIndexPosInfo[i].streamChunkNum = aviPointer->AudioChunkNum;
        audioIndexPosInfo[i].audioBytePos = audioBytePos;
    }
#endif
#endif
    return 0;
}

/********************************************************************************************
 Func:
  AviAudioGetPreChunkInfo()
 Description:
  Get Pre audio chunk information.
 Param:
  AviFilePointer *aviPointer - avi file pointer.
  idx1 *audioChunkInfo - chunk information.
  char *audioBuffer - Buffer for audio data.
 Return:
  0:  Success.
  -1: Get chunk error.
 Author:
  ljn
 Date:
  2007-9-18 9:58
 Log:

********************************************************************************************/
int AviAudioGetPreChunkInfo(AviFilePointer *aviPointer, idx1 *audioChunkInfo)
{
    /***************************************************
     it is inefficient to use seek back on rockchip file
     system, so we had better not use this function in
     practice.
    ****************************************************/

    /* seek back. */
    AviFseek(aviPointer->AudioIndex, ((int)(0) - (int)sizeof(idx1) - (int)sizeof(idx1)), SEEK_CUR);

    if (AviFread(audioChunkInfo, sizeof(idx1), 1, aviPointer->AudioIndex) < sizeof(idx1))
        return -1;

    /* seek audio chunk. */
    //while((audioChunkInfo->dwChunkid & 0xffff0000) != AUDIO_INDEX){
    while (!IS_AUDIO_NO1_IDX(audioChunkInfo->dwChunkid))        //jianhuan
    {
        AviFseek(aviPointer->AudioIndex, ((int)(0) - (int)sizeof(idx1) - (int)sizeof(idx1)), SEEK_CUR);
        if (AviFread(audioChunkInfo, sizeof(idx1), 1, aviPointer->AudioIndex) < sizeof(idx1))
            return -1;
    }

    aviPointer->AudioChunkNum--;
    audioBytePos -= audioChunkInfo->dwSize;
    return 0;
}

/********************************************************************************************
 Func:
  AviVideoGetDataToSDRAM()
 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.
 Author:
  ljn
 Date:
  2007-9-19 10:28
 Log:

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

    if (skipResume == AVI_RESUME_FIRST_CHUNK)
    {
        aviPointer->Video->ReadSize = 0;
        aviPointer->Video->CurOffset = videoChunkSkipTo.CurOffset;
        aviPointer->Video->CurChunkSize = videoChunkSkipTo.CurChunkSize;
        skipResume = AVI_RESUME_SECOND_CHUNK;
    }

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

    if (remainSize > 0)
    {
#ifdef ON_RKFS
        if (aviPointer->VideoData->Offset != moviPos.Offset + aviPointer->Video->CurOffset + aviPointer->Video->ReadSize)
            AviFseek(aviPointer->VideoData, (long)(moviPos.Offset + aviPointer->Video->CurOffset + aviPointer->Video->ReadSize) - (long)aviPointer->VideoData->Offset, SEEK_CUR);
#endif

        if (remainSize <= sizeToGet)     // Read all remain data to SDRAM
        {
            if (AviFread(buffer, remainSize, 1, aviPointer->VideoData) < remainSize)
                return -1;
            sizeToGet -= remainSize;
            aviPointer->Video->ReadSize = aviPointer->Video->CurChunkSize;
        }
        else            // read size required to SDRAM
        {
            if (AviFread(buffer, sizeToGet, 1, aviPointer->VideoData) < sizeToGet)
                return -1;
            aviPointer->Video->ReadSize += sizeToGet;
            return 0;
        }
    }
    else if ((NDCodeRemain > 0) && (NDCodeRemain < 4))
    {
        if (NDCodeRemain <= sizeToGet)     // Read all remain ND code to SDRAM
        {
            for (i = NDCodeRemain; NDCodeRemain > 0; NDCodeRemain--)
            {
                buffer[i - NDCodeRemain] = NDCode[NDCodeRemain - 1];
            }
            sizeToGet -= NDCodeRemain;
            aviPointer->Video->ReadSize = aviPointer->Video->CurChunkSize;
        }
    }

    if (skipResume == AVI_RESUME_SECOND_CHUNK)
    {
        aviPointer->VideoIndex->Clus = dstIndexPos.Clus;
        aviPointer->VideoIndex->Offset = dstIndexPos.Offset;
        skipResume = AVI_RESUME_OK;
    }

    tempReadSize = aviPointer->Video->ReadSize;

    for (i = sizeToGet;i > 0;i -= aviPointer->Video->ReadSize)
    {
        if (beingSkip != AVI_FRAME_SKIP_NONE)  //skip mode 2 @LJN
        {
            //AviFseek(aviPointer->VideoData, videoChunkSkipTo.CurOffset-aviPointer->Video->CurOffset-aviPointer->Video->ReadSize, SEEK_CUR);
            //aviPointer->Video->ReadSize = 0;
            chunk.dwOffset = videoChunkSkipTo.CurOffset;
            chunk.dwSize = videoChunkSkipTo.CurChunkSize;
            if (beingSkip == AVI_FRAME_SKIP_SYN) //skip mode 2 @ LJN
                AviFseek(aviPointer->VideoIndex, ((int)(idx1Pos.Offset + aviPointer->TotalChunkNum*sizeof(idx1)) - (int)aviPointer->VideoIndex->Offset), SEEK_CUR);  //skip mode 2@LJN
            beingSkip = AVI_FRAME_SKIP_NONE; //skip mode 2@LJN
        }
        else
        {
            if (AviVideoGetNextChunkInfo(aviPointer, &chunk) < 0)
            {
                *size -= i;
                return -1;
            }
        }
        if (chunk.dwSize == 0)      //add ND frame code here
        {
            NDCodeRemain = 4;
            if (i <= 4)
            {
                while (i > 0)
                {
                    buffer[*size-i] = NDCode[NDCodeRemain - 1];
                    i --;
                    NDCodeRemain --;
                }
                aviPointer->Video->ReadSize = tempReadSize;
            }
            else
            {
                for (; NDCodeRemain > 0; NDCodeRemain--)
                {
                    buffer[*size-i] = NDCode[NDCodeRemain - 1];
                    i --;
                }
                aviPointer->Video->ReadSize = 0;
            }
            continue;