mx27_codec.h

Freescale ARM9系列CPU MX27的WINCE 5.0下的BSP

// Copyright (c) 2006, Chips & Media.  All rights reserved.
//-----------------------------------------------------------------------------
// Copyright (C) 2006-2007, Freescale Semiconductor, Inc. All Rights Reserved.
// THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
// AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT 
//-----------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
//  File:		  mx27_codec.h
//  Purpose:	Defines the structure and protoytpe of API for Video Codec module
//
//------------------------------------------------------------------------------

#ifndef __MX27_CODEC_H__
#define __MX27_CODEC_H__

#if __cplusplus
extern "C" {
#endif

#include <windows.h>
//------------------------------------------------------------------------------
// MACRO DEFINITIONS 
//------------------------------------------------------------------------------
#define BONO
#define MAX_NUM_INSTANCE 4

// The Software Event Name used by User
#define VPU_INT_PIC_RUN_NAME                   L"Vpu PIC Run Command"
#define VPU_INT_BSBUF_EMPTY_NAME               L"Vpu Bitstream Empty"
//------------------------------------------------------------------------------
// Define Type Enumerations and Structure
//------------------------------------------------------------------------------
typedef unsigned char	Uint8;
typedef unsigned long	Uint32;
typedef unsigned short	Uint16;

typedef Uint32 PhysicalAddress;
typedef PhysicalAddress *PPhysicalAddress;

//------------------------------------------------------------------------------
// common struct and definition
//------------------------------------------------------------------------------

typedef enum {
	STD_MPEG4 = 0 ,
	STD_H263,
	STD_AVC
#if defined(SHIVA) || defined(ZAPPA)
	,
	STD_VC1
#endif
#ifdef ZAPPA
	,
	STD_MPEG2,
	STD_MJPEG,
	STD_DIV3
#endif
} CodStd;

typedef enum {
	RETCODE_SUCCESS,
	RETCODE_FAILURE,
	RETCODE_INVALID_HANDLE,
	RETCODE_INVALID_PARAM,
	RETCODE_INVALID_COMMAND,
#ifndef	SHIVA
	RETCODE_ROTATOR_OUTPUT_NOT_SET,
	RETCODE_ROTATOR_STRIDE_NOT_SET,
#endif
	RETCODE_FRAME_NOT_COMPLETE,
	RETCODE_INVALID_FRAME_BUFFER,
	RETCODE_INSUFFICIENT_FRAME_BUFFERS,
	RETCODE_INVALID_STRIDE,
	RETCODE_WRONG_CALL_SEQUENCE,
	RETCODE_CALLED_BEFORE,
	RETCODE_NOT_INITIALIZED,
	RETCODE_DEBLOCKING_OUTPUT_NOT_SET
} RetCode;

typedef enum {
#ifndef SHIVA
	ENABLE_ROTATION,
	DISABLE_ROTATION,
	ENABLE_MIRRORING,
	DISABLE_MIRRORING,
	SET_MIRROR_DIRECTION,
	SET_ROTATION_ANGLE,
	SET_ROTATOR_OUTPUT,
	SET_ROTATOR_STRIDE,
#endif
	GET_SPS_RBSP,	// to be changed
	GET_PPS_RBSP,
	SET_SPS_RBSP,
	SET_PPS_RBSP,
	ENCODE_MP4_HEADER,
	ENCODE_AVC_HEADER
#if defined(SHIVA) || defined(BONO) || defined(ZAPPA)
	,
	SET_ENC_SEARCHRAM_PARAM
#endif
#if defined(PRISM) || defined(SHIVA) || defined(ZAPPA)
	,
	SET_DEBLOCKING_OUTPUT
#endif
} CodecCommand;

typedef struct {
	PhysicalAddress bufY;
	PhysicalAddress bufCb;
	PhysicalAddress bufCr;
#ifdef ZAPPA
	PhysicalAddress bufMvCol;
#endif 
} FrameBuffer;

#ifndef SHIVA
typedef enum {
	MIRDIR_NONE,
	MIRDIR_VER,
	MIRDIR_HOR,
	MIRDIR_HOR_VER
} MirrorDirection;
#endif
		
struct CodecInst;

//------------------------------------------------------------------------------
// decode struct and definition
//------------------------------------------------------------------------------

typedef struct CodecInst DecInst;
typedef DecInst * DecHandle;

typedef struct {
	CodStd bitstreamFormat;
	PhysicalAddress bitstreamBuffer;
	Uint8 *virt_bitstreamBuffer;
	int bitstreamBufferSize;
#if defined(PRISM) || defined(SHIVA) || defined( ZAPPA )
	int mp4DeblkEnable;
#elif defined(BONO)
	int qpReport;
#endif
	int reorderEnable;			
#if defined(SHIVA)
	int chromaInterleave;
#endif		
#if defined(ZAPPA) || defined(BONO) || defined(SHIVA)
	int  filePlayEnable;
	int  picWidth;
	int  picHeight;
#endif
} DecOpenParam;

typedef struct {
	int picWidth;			// {(PicX+15)/16} * 16
	int picHeight;			// {(PicY+15)/16} * 16
	Uint32 frameRateInfo;
	
	int mp4_dataPartitionEnable;
	int mp4_reversibleVlcEnable;
	int mp4_shortVideoHeader;
	int h263_annexJEnable;
	int minFrameBufferCount;
	int frameBufDelay;				
} DecInitialInfo;

typedef struct {
#if defined(BONO) || defined(ZAPPA) || defined(SHIVA)
	int prescanEnable;
	int prescanMode;
#endif
	int dispReorderBuf;
#if defined(BONO) || defined(SHIVA) || defined( ZAPPA )
	int iframeSearchEnable;
#endif
#if defined(BONO)
	int skipframeMode;
	int skipframeNum;
#endif
#if defined(SHIVA)
	int vpuCountEnable;
#endif
#if defined(ZAPPA) || defined(BONO) || defined(SHIVA)
	int chunkSize;
#endif
} DecParam;

typedef struct {
	int indexDecoded;
	int picType;
	int numOfErrMBs;
	Uint8 *qpInfo;
#ifdef SHIVA
	int DecVpuCount;
#endif
#if defined(SHIVA) || defined(ZAPPA)
	int hScaleFlag;			//(VC1 only)
	int vScaleFlag;			//(VC1 only)
#endif
#if defined(BONO) || defined(ZAPPA) || defined(SHIVA)
	int prescanresult;
#endif
} DecOutputInfo;

typedef struct {
	Uint8 * paraSet;
	int size;
} DecParamSet;

//------------------------------------------------------------------------------
// encode struct and definition
//------------------------------------------------------------------------------

typedef struct CodecInst EncInst;
typedef EncInst * EncHandle;

typedef struct {
	int mp4_dataPartitionEnable;
	int mp4_reversibleVlcEnable;
	int mp4_intraDcVlcThr;
} EncMp4Param;

typedef struct {
	int h263_annexJEnable;
	int h263_annexKEnable;
	int h263_annexTEnable;
} EncH263Param;

typedef struct {
	int avc_constrainedIntraPredFlag;
	int avc_disableDeblk;
	int avc_deblkFilterOffsetAlpha;
	int avc_deblkFilterOffsetBeta;
	int avc_chromaQpOffset;
	int avc_audEnable;
	int avc_fmoEnable;
	int avc_fmoSliceNum;
	int avc_fmoType;	
} EncAvcParam;

typedef struct {
	CodStd bitstreamFormat;
	PhysicalAddress bitstreamBuffer;
	Uint32 bitstreamBufferSize;
	Uint8 *virt_bitstreamBuffer;
	int streamBufResetEnable;
	
	int picWidth;
	int picHeight;
	Uint32 frameRateInfo;
	int bitRate;
	int initialDelay;
	int vbvBufferSize;
	int enableAutoSkip;
	int gopSize;
	int sliceMode;
	int sliceSizeMode;
	int sliceSize;
	int intraRefresh;
	
	int sliceReport;
	int mbReport;
#if defined(BONO) || defined(ZAPP ) || defined(SHIVA)
	int mbQpReport;
#endif
#if defined(SHIVA)
	int chromaInterleave;
#endif
	union {
		EncMp4Param mp4Param;
		EncH263Param h263Param;
		EncAvcParam avcParam;
	} EncStdParam;
} EncOpenParam;

typedef struct {
	int minFrameBufferCount;
} EncInitialInfo;

typedef struct {
	FrameBuffer * sourceFrame;
	int forceIPicture;
	int skipPicture;
	int quantParam;
#ifdef SHIVA
	int vpuCountEnable;
#endif
} EncParam;

typedef struct {
	int picType;
	PhysicalAddress bitstreamBuffer;
	Uint32 bitstreamSize;
	int numOfSlices;
	Uint8 *sliceInfo;
	Uint8 *mbInfo;
#ifdef SHIVA
	int EncVpuCount;
#endif
#if defined(BONO) || defined(ZAPPA) || defined(SHIVA)
	Uint8 *mbQpInfo;
#endif
} EncOutputInfo;


typedef struct {
	Uint8 *paraSet;
	int size;
} EncParamSet;

#if defined(SHIVA) || defined(BONO) || defined(ZAPPA)
typedef struct {
	PhysicalAddress searchRamAddr;
#if defined(SHIVA) || defined(ZAPPA)
	int SearchRamSize;
#endif
} SearchRamParam;
#endif

typedef struct {
	Uint8 *buf;
	int size;
	int headerType;
} EncHeaderParam;

typedef enum {
	VOL_HEADER,
	VOS_HEADER,
	VIS_HEADER
} Mp4HeaderType;

typedef enum {
	SPS_RBSP,
	PPS_RBSP
} AvcHeaderType;	


//------------------------------------------------------------------------------
// MX27 CODEC API interfaces
//------------------------------------------------------------------------------
void* vpu_AllocPhysMem(Uint32 cbSize, PPhysicalAddress pPhysicalAddress);
BOOL vpu_FreePhysMem(void* pvAddress);
BOOL vpu_ReleaseCodecMutex(void);

RetCode vpu_Init();
void vpu_Deinit(void);
int vpu_IsBusy(void);
RetCode vpu_GetVersionInfo( Uint32 *versionInfo );

// function for encode
RetCode vpu_EncOpen(EncHandle *pHandle, EncOpenParam *pop);
RetCode vpu_EncClose(EncHandle handle);
RetCode vpu_EncGetInitialInfo(EncHandle handle, EncInitialInfo * info);
RetCode vpu_EncRegisterFrameBuffer(EncHandle handle,
		           FrameBuffer * bufArray, int num, int stride);
RetCode vpu_EncGetBitstreamBuffer(EncHandle handle, PhysicalAddress * prdPrt,
		                 PhysicalAddress * pwrPtr, Uint32 * size);
RetCode vpu_EncUpdateBitstreamBuffer(EncHandle handle, Uint32 size);
RetCode vpu_EncStartOneFrame(EncHandle handle, EncParam * param );
RetCode vpu_EncGetOutputInfo(EncHandle handle, EncOutputInfo * info);
RetCode vpu_EncGiveCommand(EncHandle handle, CodecCommand cmd, void * parameter);

// function for decode
RetCode vpu_DecOpen(DecHandle * pHandle, DecOpenParam * pop);
RetCode vpu_DecClose(DecHandle handle);
#if defined(BONO) || defined(ZAPPA) || defined(SHIVA)
RetCode vpu_DecSetEscSeqInit(DecHandle handle, int escape );
#endif
RetCode vpu_DecGetInitialInfo(DecHandle handle, DecInitialInfo * info);
RetCode vpu_DecRegisterFrameBuffer(DecHandle handle,
                   FrameBuffer * bufArray, int num, int stride);
RetCode vpu_DecGetBitstreamBuffer(DecHandle handle,	PhysicalAddress * prdPrt,
		           PhysicalAddress * pwrPtr, Uint32 * size );
RetCode vpu_DecUpdateBitstreamBuffer(DecHandle handle, Uint32 size);
RetCode vpu_DecStartOneFrame(DecHandle handle, DecParam *param ); 
RetCode vpu_DecGetOutputInfo(DecHandle handle, DecOutputInfo * info);
#if defined(BONO)
	RetCode vpu_DecBitBufferFlush(DecHandle handle);
#endif
RetCode vpu_DecGiveCommand(DecHandle handle, CodecCommand cmd, void * parameter);	
	
#ifdef __cplusplus
}
#endif

#endif // __MX27_CODEC_H__