xvid.h

基于Linux的ffmepg decoder

/* @} */

/* @} */

/*
 * \defgroup encoder_grp Encoder related functions and structures.
 *
 * @{
 */

/*****************************************************************************
 * Encoder constants
 ****************************************************************************/

/*
 * \defgroup encgenflags_grp  Flags for Faraday_ENC_FRAME.general
 * @{
 */

#define Faraday_VALID_FLAGS		0x80000000 /*< Reserved for future use */

#define Faraday_CUSTOM_QMATRIX		0x00000004 /*< Use custom quantization matrices
											*
 * This flag forces Faraday to use custom matrices passed to encoder in
 * Faraday_ENC_FRAME structure (members quant_intra_matrix and quant_inter_matrix) */
#define Faraday_H263QUANT			0x00000010 /*< Use H263 quantization
											*
 * This flag forces Faraday to use H263  quantization type */
#define Faraday_MPEGQUANT			0x00000020 /*< Use MPEG4 quantization.
											*
 * This flag forces Faraday to use MPEG4 quantization type */
#define Faraday_HALFPEL			0x00000040 /*< Halfpel motion estimation
											*
* informs Faraday to perform a half pixel  motion estimation. */
#define Faraday_ADAPTIVEQUANT		0x00000080/*< Adaptive quantization
											*
* informs Faraday to perform an adaptative quantization using a Luminance
* masking algorithm */
#define Faraday_LUMIMASKING		0x00000100/*< Lumimasking flag
											*
											* \deprecated This flag is no longer used. */
#define Faraday_LATEINTRA			0x00000200/*< Unknown
											*
											* \deprecated This flag is no longer used. */
#define Faraday_INTERLACING		0x00000400/*< MPEG4 interlacing mode.
											*
											* Enables interlacing encoding mode */
#define Faraday_TOPFIELDFIRST		0x00000800/*< Unknown
                                            *
											* \deprecated This flag is no longer used. */
#define Faraday_ALTERNATESCAN		0x00001000/*<
											*
											* \deprecated This flag is no longer used. */
#define Faraday_HINTEDME_GET		0x00002000/*< Gets Motion vector data from ME system.
											*
* informs  Faraday to  return  Motion Estimation vectors from the ME encoder
* algorithm. Used during a first pass. */
#define Faraday_HINTEDME_SET		0x00004000/*< Gives Motion vectors hint to ME system.
											*
* informs Faraday to  use the user  given motion estimation vectors as hints
* for the encoder ME algorithms. Used during a 2nd pass. */
#define Faraday_INTER4V			0x00008000/*< Inter4V mode.
											*
* forces Faraday to search a vector for each 8x8 block within the 16x16  Macro
* Block. This mode should  be used only if the Faraday_HALFPEL mode is  activated
* (this  could change  in the future). */
#define Faraday_ME_ZERO			0x00010000/*< Unused
											*
* Do not use this flag (reserved for future use) */
#define Faraday_ME_LOGARITHMIC		0x00020000/*< Unused
											*
* Do not use this flag (reserved for future use) */
#define Faraday_ME_FULLSEARCH		0x00040000/*< Unused
											*
* Do not use this flag (reserved for future use) */
#define Faraday_ME_PMVFAST			0x00080000/*< Use PMVfast ME algorithm.
											*
* Switches Faraday ME algorithm to PMVfast */
#define Faraday_ME_EPZS			0x00100000/*< Use EPZS ME algorithm.
											*
* Switches Faraday ME algorithm to EPZS */
#define Faraday_GREYSCALE			0x01000000/*< Discard chroma data.
											*
* This flags forces Faraday to discard chroma data, this is not mpeg4 greyscale
* mode, it simply drops chroma MBs using cbp == 0 for these blocks */
#define Faraday_GRAYSCALE			Faraday_GREYSCALE /*< Faraday_GREYSCALE alias 
											*
* United States locale support. */

/* @} */

/*
 * \defgroup encmotionflags_grp  Flags for Faraday_ENC_FRAME.motion
 * @{
 */

#define PMV_ADVANCEDDIAMOND8	0x00004000/*< Uses advanced diamonds for 8x8 blocks
											*
* Same as its 16x16 companion option
*/
#define PMV_ADVANCEDDIAMOND16   0x00008000/*< Uses advanced diamonds for 16x16 blocks
											*
* */
#define PMV_HALFPELDIAMOND16 	0x00010000/*< Turns on halfpel precision for 16x16 blocks
											*
* switches the search algorithm from 1 or 2 full pixels precision to 1 or 2 half pixel precision.
*/
#define PMV_HALFPELREFINE16 	0x00020000/*< Turns on halfpel refinement step
											*
* After normal diamond search, an extra halfpel refinement step is  performed. Should always be used if
* Faraday_HALFPEL is on, because it gives a rather big increase in quality.
*/
#define PMV_EXTSEARCH16 		0x00040000/*< Extends search for 16x16 blocks
											*
* Normal PMVfast predicts one  start vector and  does diamond search around this position. EXTSEARCH means that 2
* more  start vectors  are used:  (0,0) and  median  predictor and diamond search  is done for  those, too.  Makes
* search slightly slower, but quality sometimes gets better.
*/
#define PMV_EARLYSTOP16	   		0x00080000/*< Dynamic ME thresholding
											*
* PMVfast and EPZS stop search  if current best is  below some dynamic  threshhold. No  diamond search  is done,
* only halfpel  refinement (if active).  Without EARLYSTOP diamond search is always done. That would be much slower,
* but not really lead to better quality.
*/
#define PMV_QUICKSTOP16	   		0x00100000/*< Dynamic ME thresholding
											*
* like  EARLYSTOP, but not even halfpel refinement is  done. Normally worse quality, so it defaults to
* off. Might be removed, too.
*/
#define PMV_UNRESTRICTED16   	0x00200000/*< Not implemented
											*
* "unrestricted  ME"   is  a   feature  of MPEG4. It's not  implemented, so this flag is  ignored (not even
* checked).
*/
#define PMV_OVERLAPPING16   	0x00400000/*< Not implemented
											*
* Same as above
*/
#define PMV_USESQUARES16		0x00800000/*< Use square pattern
											*
* Replace  the  diamond search  with a  square search. 
*/
#define PMV_HALFPELDIAMOND8 	0x01000000/*< see 16x16 equivalent
											*
* Same as its 16x16 companion option */
#define PMV_HALFPELREFINE8 		0x02000000/*< see 16x16 equivalent
											*
* Same as its 16x16 companion option */
#define PMV_EXTSEARCH8 			0x04000000/*< see 16x16 equivalent
											*
* Same as its 16x16 companion option */
#define PMV_EARLYSTOP8	   		0x08000000/*< see 16x16 equivalent
											*
* Same as its 16x16 companion option */
#define PMV_QUICKSTOP8	   		0x10000000/*< see 16x16 equivalent
											*
* Same as its 16x16 companion option */
#define PMV_UNRESTRICTED8   	0x20000000/*< see 16x16 equivalent
											*
* Same as its 16x16 companion option */
#define PMV_OVERLAPPING8   		0x40000000/*< see 16x16 equivalent
											*
* Same as its 16x16 companion option */
#define PMV_USESQUARES8			0x80000000/*< see 16x16 equivalent
											*
* Same as its 16x16 companion option */

/* @} */

/*****************************************************************************
 * Encoder structures
 ****************************************************************************/

	/* Structure used for encoder instance creation */
	//typedef struct
	//{
		//int h263;		

		//int enable_4mv;
		//int resyn;
		
		//int width;                    /*< [in]
		//							     *
		//							     * Input frame width. */
		//int height;                   /*< [in]
		//							   *
		//							   * Input frame height. */
		//int fincr;                    /*< [in]
		//							   *
		//							   * Time increment (fps = increment/base). */
		//int fbase;                    /*< [in]
		//							   *
		//							   * Time base (fps = increment/base). */
		//int rc_bitrate;               /*< [in]
		//							   *
		//							   * Sets the target bitrate of the encoded stream, in bits/second. **/
		//int rc_reaction_delay_factor; /*< [in]
		//							   *
		//							   * Tunes how fast the rate control reacts - lower values are faster. */
		//int rc_averaging_period;      /*< [in]
		//							   *
		//							   * Tunes how fast the rate control reacts - lower values are faster. */
		//int rc_buffer;	              /*< [in]
		//							   *
		//							   * Tunes how fast the rate control reacts - lower values are faster. */
		//int max_quantizer;            /*< [in]
		//							   *
		//							   * Sets the upper limit of the quantizer. */
		//int min_quantizer;            /*< [in]
		//							   *
		//							   * Sets the lower limit of the quantizer. */
		//int max_key_interval;         /*< [in]
		//							   *
		//							   * Sets the maximum interval between key frames. */
		//void *handle;                 /*< [out]
		//							   *
		//							   * Faraday core lib will set this with the creater encoder instance. */
	//}
	//Faraday_ENC_PARAM;

	typedef struct
	{
		int x;
		int y;
	}
	VECTOR;

	typedef struct
	{
		int mode;				/* macroblock mode */
		VECTOR mvs[4];
	}
	MVBLOCKHINT;

	typedef struct
	{
		int intra;				/* frame intra choice */
		int fcode;				/* frame fcode */
		MVBLOCKHINT *block;		/* caller-allocated array of block hints (mb_width * mb_height) */
	}
	MVFRAMEHINT;

	/* Structure used to pass a frame to the encoder */
	typedef struct
	{
		int general;                       /*< [in]
											*
											* Sets general options flag (See \ref encgenflags_grp) */
		int motion;                        /*< [in]
											*
											* Sets Motion Estimation options */
		void *bitstream;                   /*< [out]
											*
											* Output MPEG4 bitstream buffer pointer */
		int length;                        /*< [out]
											*
											* Output MPEG4 bitstream length (bytes) */
		void *image;                       /*< [in]
											*
											* Input frame */
		int colorspace;                    /*< [in]
											*
											* input frame colorspace */
		unsigned char *quant_intra_matrix; /*< [in]
											*
											* Custom intra quantization matrix */
		unsigned char *quant_inter_matrix; /*< [in]
											*
											* Custom inter quantization matrix */
		int quant;                         /*< [in]
											*
											* Frame quantizer :
											* <ul>
											* <li> 0 (zero) : Then the  rate controler chooses the right quantizer
											*                 for you.  Typically used in ABR encoding, or first pass of a VBR
											*                 encoding session.
											* <li> !=  0  :  Then you  force  the  encoder  to use  this  specific
											*                  quantizer   value.     It   is   clamped    in   the   interval
											*                  [1..31]. Tipically used  during the 2nd pass of  a VBR encoding
											*                  session. 
											* </ul> */
		int intra;                         /*< [in/out]
											*
											* <ul>
											* <li> [in] : tells Faraday if the frame must be encoded as an intra frame
											*     <ul>
											*     <li> 1: forces the encoder  to create a keyframe. Mainly used during
											*              a VBR 2nd pass.
											*     <li> 0:  forces the  encoder not to  create a keyframe.  Minaly used
											*               during a VBR second pass
											*     <li> -1: let   the  encoder   decide  (based   on   contents  and
											*              max_key_interval). Mainly  used in ABR  mode and during  a 1st
											*              VBR pass. 
											*     </ul>
											* <li> [out] : When first set to -1, the encoder returns the effective keyframe state
											*              of the frame. 
											* </ul>
                                            */

	}
	Faraday_ENC_FRAME;



/*****************************************************************************
 * Encoder entry point
 ****************************************************************************/

/*
 * \defgroup  encops_grp Encoder operations
 *
 * These are all the operations Faraday's encoder can perform.
 *
 * @{
 */

#define Faraday_ENC_ENCODE		0 /*< Encodes a frame
				   *
 * This operation constant is used when client application wants to encode a
 * frame. Client application must also fill Faraday_ENC_FRAME appropriately.
 */

#define Faraday_ENC_CREATE		1 /*< Creates a decoder instance
				   *
 * This operation constant is used by a client application in order to create
 * an encoder instance. Encoder instances are independant from each other.
 */

#define Faraday_ENC_DESTROY	2 /*< Destroys a encoder instance
				   *
 * This operation constant is used by the client application to destroy a
 * previously created encoder instance.
 */


/* @} */

/*
 * \defgroup  encentry_grp Encoder entry point
 *
 * @{
 */

/*
 * \brief Encoder entry point.
 *
 * This is the Faraday's encoder entry point. The possible operations are
 * described in the \ref encops_grp section.
 *
 * \param handle Encoder instance handle
 * \param opt Encoder option constant
 * \param param1 Used to pass Faraday_ENC_PARAM or Faraday_ENC_FRAME structures.
 * \param param2 Optionally used to pass the Faraday_ENC_STATS structure.
 */
	int Faraday_encore(void *handle,
					int opt,
					void *param1,
					void *param2);

/* @} */

/* @} */

#ifdef __cplusplus
}
#endif

#endif