avifile.c

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

        return AVI_FILE_INDX_ERR;
    if (AviGetChunkPointer(aviPointer->VideoData, SIGN_MOVI))
        return AVI_FILE_INDX_ERR;
#endif

#endif

    /* Check audio stream. */
    if (stream_supported_flag.AudioSupportedFlag == FALSE)
    {
        return AVI_FILE_AUDIO_CODEC_ERR;
    }

    return AVI_FILE_PARSING_OK;
}

/********************************************************************************************
 Func:
  AviAudioGetNextChunk()
 Description:
  Get next audio chunk .
 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 AviAudioGetNextChunk(AviFilePointer *aviPointer, idx1 *audioChunkInfo, char *audioBuffer)
{
    MY_FILE *pFile = aviPointer->AudioData;

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

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

    /* update audio position. */
    aviPointer->AudioChunkNum++;
    audioBytePos += audioChunkInfo->dwSize;

//Read data
    /* seek audio data pointer to chunk offset. */
    AviFseek(pFile, audioChunkInfo->dwOffset - aviPointer->Audio->CurOffset - aviPointer->Audio->ReadSize, SEEK_CUR);

    /* read audio data to buffer. */
    if (AviFread(audioBuffer, audioChunkInfo->dwSize, 1, pFile) < audioChunkInfo->dwSize)
        return -1;

    aviPointer->Audio->CurOffset = audioChunkInfo->dwOffset;
    aviPointer->Audio->ReadSize = audioChunkInfo->dwSize;
    return 0;
}

/********************************************************************************************
 Func:
  AviVideoGetNextChunk()
 Description:
  Get next video chunk .
 Param:
  AviFilePointer *aviPointer - avi file pointer.
  idx1 *videoChunkInfo - chunk information.
  char *videoBuffer - Buffer for video data.
 Return:
  0:  Success.
  -1: Get chunk error.
 Author:
  ljn
 Date:
  2007-9-18 10:07
 Log:

********************************************************************************************/
int AviVideoGetNextChunk(AviFilePointer *aviPointer, idx1 *videoChunkInfo, char *videoBuffer)
{

    MY_FILE *pFile = aviPointer->VideoData;

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

    /* seek video index. */
    while (!IS_VIDEO_IDX(videoChunkInfo->dwChunkid))
    {
        aviPointer->TotalChunkNum++;
        if (AviFread(videoChunkInfo, sizeof(idx1), 1, aviPointer->VideoIndex) < sizeof(idx1))
            return -1;
    }
    aviPointer->VideoChunkNum++;

    /* Save key frame information. */
    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++;
    }

    /* ND frame process. */
    if (videoChunkInfo->dwSize == 0)    //ND Frame
    {
//  videoChunkInfo->dwSize = 3;
//  videoBuffer[0] = 'N';
//  videoBuffer[1] = 'D';
//  videoBuffer[2] = 'F';
        return 0;
    }

    /* seek to chunk offset. */
    AviFseek(pFile, videoChunkInfo->dwOffset - aviPointer->Video->CurOffset - aviPointer->Video->ReadSize, SEEK_CUR);

    /* read video data to buffer. */
    if (AviFread(videoBuffer, videoChunkInfo->dwSize, 1, pFile) < videoChunkInfo->dwSize)
        return -1;

    aviPointer->Video->CurOffset = videoChunkInfo->dwOffset;
    aviPointer->Video->ReadSize = videoChunkInfo->dwSize;
    return 0;
}


/********************************************************************************************
 Func:
  AviVideoGetNextIChunk()
 Description:
  Get next video key frame.
 Param:
  AviFilePointer *aviPointer - avi file pointer.
  idx1 *videoChunkInfo - chunk information.
  char *videoBuffer - Buffer for video data.
 Return:
  0:  Success.
  -1: Get chunk error.
 Author:
  ljn
 Date:
  2007-9-18 10:18
 Log:

********************************************************************************************/
int AviVideoGetNextIChunk(AviFilePointer *aviPointer, idx1 *videoChunkInfo, char *videoBuffer, unsigned int step)
{

    MY_FILE *pFile = aviPointer->VideoData;
    int tempFrameNum, i, readNum = AVI_CHUNK_LIST_NUM;
    idx1 tempInfo;
    idx1 *videoIChunkInfo = &tempInfo;

    if (beingSkip && (step != AVI_FFD_FFW_RESUME_FLAG))
        return 0;

    aviPointer->TotalChunkNum = ((aviPointer->VideoIndex->Offset - idx1Pos.Offset) >> 4);
    if (!lastSkipPoint)
    {
        lastSkipPoint = aviPointer->VideoChunkNum;
    }

#ifdef  SEEK_TABLE
    if ((aviPointer->KeyFrameNum >= (totalKeyFrmNum - 1)) && (step != AVI_FFD_FFW_RESUME_FLAG))
        return -1;
    aviPointer->KeyFrameNum ++;
    while ((aviPointer->KeyFrameNum < (totalKeyFrmNum - 1)) && ((int)((int)(keyFrameList[aviPointer->KeyFrameNum - 1].dwVideoFrameNum) - (int)lastSkipPoint) < (int)step))
    {
        aviPointer->KeyFrameNum ++;
    }
    if (aviPointer->KeyFrameNum > totalKeyFrmNum)
        aviPointer->KeyFrameNum = totalKeyFrmNum;
    /* prevent video application from exiting soon.  */
    /*while((avih.dwTotalFrames - keyFrameList[aviPointer->KeyFrameNum-1].dwVideoFrameNum) < 80){
        aviPointer->KeyFrameNum --;
    }*/
    videoIChunkInfo->dwSize = keyFrameList[aviPointer->KeyFrameNum-1].dwSize;
    videoIChunkInfo->dwOffset = keyFrameList[aviPointer->KeyFrameNum-1].dwOffset;
    aviPointer->TotalChunkNum = keyFrameList[aviPointer->KeyFrameNum-1].dwNumber;
    aviPointer->VideoChunkNum = keyFrameList[aviPointer->KeyFrameNum-1].dwVideoFrameNum;

    AviFseek(aviPointer->VideoIndex, ((int)(idx1Pos.Offset + keyFrameList[aviPointer->KeyFrameNum-1].dwNumber*sizeof(idx1)) - (int)aviPointer->VideoIndex->Offset), SEEK_CUR);
#else   /* no seek table */
#if 1
    while (readNum > 2)
    {
        while (((int)(step + lastSkipPoint) - (int)aviPointer->VideoChunkNum) > (int)readNum)
        {
            if ((AviFread(chunkList, 1, sizeof(idx1)*readNum, aviPointer->VideoIndex)) < (sizeof(idx1)*readNum))
                return -1;
            for (i = 0; i < readNum; i++)
            {
                aviPointer->TotalChunkNum ++;
                if (IS_VIDEO_IDX(chunkList[i].dwChunkid))
                {
                    aviPointer->VideoChunkNum++;
                    if (((chunkList[i].dwFlags & 0x00000010) == 0x10))
                    {
                        keyFrameList[aviPointer->KeyFrameNum].dwSize = chunkList[i].dwSize;
                        keyFrameList[aviPointer->KeyFrameNum].dwOffset = chunkList[i].dwOffset;
#if 1   //#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;
                        aviPointer->KeyFrameNum++;
                    }
                }
            }
        }
        readNum -= 2;
    }
#endif
    do
    {
//Get next video index
        if (AviFread(videoIChunkInfo, sizeof(idx1), 1, aviPointer->VideoIndex) < sizeof(idx1))
            return -1;
        aviPointer->TotalChunkNum++;
        if (IS_VIDEO_IDX(videoIChunkInfo->dwChunkid))  //(((videoIChunkInfo->dwChunkid & 0xffff0000) == VIDEO_INDEX))
            aviPointer->VideoChunkNum++;

        while ((!IS_VIDEO_IDX(videoIChunkInfo->dwChunkid)) || ((videoIChunkInfo->dwFlags & 0x00000010) != 0x10)) //(((videoIChunkInfo->dwChunkid & 0xffff0000) != VIDEO_INDEX)||
        {
            //if(((videoIChunkInfo->dwChunkid & 0xffff0000) != VIDEO_INDEX)&&((videoIChunkInfo->dwChunkid & 0xffff0000) != AUDIO_INDEX))
            //    return -1;
            if (aviPointer->VideoChunkNum >= (avih.dwTotalFrames - 1))
                return -1;
            if ((AviFread(videoIChunkInfo, sizeof(idx1), 1, aviPointer->VideoIndex)) < sizeof(idx1))
                return -1;
            aviPointer->TotalChunkNum++;
            if (IS_VIDEO_IDX(videoIChunkInfo->dwChunkid))   //(((videoIChunkInfo->dwChunkid & 0xffff0000) == VIDEO_INDEX))
                aviPointer->VideoChunkNum++;
        }

        keyFrameList[aviPointer->KeyFrameNum].dwSize = videoIChunkInfo->dwSize;
        keyFrameList[aviPointer->KeyFrameNum].dwOffset = videoIChunkInfo->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;
        aviPointer->KeyFrameNum++;
    }
    while (((int)((int)(keyFrameList[aviPointer->KeyFrameNum - 1].dwVideoFrameNum) - (int)lastSkipPoint) < (int)step));
#endif

    lastSkipPoint = aviPointer->VideoChunkNum;
    videoChunkSkipTo.ReadSize = 0;
    videoChunkSkipTo.CurOffset = videoIChunkInfo->dwOffset;
    videoChunkSkipTo.CurChunkSize = videoIChunkInfo->dwSize;
    beingSkip = AVI_FRAME_SKIP_FFD_FFW;  //skip mode 2 @ LJN
    if (step == AVI_FFD_FFW_RESUME_FLAG)
    {
#ifdef ON_RKFS
        aviPointer->Video->ReadSize = 0;
        aviPointer->Video->CurOffset = videoIChunkInfo->dwOffset;
        aviPointer->Video->CurChunkSize = videoIChunkInfo->dwSize;
        dstIndexPos.Clus = aviPointer->VideoIndex->Clus;
        dstIndexPos.Offset = aviPointer->VideoIndex->Offset;
        beingSkip = AVI_FRAME_SKIP_NONE;  //skip mode 2@LJN
        skipResume = AVI_RESUME_FIRST_CHUNK;
        AviFseek(aviPointer->VideoData, (long)(moviPos.Offset + aviPointer->Video->CurOffset + aviPointer->Video->ReadSize) - (long)(aviPointer->VideoData->Offset), SEEK_CUR);
#else
        aviPointer->Video->ReadSize = aviPointer->Video->CurChunkSize;
        AviFseek(aviPointer->VideoData, aviPointer->Video->CurChunkSize - aviPointer->Video->ReadSize, SEEK_CUR);
#endif
        lastSkipPoint = 0;
    }
    return 0;
}


/********************************************************************************************
 Func:
  AviVideoGetPreIChunk()
 Description:
  Get Pre video key frame.
 Param:
  AviFilePointer *aviPointer - avi file pointer.
  idx1 *videoChunkInfo - chunk information.
  char *videoBuffer - Buffer for video data.
 Return:
  0:  Success.
  -1: Get chunk error.
 Author:
  ljn
 Date:
  2007-9-18 10:28
 Log:

********************************************************************************************/
int AviVideoGetPreIChunk(AviFilePointer *aviPointer, idx1 *videoChunkInfo, char *videoBuffer, unsigned int step)
{

    MY_FILE *pFile = aviPointer->VideoData;
    DWORD riffType;
    int tempFrameNum, i, dstDataPos;

    if (beingSkip && (step != AVI_FFD_FFW_RESUME_FLAG))
        return 0;

#if 0
//Get next video index use fseek
    AviFseek(aviPointer->VideoIndex, (0 - sizeof(idx1) - sizeof(idx1)), SEEK_CUR);
    if (AviFread(videoChunkInfo, sizeof(idx1), 1, aviPointer->VideoIndex) < sizeof(idx1))return -1;
    while ((!IS_VIDEO_IDX(videoIChunkInfo->dwChunkid)) ||     //(((videoChunkInfo->dwChunkid & 0xffff0000) != VIDEO_INDEX)||
            ((videoChunkInfo->dwFlags & 0x00000010) != 0x10))
    {
        AviFseek(aviPointer->VideoIndex, (0 - sizeof(idx1) - sizeof(idx1)), SEEK_CUR);
        if (AviFread(videoChunkInfo, sizeof(idx1), 1, aviPointer->VideoIndex) < sizeof(idx1))return -1;
    }
#else // no fseek
    if (aviPointer->KeyFrameNum < 1)
        return -1;
    if (aviPointer->KeyFrameNum > 1)
        aviPointer->KeyFrameNum --;

    if (!lastSkipPoint)
    {
        lastSkipPoint = aviPointer->VideoChunkNum;
    }
    while ((aviPointer->KeyFrameNum > 1) && (((int)lastSkipPoint - (int)keyFrameList[aviPointer->KeyFrameNum].dwVideoFrameNum) < (int)step))
    {
        aviPointer->KeyFrameNum --;
    }

    videoChunkInfo->dwSize = keyFrameList[aviPointer->KeyFrameNum-1].dwSize;
    videoChunkInfo->dwOffset = keyFrameList[aviPointer->KeyFrameNum-1].dwOffset;
    aviPointer->TotalChunkNum = keyFrameList[aviPointer->KeyFrameNum-1].dwNumber;
    aviPointer->VideoChunkNum = keyFrameList[aviPointer->KeyFrameNum-1].dwVideoFrameNum;

//get file pointer of 'idx1' for video
#ifdef ON_RKFS
    AviFastFseek(aviPointer->VideoIndex, idx1Pos.Offset, idx1Pos.Clus);
#else
    if (AviGetChunkPointer(aviPointer->VideoIndex, SIGN_IDX1))
        return -1;
#endif
    AviFseek(aviPointer->VideoIndex, keyFrameList[aviPointer->KeyFrameNum-1].dwNumber*sizeof(idx1), SEEK_CUR);

#endif

    lastSkipPoint = aviPointer->VideoChunkNum;
//initialize current chunk information
    //AviFseek(pFile, videoChunkInfo->dwOffset-aviPointer->Video->CurOffset-aviPointer->Video->ReadSize, SEEK_CUR);
    videoChunkSkipTo.ReadSize = 0;
    videoChunkSkipTo.CurOffset = videoChunkInfo->dwOffset;
    videoChunkSkipTo.CurChunkSize = videoChunkInfo->dwSize;
    beingSkip = AVI_FRAME_SKIP_FFD_FFW;  //skip mode 2  @ LJN
    if (step == AVI_FFD_FFW_RESUME_FLAG)