mjpeg_avi_filereader.c

ADI blackfin DSP的基于device friver的jpeg压缩算法

    MJPEG_AVI_StreamHeader lStrHeader;
    FILE *fp;

    tMJPEG_AVI_STREAMHANDLEREAD *pAVIStreamHandle 
        = (tMJPEG_AVI_STREAMHANDLEREAD *)pAVIStreamHandleParam;
    tMJPEG_AVI_FILEHANDLEREAD AVIFileHandle = (tMJPEG_AVI_FILEHANDLEREAD) AVIFileHandleParam;
    
    if(AVIFileHandle == NULL
        || index != 0
        || (fccTypeParam != MJPEG_AVI_StreamTypeVIDEO 
            && fccTypeParam != MJPEG_AVI_StreamTypeAUDIO))
    {
        return MJPEG_AVI_RETURN_ERROR;
    }

    lStreamId = 0;
    lListstrlOffset = AVIFileHandle->avihChunkOffset + sizeof(MJPEG_AVI_MainAVIHeader)
                        + 8;

    fp = AVIFileHandle->filePtr;

CHECK_NEXT_LIST_STRL :
    if(fseek(fp, lListstrlOffset, SEEK_SET) != 0)
    {
        return MJPEG_AVI_RETURN_FILESEEKFAIL;
    }
    if(fread(&lChunkId, 1, 4, fp) != 4)
    {
        return MJPEG_AVI_RETURN_FILEREADFAIL;
    }
    if(lChunkId != MJPEG_AVI_FOURCC('L','I','S','T'))
    {
        return MJPEG_AVI_RETURN_FILEINCORRECTFORMAT;
    }
    
    if(fread(&lListstrlChunkLength, 1, 4, fp) != 4)
    {
        return MJPEG_AVI_RETURN_FILEREADFAIL;
    }
    
    if(fread(&lChunkId, 1, 4, fp) != 4)
    {
        return MJPEG_AVI_RETURN_FILEREADFAIL;
    }
    if(lChunkId != MJPEG_AVI_FOURCC('s','t','r','l'))
    {
        return MJPEG_AVI_RETURN_FILEINCORRECTFORMAT;
    }

    if(fread(&lChunkId, 1, 4, fp) != 4)
    {
        return MJPEG_AVI_RETURN_FILEREADFAIL;
    }
    if(lChunkId != MJPEG_AVI_FOURCC('s','t','r','h'))
    {
        return MJPEG_AVI_RETURN_FILEINCORRECTFORMAT;
    }
    
    if(fread(&lstrhChunkLength,1,4,fp) != 4)
    {
        return MJPEG_AVI_RETURN_FILEREADFAIL;
    }
    
    if(fread(&lStrHeader,1,sizeof(MJPEG_AVI_StreamHeader),fp) 
        != sizeof(MJPEG_AVI_StreamHeader))
    {
        return MJPEG_AVI_RETURN_FILEREADFAIL;
    }

    if(lStrHeader.fccType != fccTypeParam)
    {
        lStreamId++;
        if(lStreamId == AVIFileHandle->avih.dwStreams)
        {
            return MJPEG_AVI_RETURN_ERROR;
        }
        lListstrlOffset += (lListstrlChunkLength+8);
        goto CHECK_NEXT_LIST_STRL;
    }

    (*pAVIStreamHandle) = (tMJPEG_AVI_STREAMHANDLEREAD) malloc(sizeof(tMJPEG_AVI_Stream_Read));
    if((*pAVIStreamHandle) == NULL)
    {
        return MJPEG_AVI_RETURN_OUTOFMEMORY;
    }
    (*pAVIStreamHandle)->AVIFileHandle = AVIFileHandle;
    (*pAVIStreamHandle)->streamId = lStreamId;
    lTemp = lStreamId + 0x3030;

    if(fccTypeParam == MJPEG_AVI_StreamTypeVIDEO)
    {
        (*pAVIStreamHandle)->streamChunkId = (lTemp << 16) + 0x6462; 
    }
    else 
    {
        /* Means this is of type MJPEG_AVI_StreamTypeAUDIO */
        (*pAVIStreamHandle)->streamChunkId = (lTemp << 16) + 0x7762;
    }
    (*pAVIStreamHandle)->streamChunkId 
        = SWAP_BYTE((*pAVIStreamHandle)->streamChunkId);

    /* Create the tMJPEG_AVI_STREAMINFO structure. */
    (*pAVIStreamHandle)->AVIStreamInfo.dwFlags = lStrHeader.dwFlags;
    (*pAVIStreamHandle)->AVIStreamInfo.dwInitialFrames 
        = lStrHeader.dwInitialFrames;
    (*pAVIStreamHandle)->AVIStreamInfo.dwLength = lStrHeader.dwLength;
    (*pAVIStreamHandle)->AVIStreamInfo.dwQuality = lStrHeader.dwQuality;
    (*pAVIStreamHandle)->AVIStreamInfo.dwRate = lStrHeader.dwRate;
    (*pAVIStreamHandle)->AVIStreamInfo.dwSampleSize = lStrHeader.dwSampleSize;
    (*pAVIStreamHandle)->AVIStreamInfo.dwScale = lStrHeader.dwScale;
    (*pAVIStreamHandle)->AVIStreamInfo.dwStart = lStrHeader.dwStart;
    (*pAVIStreamHandle)->AVIStreamInfo.dwSuggestedBufferSize 
        = lStrHeader.dwSuggestedBufferSize;
    (*pAVIStreamHandle)->AVIStreamInfo.fccHandler = lStrHeader.fccHandler;
    (*pAVIStreamHandle)->AVIStreamInfo.fccType = lStrHeader.fccType;
    (*pAVIStreamHandle)->AVIStreamInfo.rcFrame = lStrHeader.rcFrame;
    (*pAVIStreamHandle)->AVIStreamInfo.wLanguage = lStrHeader.wLanguage;
    (*pAVIStreamHandle)->AVIStreamInfo.wPriority = lStrHeader.wPriority;
    
    (*pAVIStreamHandle)->AVIStreamInfo.dwCaps = 0;
    (*pAVIStreamHandle)->AVIStreamInfo.dwEditCount = 0;
    (*pAVIStreamHandle)->AVIStreamInfo.dwFormatChangeCount = 0;
    (*pAVIStreamHandle)->AVIStreamInfo.szName[0] = '\0';

    (*pAVIStreamHandle)->indexOffset = AVIFileHandle->indexChunkOffset + 8;
    AVIFileHandle->openStreamCount++;

    return MJPEG_AVI_RETURN_OK;
}

/*
*******************************************************************************
Name         : MJPEG_AVI_CloseStreamRead
Description  : Closes the AVI stream.
Parameter    : 
            AVIStreamHandleParam: Handle of the AVI Stream Handle to be closed.
Return Value : MJPEG_AVI_RETURN_OK if stream closed OK,  
				MJPEG_AVI_RETURN_ERROR otherwise.
*******************************************************************************
*/
section ("MJPEGDEC_P0") // All code
int32 MJPEG_AVI_CloseStreamRead(uint32 AVIStreamHandleParam)
{
    tMJPEG_AVI_STREAMHANDLEREAD AVIStreamHandle 
        = (tMJPEG_AVI_STREAMHANDLEREAD)AVIStreamHandleParam;
    if(AVIStreamHandle == NULL)
    {
        return MJPEG_AVI_RETURN_ERROR;
    }
    AVIStreamHandle->AVIFileHandle->openStreamCount--;
    free(AVIStreamHandle);
    return MJPEG_AVI_RETURN_OK;
}

/*
*******************************************************************************
Name         : MJPEG_AVI_ReadStreamInfo
Description  : Returns the AVI Stream info of the stream.
Parameter    : 
            AVIStreamHandleParam: Handle of the open AVI Stream Handle.
            pStreamInfo         : pointer to receive the stream information.
            size                : size of the structure receiving the 
                                    stream information.
Return Value : returns MJPEG_AVI_RETURN_OK on Success, else the E_FAILURE code.
*******************************************************************************
*/
section ("MJPEGDEC_P0") // All code
int32 MJPEG_AVI_ReadStreamInfo(uint32 AVIStreamHandleParam,
                       tMJPEG_AVI_STREAMINFO *pStreamInfo,
                       int32 size)
{
#ifndef	MJPEGREWIND	
    tMJPEG_AVI_STREAMHANDLEREAD AVIStreamHandle 
        = (tMJPEG_AVI_STREAMHANDLEREAD)AVIStreamHandleParam;
    if(AVIStreamHandle == NULL
        || pStreamInfo == NULL
        || size != sizeof(tMJPEG_AVI_STREAMINFO))
    {
        return MJPEG_AVI_RETURN_ERROR;
    }
    *pStreamInfo = AVIStreamHandle->AVIStreamInfo;
#endif    
    return MJPEG_AVI_RETURN_OK;
}





/*
*******************************************************************************
Name         : MJPEG_AVI_ReadToNextFrame
Description  : 	Reads the AVI stream up to the start of the JPEG image
				Returns the number of bytes in the subsequent JPEG image in pBufLength.
Parameter    : 
            AVIStreamHandleParam: Handle of the open AVI Stream Handle.
            pBufLength          : pointer to the current length of the buffer.
Return Value	: MJPEG_AVI_RETURN_OK if stream opened OK
	`			  MJPEG_AVI_RETURN_OUTOFMEMORY 
							if memory could not be allocated when opening the stream
				  MJPEG_AVI_RETURN_FILEOPENFAIL
				  			if the input stream could not be opened
				  MJPEG_AVI_RETURN_FILEREADFAIL
				  			if the input stream could not be read
				  MJPEG_AVI_RETURN_FILEINCORRECTFORMAT
				  			if the input stream was not in MJPEG AVI format
				  MJPEG_AVI_RETURN_FILESEEKFAIL
				  			if the seek operation on the input stream failed
				  MJPEG_AVI_RETURN_NOMORESAMPLES 
				            if no more frames are available to read
				  MJPEG_AVI_RETURN_EVALUATIONLIMITREACHED
				  			if evaluation limit reached				  						  
				  MJPEG_AVI_RETURN_ERROR otherwise
*******************************************************************************
*/
section ("MJPEGDEC_P0") // All code
int32 MJPEG_AVI_ReadToNextFrame(uint32 AVIStreamHandleParam, uint32 *pBufLength)
{
#ifdef	MJPEGREWIND
#else
    FILE *fp;
    MJPEG_AVI_INDEXENTRY lIndexEntry;
    uint32 lTemp;
#ifdef ISEVALUATION
	/* Limit evaluation version to a given number of decoded frames */
	static unsigned int _Axx = 0;
	if (++_Axx > EVALUATIONMAXFRAMES)
	{
		return MJPEG_AVI_RETURN_EVALUATIONLIMITREACHED; 
	}
#endif

    tMJPEG_AVI_STREAMHANDLEREAD AVIStreamHandle 
        = (tMJPEG_AVI_STREAMHANDLEREAD)AVIStreamHandleParam;
    if(AVIStreamHandle == NULL)
    {
        return MJPEG_AVI_RETURN_STREAMINVALID;
    }

    fp = AVIStreamHandle->AVIFileHandle->filePtr;
    if(fseek(fp, AVIStreamHandle->indexOffset, SEEK_SET) != 0)
    {
        return MJPEG_AVI_RETURN_FILESEEKFAIL;
    }

	/* Revised V3.0.1 - if (offset > calculated offset) ...*/
    if(AVIStreamHandle->indexOffset >
        (AVIStreamHandle->AVIFileHandle->indexChunkOffset
            + AVIStreamHandle->AVIFileHandle->indexChunkLength + 8 
            - sizeof(MJPEG_AVI_INDEXENTRY)))
    {
        return MJPEG_AVI_RETURN_NOMORESAMPLES;
    }

    while(1)
    {
        if(fread(&lIndexEntry, 1, sizeof(MJPEG_AVI_INDEXENTRY), fp) 
            != sizeof(MJPEG_AVI_INDEXENTRY))
        {
            return MJPEG_AVI_RETURN_FILEREADFAIL;
        }

        if((lIndexEntry.ckid & 0xFEFFFFFF) != AVIStreamHandle->streamChunkId)
        {
            if(ftell(fp) 
                >= (int32) (AVIStreamHandle->AVIFileHandle->indexChunkOffset
                        + AVIStreamHandle->AVIFileHandle->indexChunkLength + 8
                        - sizeof(MJPEG_AVI_INDEXENTRY)))
            {
                return MJPEG_AVI_RETURN_NOMORESAMPLES;
            }
            continue;
        }
        
        break;
    }

    AVIStreamHandle->indexOffset = ftell(fp);

    if(fseek(fp, lIndexEntry.dwChunkOffset, SEEK_SET) != 0)
    {
        return MJPEG_AVI_RETURN_FILESEEKFAIL;
    }

    if(fread(&lTemp, 1, 4, fp) != 4)
    {
        return MJPEG_AVI_RETURN_FILEREADFAIL;
    }

    if((lTemp & 0xFEFFFFFF) != AVIStreamHandle->streamChunkId)
    {
        return MJPEG_AVI_RETURN_FILEINCORRECTFORMAT;
    }

    if(fread(&lTemp, 1, 4, fp) != 4)
    {
        return MJPEG_AVI_RETURN_FILEREADFAIL;
    }
    if(lTemp != lIndexEntry.dwChunkLength)
    {
        return MJPEG_AVI_RETURN_FILEINCORRECTFORMAT;
    }

    *pBufLength = lIndexEntry.dwChunkLength;
#endif    
    return MJPEG_AVI_RETURN_OK;
}

/*
******************************************************************************
Name         : MJPEG_AVI_ReadNextFrame
Description  : Reads the next image frame into the supplied buffer.  Assumes that
			   MJPEG_AVI_ReadToNextFrame has been called immediately before.
Parameter    : 
            AVIStreamHandleParam: Handle of the open AVI Stream Handle.
            pBuffer             : buffer pointer to receive the next sample.
            pBufLength          : The length of the buffer.
Return Value : returns MJPEG_AVI_RETURN_OK on Success, else the E_FAILURE code.

Return Value	: MJPEG_AVI_RETURN_OK if stream opened OK
	`			  MJPEG_AVI_RETURN_STREAMINVALID if the stream handle is invalid
				  MJPEG_AVI_RETURN_FILEREADFAIL	if the input stream could not be read
*******************************************************************************
*/
#ifdef	MJPEGREWIND
section ("MJPEGDEC_P0") // All code
int32 MJPEG_AVI_ReadNextFrame(uint32 AVIStreamHandleParam, void* pBuffer,
                                    uint32 * pBufLength)
{
#else
section ("MJPEGDEC_P0") // All code
int32 MJPEG_AVI_ReadNextFrame(uint32 AVIStreamHandleParam, void* pBuffer,
                                    uint32 pBufLength)
{
#endif	
    FILE *fp;
    MJPEG_AVI_INDEXENTRY lIndexEntry;

    uint32 lTemp;

    /* Valid stream? */
    tMJPEG_AVI_STREAMHANDLEREAD AVIStreamHandle 
        = (tMJPEG_AVI_STREAMHANDLEREAD)AVIStreamHandleParam;
    if(AVIStreamHandle == NULL)
    {
        return MJPEG_AVI_RETURN_STREAMINVALID;
    }
    fp = AVIStreamHandle->AVIFileHandle->filePtr;
    
	/* Enough samples? 
    if(AVIStreamHandle->indexOffset >=
        (AVIStreamHandle->AVIFileHandle->indexChunkOffset
            + AVIStreamHandle->AVIFileHandle->indexChunkLength + 8 
            - sizeof(MJPEG_AVI_INDEXENTRY)))
    {
        return MJPEG_AVI_RETURN_NOMORESAMPLES;
    }
*/
    /* Read the frame */
#ifdef	MJPEGREWIND
	char * Bufptr = (char *)pBuffer;
	*pBufLength = lTemp = frameheader[1];           	    
    if(FrameCount >= (AVIStreamHandle->AVIFileHandle->indexChunkLength / sizeof(MJPEG_AVI_INDEXENTRY)))
    return MJPEG_AVI_RETURN_NOMORESAMPLES;     		
	if((AVIStreamHandle->AVIFileHandle->indexChunkLength/sizeof(MJPEG_AVI_INDEXENTRY)) < MAXINDEXBUFFERSIZE) {
	if (fseek(fp, FrameIndex[FrameCount].dwChunkOffset, SEEK_SET) != 0) return MJPEG_AVI_RETURN_FILESEEKFAIL; }    	
    if ((frameheader[0] & 0xFEFFFFFF) != AVIStreamHandle->streamChunkId) return MJPEG_AVI_RETURN_FILEINCORRECTFORMAT;            
    FrameCount++;
    if (fread(pBuffer, 1, lTemp + 8, fp) != (lTemp + 8)) return MJPEG_AVI_RETURN_FILEREADFAIL;   
    memcpy(frameheader, &Bufptr[lTemp], 8);     
#else    
    if(fread(pBuffer, 1, pBufLength, fp) 
        != pBufLength)
    {
        return MJPEG_AVI_RETURN_FILEREADFAIL;
    }
#endif    
    return MJPEG_AVI_RETURN_OK;
}
#ifdef	MJPEGREWIND
/*
*******************************************************************************
Name         : MJPEG_AVI_RewindToFirstFrame
Description  : 	Rewind file pointer to the start of the first frame of the AVI stream,
				Returns the number of bytes in the subsequent JPEG image in pBufLength.
Parameter    : 
            AVIStreamHandleParam: Handle of the open AVI Stream Handle.
            pBufLength          : pointer to the maximum length of the frame buffer.
Return Value	: MJPEG_AVI_RETURN_OK 
							if stream opened OK			  				  
				  MJPEG_AVI_RETURN_FILEREADFAIL
				  			if the input stream could not be read				  
				  MJPEG_AVI_RETURN_FILESEEKFAIL
				  			if the seek operation on the input stream failed
				  MJPEG_AVI_RETURN_NOMORESAMPLES 
				            if no more frames are available to read				  					  
				  MJPEG_AVI_RETURN_STREAMINVALID 
				  			if stream handle is invalid
*******************************************************************************
*/
section ("MJPEGDEC_P0") 
int32 MJPEG_AVI_RewindToFirstFrame(uint32 AVIStreamHandleParam, uint32 *pBufLength) {         
    tMJPEG_AVI_STREAMHANDLEREAD AVIStreamHandle = (tMJPEG_AVI_STREAMHANDLEREAD)AVIStreamHandleParam;
    if(AVIStreamHandle == NULL) return MJPEG_AVI_RETURN_STREAMINVALID; 
    FILE *fp = AVIStreamHandle->AVIFileHandle->filePtr;
	FrameCount=0;
    if (fseek(fp, FrameIndex[0].dwChunkOffset, SEEK_SET) != 0) 
    return MJPEG_AVI_RETURN_FILESEEKFAIL;  
    *pBufLength = FrameIndex[0].dwChunkLength;    
    if (fread(frameheader, 1, 8, fp) != 8)	 return MJPEG_AVI_RETURN_FILEREADFAIL;   
    return MJPEG_AVI_RETURN_OK;
}

#endif