xvid.h   xvid.h 
/************************************************************************** *** /************************************************************************** ***
* *
* XVID MPEG-4 VIDEO CODEC * XVID MPEG-4 VIDEO CODEC
* - XviD Main header file - * - XviD Main header file -
* *
* This file is part of XviD, a free MPEG-4 video encoder/decoder * Copyright(C) 2001-2003 Peter Ross <pross@xvid.org>
* *
* XviD is free software; you can redistribute it and/or modify it * This program is free software ; you can redistribute it and/or modify
* under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation ; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program ; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 US A * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 US A
* *
* Under section 8 of the GNU General Public License, the copyright * $Id$
* holders of XVID explicitly forbid distribution in the following
* countries:
*
* - Japan
* - United States of America
*
* Linking XviD statically or dynamically with other modules is making a
* combined work based on XviD. Thus, the terms and conditions of the
* GNU General Public License cover the whole combination.
*
* As a special exception, the copyright holders of XviD give you
* permission to link XviD with independent modules that communicate with
* XviD solely through the VFW1.1 and DShow interfaces, regardless of the
* license terms of these independent modules, and to copy and distribute
* the resulting combined work under terms of your choice, provided that
* every copy of the combined work is accompanied by a complete copy of
* the source code of XviD (the version of XviD used to produce the
* combined work), being distributed under the terms of the GNU General
* Public License plus this exception. An independent module is a module
* which is not derived from or based on XviD.
*
* Note that people who make modified versions of XviD are not obligated
* to grant this special exception for their modified versions; it is
* their choice whether to do so. The GNU General Public License gives
* permission to release a modified version without this exception; this
* exception also makes it possible to release a modified version which
* carries forward this exception.
*
* $Id: xvid.h,v 1.23 2002/11/16 23:38:16 edgomez Exp $
* *
************************************************************************** ***/ ************************************************************************** **/
#ifndef _XVID_H_ #ifndef _XVID_H_
#define _XVID_H_ #define _XVID_H_
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/**
* \defgroup global_grp Global constants used in both encoder and decoder
.
*
* This module describe all constants used in both the encoder and the deco
der.
* @{
*/
/************************************************************************** *** /************************************************************************** ***
* API version number * versioning
************************************************************************** **/ ************************************************************************** **/
/** /* versioning
* \defgroup api_grp API version version takes the form "$major.$minor.$patch"
* @{ $patch is incremented when there is no api change
*/ $minor is incremented when the api is changed, but remains backwards
compatible
$major is incremented when the api is changed significantly
#define API_VERSION ((2 << 16) | (1))/**< This constant tells you what XviD when initialising an xvid structure, you must always zero it, and se
's t the version field.
* version this header defines. memset(&struct,0,sizeof(struct));
* struct.version = XVID_VERSION;
* You can use it to check if the host XviD library API is the same as the
one XVID_UNSTABLE is defined only during development.
* you used to build you client program. If versions mismatch, then it is */
* highly possible that your application will segfault because the host Xvi
D #define XVID_MAKE_VERSION(a,b,c) ((((a)&0xff)<<16) | (((b)&0xff)<<8) | ((c)
* library and your application use different structures. &0xff))
#define XVID_VERSION_MAJOR(a) ((char)(((a)>>16) & 0xff))
#define XVID_VERSION_MINOR(a) ((char)(((a)>> 8) & 0xff))
#define XVID_VERSION_PATCH(a) ((char)(((a)>> 0) & 0xff))
#define XVID_MAKE_API(a,b) ((((a)&0xff)<<16) | (((b)&0xff)<<0))
#define XVID_API_MAJOR(a) (((a)>>16) & 0xff)
#define XVID_API_MINOR(a) (((a)>> 0) & 0xff)
#define XVID_VERSION XVID_MAKE_VERSION(1,0,0)
#define XVID_API XVID_MAKE_API(4, 0)
/* Bitstream Version
* this will be writen into the bitstream to allow easy detection of xvid
* encoder bugs in the decoder, without this it might not possible to
* automatically distinquish between a file which has been encoded with an
* old & buggy XVID from a file which has been encoded with a bugfree versi
on
* see the infamous interlacing bug ...
* *
* this MUST be increased if an encoder bug is fixed, increasing it too oft
en
* doesnt hurt but not increasing it could cause difficulty for decoders in
the
* future
*/ */
#define XVID_BS_VERSION 34
/** @} */ /**************************************************************************
***
* error codes
**************************************************************************
**/
/* all functions return values <0 indicate error */
#define XVID_ERR_FAIL -1 /* general fault */
#define XVID_ERR_MEMORY -2 /* memory allocation
error */
#define XVID_ERR_FORMAT -3 /* file format error
*/
#define XVID_ERR_VERSION -4 /* structure version not sup
ported */
#define XVID_ERR_END -5 /* encoder only; end of stre
am reached */
/************************************************************************** *** /************************************************************************** ***
* Error codes * xvid_image_t
************************************************************************** **/ ************************************************************************** **/
/** /* colorspace values */
* \defgroup error_grp Error codes returned by XviD API entry points.
* @{
*/
#define XVID_ERR_FAIL -1 /**< Operation failed. #define XVID_CSP_PLANAR (1<< 0) /* 4:2:0 planar (==I420, except for point
* ers/strides) */
* The requested XviD operation failed. If this error code is returned from #define XVID_CSP_USER XVID_CSP_PLANAR
: #define XVID_CSP_I420 (1<< 1) /* 4:2:0 planar */
* <ul> #define XVID_CSP_YV12 (1<< 2) /* 4:2:0 planar */
* <li>the xvid_init function : you must not try to use an XviD's instance #define XVID_CSP_YUY2 (1<< 3) /* 4:2:2 packed */
from #define XVID_CSP_UYVY (1<< 4) /* 4:2:2 packed */
* this point of the code. Clean all instances #define XVID_CSP_YVYU (1<< 5) /* 4:2:2 packed */
you #define XVID_CSP_BGRA (1<< 6) /* 32-bit bgra packed */
* already created and exit the program cleanl #define XVID_CSP_ABGR (1<< 7) /* 32-bit abgr packed */
y. #define XVID_CSP_RGBA (1<< 8) /* 32-bit rgba packed */
* <li>xvid_encore or xvid_decore : something was wrong and en/decoding #define XVID_CSP_ARGB (1<<15) /* 32-bit argb packed */
* operation was not completed sucessfully #define XVID_CSP_BGR (1<< 9) /* 24-bit bgr packed */
. #define XVID_CSP_RGB555 (1<<10) /* 16-bit rgb555 packed */
* you can stop the en/decoding process or #define XVID_CSP_RGB565 (1<<11) /* 16-bit rgb565 packed */
just #define XVID_CSP_SLICE (1<<12) /* decoder only: 4:2:0 planar, per slice
* igno rendering */
re and go on. #define XVID_CSP_INTERNAL (1<<13) /* decoder only: 4:2:0 planar, returns pt
* <li>xvid_stop : you can safely ignore it if you call this function at th rs to internal buffers */
e #define XVID_CSP_NULL (1<<14) /* decoder only: dont output anything */
* end of your program. #define XVID_CSP_VFLIP (1<<31) /* vertical flip mask */
* </ul>
*/
#define XVID_ERR_OK 0 /**< Operation succeed. /* xvid_image_t
* for non-planar colorspaces use only plane[0] and stride[0]
* The requested XviD operation succeed, you can continue to use XviD's four plane reserved for alpha*/
* functions. typedef struct {
*/ int csp; /* [in] colorspace; or with
XVID_CSP_VFLIP to perform vertical flip */
void * plane[4]; /* [in] image plane ptrs */
int stride[4]; /* [in] image stride; "bytes per row
"*/
} xvid_image_t;
#define XVID_ERR_MEMORY 1 /**< Operation failed. /* video-object-sequence profiles */
* #define XVID_PROFILE_S_L0 0x08 /* simple */
* Insufficent memory was available on the host system. #define XVID_PROFILE_S_L1 0x01
*/ #define XVID_PROFILE_S_L2 0x02
#define XVID_PROFILE_S_L3 0x03
#define XVID_PROFILE_ARTS_L1 0x91 /* advanced realtime simple */
#define XVID_PROFILE_ARTS_L2 0x92
#define XVID_PROFILE_ARTS_L3 0x93
#define XVID_PROFILE_ARTS_L4 0x94
#define XVID_PROFILE_AS_L0 0xf0 /* advanced simple */
#define XVID_PROFILE_AS_L1 0xf1
#define XVID_PROFILE_AS_L2 0xf2
#define XVID_PROFILE_AS_L3 0xf3
#define XVID_PROFILE_AS_L4 0xf4
#define XVID_ERR_FORMAT 2 /**< Operation failed. /* aspect ratios */
* #define XVID_PAR_11_VGA 1 /* 1:1 vga (square), default if supplied PAR i
* The format of the parameters or input stream were incorrect. s not a valid value */
*/ #define XVID_PAR_43_PAL 2 /* 4:3 pal (12:11 625-line) */
#define XVID_PAR_43_NTSC 3 /* 4:3 ntsc (10:11 525-line) */
#define XVID_PAR_169_PAL 4 /* 16:9 pal (16:11 625-line) */
#define XVID_PAR_169_NTSC 5 /* 16:9 ntsc (40:33 525-line) */
#define XVID_PAR_EXT 15 /* extended par; use par_width, par_height */
/** @} */ /* frame type flags */
#define XVID_TYPE_VOL -1 /* decoder only: vol was decoded */
#define XVID_TYPE_NOTHING 0 /* decoder only (encoder stats): nothing was d
ecoded/encoded */
#define XVID_TYPE_AUTO 0 /* encoder: automatically determine coding typ
e */
#define XVID_TYPE_IVOP 1 /* intra frame */
#define XVID_TYPE_PVOP 2 /* predicted frame */
#define XVID_TYPE_BVOP 3 /* bidirectionally encoded */
#define XVID_TYPE_SVOP 4 /* predicted+sprite frame */
/************************************************************************** *** /************************************************************************** ***
* Color space constants * xvid_global()
************************************************************************** **/ ************************************************************************** **/
/** /* cpu_flags definitions (make sure to sync this with cpuid.asm for ia32) *
* \defgroup csp_grp Colorspaces constants. /
* @{
*/
#define XVID_CSP_RGB24 0 /**< 24-bit RGB colorspace (b,g,r packed) */ #define XVID_CPU_FORCE (1<<31) /* force passed cpu flags */
#define XVID_CSP_YV12 1 /**< YV12 colorspace (y,v,u planar) */ #define XVID_CPU_ASM (1<< 7) /* native assembly */
#define XVID_CSP_YUY2 2 /**< YUY2 colorspace (y,u,y,v packed) */ /* ARCH_IS_IA32 */
#define XVID_CSP_UYVY 3 /**< UYVY colorspace (u,y,v,y packed) */ #define XVID_CPU_MMX (1<< 0) /* mmx : pentiumMMX,k6 */
#define XVID_CSP_I420 4 /**< I420 colorsapce (y,u,v planar) */ #define XVID_CPU_MMXEXT (1<< 1) /* mmx-ext : pentium2, athlon */
#define XVID_CSP_RGB555 10 /**< 16-bit RGB555 colorspace */ #define XVID_CPU_SSE (1<< 2) /* sse : pentium3, athlonXP */
#define XVID_CSP_RGB565 11 /**< 16-bit RGB565 colorspace */ #define XVID_CPU_SSE2 (1<< 3) /* sse2 : pentium4, athlon64 */
#define XVID_CSP_USER 12 /**< user colorspace format, where the image buf #define XVID_CPU_3DNOW (1<< 4) /* 3dnow : k6-2 */
fer points #define XVID_CPU_3DNOWEXT (1<< 5) /* 3dnow-ext : athlon */
* to a DEC_PICTURE (y,u,v planar) structure. #define XVID_CPU_TSC (1<< 6) /* tsc : Pentium */
* /* ARCH_IS_PPC */
* For encoding, im #define XVID_CPU_ALTIVEC (1<< 0) /* altivec */
age is read from the DEC_PICTURE
* parameter values
. For decoding, the DEC_PICTURE
* parameters are set, pointing to the interna
l XviD
* image buffer. */
#define XVID_CSP_EXTERN 1004 /**< Special colorspace used for slice renderi
ng
*
* The application provides an external buffer
to XviD.
* This way, XviD works directly into the fina
l rendering
* buffer, no need to specify this is a speed
boost feature.
* This feature is only used by mplayer at the
moment, refer
* to mplayer code to see how it can be used.
*/
#define XVID_CSP_YVYU 1002 /**< YVYU colorspace (y,v,y,u packed) */
#define XVID_CSP_RGB32 1000 /**< 32-bit RGB colorspace (b,g,r,a packed) */
#define XVID_CSP_NULL 9999 /**< NULL colorspace; no conversion is perform
ed */
#define XVID_CSP_VFLIP 0x80000000 /**< (flag) Flip frame vertically during #define XVID_DEBUG_ERROR (1<< 0)
conversion */ #define XVID_DEBUG_STARTCODE (1<< 1)
#define XVID_DEBUG_HEADER (1<< 2)
#define XVID_DEBUG_TIMECODE (1<< 3)
#define XVID_DEBUG_MB (1<< 4)
#define XVID_DEBUG_COEFF (1<< 5)
#define XVID_DEBUG_MV (1<< 6)
#define XVID_DEBUG_RC (1<< 7)
#define XVID_DEBUG_DEBUG (1<<31)
/** @} */ /* XVID_GBL_INIT param1 */
typedef struct {
int version;
unsigned int cpu_flags; /* [in:opt] zero = autodetect cpu; XVID_CPU_
FORCE|{cpu features} = force cpu features */
int debug; /* [in:opt] debug level */
} xvid_gbl_init_t;
/** @} */ /* XVID_GBL_INFO param1 */
typedef struct {
int version;
int actual_version; /* [out] returns the actual xvidcore version */
const char * build; /* [out] if !null, points to description of this
xvid core build */
unsigned int cpu_flags; /* [out] detected cpu features */
int num_threads; /* [out] detected number of cpus/threads */
} xvid_gbl_info_t;
/** /* XVID_GBL_CONVERT param1 */
* \defgroup init_grp Initialization constants, structures and functions. typedef struct {
* int version;
* This section describes all the constants, structures and functions used xvid_image_t input; /* [in] input image & colorspace */
to xvid_image_t output; /* [in] output image & colorspace */
* initialize the XviD core library int width; /* [in] width */
* int height; /* [in] height */
* @{ int interlacing; /* [in] interlacing */
*/ } xvid_gbl_convert_t;
#define XVID_GBL_INIT 0 /* initialize xvidcore; must be called before us
ing xvid_decore, or xvid_encore) */
#define XVID_GBL_INFO 1 /* return some info about xvidcore, and the host
computer */
#define XVID_GBL_CONVERT 2 /* colorspace conversion utility */
extern int xvid_global(void *handle, int opt, void *param1, void *param2);
/************************************************************************** *** /************************************************************************** ***
* CPU flags * xvid_decore()
************************************************************************** **/ ************************************************************************** **/
/** #define XVID_DEC_CREATE 0 /* create decore instance; return 0 on success *
* \defgroup cpu_grp Flags for XVID_INIT_PARAM.cpu_flags. /
* #define XVID_DEC_DESTROY 1 /* destroy decore instance: return 0 on success
* This section describes all constants that show host cpu available featur */
es, #define XVID_DEC_DECODE 2 /* decode a frame: returns number of bytes consu
* and allow a client application to force usage of some cpu instructions s med >= 0 */
ets.
* @{
*/
/** extern int xvid_decore(void *handle, int opt, void *param1, void *param2);
* \defgroup x86_grp x86 specific cpu flags
* @{
*/
#define XVID_CPU_MMX 0x00000001 /**< use/has MMX instruction set */ /* XVID_DEC_CREATE param 1
#define XVID_CPU_MMXEXT 0x00000002 /**< use/has MMX-ext (pentium3) instru image width & height may be specified here when the dimensions are
ction set */ known in advance. */
#define XVID_CPU_SSE 0x00000004 /**< use/has SSE (pentium3) instructio typedef struct {
n set */ int version;
#define XVID_CPU_SSE2 0x00000008 /**< use/has SSE2 (pentium4) instructi int width; /* [in:opt] image width */
on set */ int height; /* [in:opt] image width */
#define XVID_CPU_3DNOW 0x00000010 /**< use/has 3dNOW (k6-2) instruction void * handle; /* [out] decore context handle */
set */ } xvid_dec_create_t;
#define XVID_CPU_3DNOWEXT 0x00000020 /**< use/has 3dNOW-ext (athlon) instru
ction set */
#define XVID_CPU_TSC 0x00000040 /**< has TimeStampCounter instruction
*/
/** @} */ /* XVID_DEC_DECODE param1 */
/* general flags */
#define XVID_LOWDELAY (1<<0) /* lowdelay mode */
#define XVID_DISCONTINUITY (1<<1) /* indicates break in stream */
#define XVID_DEBLOCKY (1<<2) /* perform luma deblocking */
#define XVID_DEBLOCKUV (1<<3) /* perform chroma deblocking */
#define XVID_FILMEFFECT (1<<4) /* adds film grain */
/** typedef struct {
* \defgroup ia64_grp ia64 specific cpu flags. int version;
* @{ int general; /* [in:opt] general flags */
*/ void *bitstream; /* [in] bitstream (read from)*/
int length; /* [in] bitstream length */
xvid_image_t output; /* [in] output image (written to) */
} xvid_dec_frame_t;
#define XVID_CPU_IA64 0x00000080 /**< Forces ia64 optimized code usage /* XVID_DEC_DECODE param2 :: optional */
* typedef struct
* This flags allow client applications to force IA64 optimized functions. {
* This feature is considered exeperimental and should be treated as is. int version;
*/
/** @} */ int type; /* [out] output data type */
union {
struct { /* type>0 {XVID_TYPE_IVOP,XVID_TYPE_PVOP,XVID_TYPE_
BVOP,XVID_TYPE_SVOP} */
int general; /* [out] flags */
int time_base; /* [out] time base */
int time_increment; /* [out] time increment */
/** /* XXX: external deblocking stuff */
* \defgroup iniflags_grp Initialization commands. int * qscale; /* [out] pointer to quantizer ta
ble */
int qscale_stride; /* [out] quantizer scale stride
*/
} vop;
struct { /* XVID_TYPE_VOL */
int general; /* [out] flags */
int width; /* [out] width */
int height; /* [out] height */
int par; /* [out] pixel aspect ratio (ref
er to XVID_PAR_xxx above) */
int par_width; /* [out] aspect ratio width [1.
.255] */
int par_height; /* [out] aspect ratio height [1.
.255] */
} vol;
} data;
} xvid_dec_stats_t;
#define XVID_ZONE_QUANT (1<<0)
#define XVID_ZONE_WEIGHT (1<<1)
typedef struct
{
int frame;
int mode;
int increment;
int base;
} xvid_enc_zone_t;
/*-------------------------------------------------------------------------
---
* xvid_enc_stats_t structure
* *
* @{ * Used in:
*/ * - xvid_plg_data_t structure
* - optional parameter in xvid_encore() function
*
* .coding_type = XVID_TYPE_NOTHING if the stats are not given
*-------------------------------------------------------------------------
-*/
#define XVID_CPU_CHKONLY 0x40000000 /**< Check cpu features typedef struct {
* int version;
* When this flag is set, the xvid_init function performs just a cpu featur
e
* checking and then fills the cpu field. This flag is usefull when client
* applications want to know what instruction sets the host cpu supports.
*/
#define XVID_CPU_FORCE 0x80000000 /**< Force input flags to be used /* encoding parameters */
* int type; /* [out] coding type */
* When this flag is set, client application forces XviD to use other flags int quant; /* [out] frame quantizer */
* set in cpu_flags. \b Use this at your own risk. int vol_flags; /* [out] vol flags (see above) */
*/ int vop_flags; /* [out] vop flags (see above) */
/** @} */ /* bitrate */
int length; /* [out] frame length */
/** @} */ int hlength; /* [out] header length (bytes) */
int kblks; /* [out] number of blocks compressed as Intra */
int mblks; /* [out] number of blocks compressed as Inter */
int ublks; /* [out] number of blocks marked as not_coded */
int sse_y; /* [out] Y plane's sse */
int sse_u; /* [out] U plane's sse */
int sse_v; /* [out] V plane's sse */
} xvid_enc_stats_t;
/************************************************************************** *** /************************************************************************** ***
* Initialization structures xvid plugin system -- internals
xvidcore will call XVID_PLG_INFO and XVID_PLG_CREATE during XVID_ENC_CREA
TE
before encoding each frame xvidcore will call XVID_PLG_BEFORE
after encoding each frame xvidcore will call XVID_PLG_AFTER
xvidcore will call XVID_PLG_DESTROY during XVID_ENC_DESTROY
************************************************************************** **/ ************************************************************************** **/
/** Structure used in xvid_init function. */ #define XVID_PLG_CREATE (1<<0)
typedef struct #define XVID_PLG_DESTROY (1<<1)
{ #define XVID_PLG_INFO (1<<2)
int cpu_flags; /**< [in/out] #define XVID_PLG_BEFORE (1<<3)
* #define XVID_PLG_FRAME (1<<4)
* Filled with desired[in] or available[out #define XVID_PLG_AFTER (1<<5)
]
* cpu instruction sets.
*/
int api_version; /**< [out]
*
* xvid_init will initialize this field wit
h
* the API_VERSION used in this XviD core
* library
*/
int core_build; /**< [out]
* \todo Unused.
*/
}
XVID_INIT_PARAM;
/************************************************************************** /* xvid_plg_info_t.flags */
*** #define XVID_REQORIGINAL (1<<0) /* plugin requires a copy of the original (
* Initialization entry point uncompressed) image */
************************************************************************** #define XVID_REQPSNR (1<<1) /* plugin requires psnr between the uncompr
**/ essed and compressed image*/
#define XVID_REQDQUANTS (1<<2) /* plugin requires access to the dquant tab
le */
/** typedef struct
* \defgroup inientry_grp Initialization entry point. {
* @{ int version;
*/ int flags; /* [in:opt] plugin flags */
} xvid_plg_info_t;
/** typedef struct
* \brief Initialization entry point. {
* int version;
* This is the XviD's initialization entry point, it is only used to initia
lize
* the XviD internal data (function pointers, vector length code tables,
* rgb2yuv lookup tables).
*
* \param handle Reserved for future use.
* \param opt Reserved for future use (set it to 0).
* \param param1 Used to pass an XVID_INIT_PARAM parameter.
* \param param2 Reserved for future use.
*/
int xvid_init(void *handle,
int opt,
void *param1,
void *param2);
/** @} */ int num_zones; /* [out] */
xvid_enc_zone_t * zones; /* [out] */
/** @} */ int width; /* [out] */
int height; /* [out] */
int mb_width; /* [out] */
int mb_height; /* [out] */
int fincr; /* [out] */
int fbase; /* [out] */
/************************************************************************** void * param; /* [out] */
*** } xvid_plg_create_t;
* Decoder constant
**************************************************************************
**/
/** typedef struct
* \defgroup decoder_grp Decoder related functions and structures. {
* int version;
* This part describes all the structures/functions from XviD's API needed
for
* decoding a MPEG4 compliant streams.
* @{
*/
/** int num_frames; /* [out] total frame encoded */
* \defgroup decframe_grp Flags for XVID_DEC_FRAME.general } xvid_plg_destroy_t;
*
* Flags' description for the XVID_DEC_FRAME.general member.
*
* @{
*/
/** Not used at the moment */ typedef struct
#define XVID_QUICK_DECODE 0x00000010 {
int version;
/** xvid_enc_zone_t * zone; /* [out] current zone */
* @}
*/ int width; /* [out] */
int height; /* [out] */
int mb_width; /* [out] */
int mb_height; /* [out] */
int fincr; /* [out] */
int fbase; /* [out] */
int min_quant[3]; /* [out] */
int max_quant[3]; /* [out] */
xvid_image_t reference; /* [out] -> [out] */
xvid_image_t current; /* [out] -> [in,out] */
xvid_image_t original; /* [out] after: points the original (uncompr
essed) copy of the current frame */
int frame_num; /* [out] frame number */
int type; /* [in,out] */
int quant; /* [in,out] */
int * dquant; /* [in,out] pointer to diff quantizer ta
ble */
int dquant_stride; /* [in,out] diff quantizer stride */
int vop_flags; /* [in,out] */
int vol_flags; /* [in,out] */
int motion_flags; /* [in,out] */
/* Deprecated, use the stats field instead.
* Will disapear before 1.0 */
int length; /* [out] after: length of encoded frame */
int kblks; /* [out] number of blocks compressed as Intr
a */
int mblks; /* [out] number of blocks compressed as Inte
r */
int ublks; /* [out] number of blocks marked not_coded *
/
int sse_y; /* [out] Y plane's sse */
int sse_u; /* [out] U plane's sse */
int sse_v; /* [out] V plane's sse */
/* End of duplicated data, kept only for binary compatibility */
int bquant_ratio; /* [in] */
int bquant_offset; /* [in] */
xvid_enc_stats_t stats; /* [out] frame statistics */
} xvid_plg_data_t;
/************************************************************************** *** /************************************************************************** ***
* Decoder structures xvid plugin system -- external
the application passes xvid an array of "xvid_plugin_t" at XVID_ENC_CREAT
E. the array
indicates the plugin function pointer and plugin-specific data.
xvidcore handles the rest. example:
xvid_enc_create_t create;
xvid_enc_plugin_t plugins[2];
plugins[0].func = xvid_psnr_func;
plugins[0].param = NULL;
plugins[1].func = xvid_cbr_func;
plugins[1].param = &cbr_data;
create.num_plugins = 2;
create.plugins = plugins;
************************************************************************** **/ ************************************************************************** **/
typedef struct typedef int (xvid_plugin_func)(void * handle, int opt, void * param1, void
{ * param2);
int width;
int height;
void *handle;
}
XVID_DEC_PARAM;
typedef struct typedef struct
{ {
int general; xvid_plugin_func * func;
void *bitstream; void * param;
int length; } xvid_enc_plugin_t;
void *image; extern xvid_plugin_func xvid_plugin_single; /* single-pass rate control *
int stride; /
int colorspace; extern xvid_plugin_func xvid_plugin_2pass1; /* two-pass rate control: fir
} st pass */
XVID_DEC_FRAME; extern xvid_plugin_func xvid_plugin_2pass2; /* two-pass rate control: sec
ond pass */
// This struct is used for per slice rendering extern xvid_plugin_func xvid_plugin_lumimasking; /* lumimasking */
typedef struct
{ extern xvid_plugin_func xvid_plugin_psnr; /* write psnr values to stdo
void *y,*u,*v; ut */
int stride_y, stride_u,stride_v; extern xvid_plugin_func xvid_plugin_dump; /* dump before and after yuv
} XVID_DEC_PICTURE; pgms */
/* single pass rate control
* CBR and Constant quantizer modes */
typedef struct
{
int version;
int bitrate; /* [in] bits per second */
int reaction_delay_factor; /* [in] */
int averaging_period; /* [in] */
int buffer; /* [in] */
} xvid_plugin_single_t;
typedef struct {
int version;
char * filename;
} xvid_plugin_2pass1_t;
#define XVID_PAYBACK_BIAS 0 /* payback with bias */
#define XVID_PAYBACK_PROP 1 /* payback proportionally */
typedef struct {
int version;
int bitrate; /* [in] bits per second */
char * filename; /* [in] first pass stats filename */
int keyframe_boost; /* [in] keyframe boost percentage: [0.
.100] */
int curve_compression_high; /* [in] percentage of compression perf
ormed on the high part of the curve (above average) */
int curve_compression_low; /* [in] percentage of compression perf
ormed on the low part of the curve (below average) */
int overflow_control_strength;/* [in] Payback delay expressed in num
ber of frames */
int max_overflow_improvement; /* [in] percentage of allowed range fo
r a frame that gets bigger because of overflow bonus */
int max_overflow_degradation; /* [in] percentage of allowed range fo
r a frame that gets smaller because of overflow penalty */
int kfreduction; /* [in] maximum bitrate reduction appl
ied to an iframe under the kfthreshold distance limit */
int kfthreshold; /* [in] if an iframe is closer to the
next iframe than this distance, a quantity of bits
* is
substracted from its bit allocation. The reduction is computed as multiple
s of
* kf
reduction/kthreshold. It reaches kfreduction when the distance == kfthresho
ld,
* 0
for 1<distance<kfthreshold */
int container_frame_overhead; /* [in] How many bytes the controller
has to compensate per frame due to container format overhead */
}xvid_plugin_2pass2_t;
/************************************************************************** *** /************************************************************************** ***
* Decoder entry point * ENCODER API
************************************************************************** **/ ************************************************************************** **/
/** /*-------------------------------------------------------------------------
* \defgroup decops_grp Decoder operations ---
* * Encoder operations
* These are all the operations XviD's decoder can perform. *-------------------------------------------------------------------------
* -*/
* @{
*/
#define XVID_DEC_DECODE 0 /**< Decodes a frame #define XVID_ENC_CREATE 0 /* create encoder instance; returns 0 on success
* */
* This operation constant is used when client application wants to decode #define XVID_ENC_DESTROY 1 /* destroy encoder instance; returns 0 on succes
a s */
* frame. Client application must also fill XVID_DEC_FRAME appropriately. #define XVID_ENC_ENCODE 2 /* encode a frame: returns number of ouput bytes
*/ * 0 means this frame should not be written (ie.
encoder lag) */
#define XVID_DEC_CREATE 1 /**< Creates a decoder instance /*-------------------------------------------------------------------------
* ---
* This operation constant is used by a client application in order to crea * Encoder entry point
te *-------------------------------------------------------------------------
* a decoder instance. Decoder instances are independant from each other, a -*/
nd
* can be safely threaded.
*/
#define XVID_DEC_DESTROY 2 /**< Destroys a decoder instance extern int xvid_encore(void *handle, int opt, void *param1, void *param2);
*
* This operation constant is used by the client application to destroy a
* previously created decoder instance.
*/
/** /* Quick API reference
* @} *
* XVID_ENC_CREATE operation
* - handle: ignored
* - opt: XVID_ENC_CREATE
* - param1: address of a xvid_enc_create_t structure
* - param2: ignored
*
* XVID_ENC_ENCODE operation
* - handle: an instance returned by a CREATE op
* - opt: XVID_ENC_ENCODE
* - param1: address of a xvid_enc_frame_t structure
* - param2: address of a xvid_enc_stats_t structure (optional)
* its return value is asynchronous to what is written to the bu
ffer
* depending on the delay introduced by bvop use. It's display
* ordered.
*
* XVID_ENC_DESTROY operation
* - handle: an instance returned by a CREATE op
* - opt: XVID_ENC_DESTROY
* - param1: ignored
* - param2: ignored
*/ */
/** /*-------------------------------------------------------------------------
* \defgroup decentry_grp Decoder entry point ---
* "Global" flags
* *
* @{ * These flags are used for xvid_enc_create_t->global field during instance
*/ * creation (operation XVID_ENC_CREATE)
*-------------------------------------------------------------------------
-*/
/** #define XVID_GLOBAL_PACKED (1<<0) /* packed bitstream */
* \brief Decoder entry point. #define XVID_GLOBAL_CLOSED_GOP (1<<1) /* closed_gop: was DX50BVOP
dx50 bvop compatibility */
#define XVID_GLOBAL_EXTRASTATS_ENABLE (1<<2)
#if 0
#define XVID_GLOBAL_VOL_AT_IVOP (1<<3) /* write vol at every ivop: WI
N32/divx compatibility */
#define XVID_GLOBAL_FORCE_VOL (1<<4) /* when vol-based parameters a
re changed, insert an ivop NOT recommended */
#endif
/*-------------------------------------------------------------------------
---
* "VOL" flags
* *
* This is the XviD's decoder entry point. The possible operations are * These flags are used for xvid_enc_frame_t->vol_flags field during frame
* described in the \ref decops_grp section. * encoding (operation XVID_ENC_ENCODE)
*-------------------------------------------------------------------------
-*/
#define XVID_VOL_MPEGQUANT (1<<0) /* enable MPEG type quantization */
#define XVID_VOL_EXTRASTATS (1<<1) /* enable plane sse stats */
#define XVID_VOL_QUARTERPEL (1<<2) /* enable quarterpel: frames will en
coded as quarterpel */
#define XVID_VOL_GMC (1<<3) /* enable GMC; frames will be checke
d for gmc suitability */
#define XVID_VOL_REDUCED_ENABLE (1<<4) /* enable reduced resolution vops: f
rames will be checked for rrv suitability */
#define XVID_VOL_INTERLACING (1<<5) /* enable interlaced encoding */
/*-------------------------------------------------------------------------
---
* "VOP" flags
* *
* \param handle Decoder instance handle. * These flags are used for xvid_enc_frame_t->vop_flags field during frame
* \param opt Decoder option constant * encoding (operation XVID_ENC_ENCODE)
* \param param1 Used to pass a XVID_DEC_PARAM or XVID_DEC_FRAME structure *-------------------------------------------------------------------------
* \param param2 Reserved for future use. -*/
*/
int xvid_decore(void *handle, /* Always valid */
int opt, #define XVID_VOP_DEBUG (1<< 0) /* print debug messages in fr
void *param1, ames */
void *param2); #define XVID_VOP_HALFPEL (1<< 1) /* use halfpel interpolation
*/
#define XVID_VOP_INTER4V (1<< 2) /* use 4 motion vectors per M
B */
#define XVID_VOP_TRELLISQUANT (1<< 3) /* use trellis based R-D "opt
imal" quantization */
#define XVID_VOP_CHROMAOPT (1<< 4) /* enable chroma optimization
pre-filter */
#define XVID_VOP_CARTOON (1<< 5) /* use 'cartoon mode' */
#define XVID_VOP_GREYSCALE (1<< 6) /* enable greyscale only mode
(even for color input material chroma is ignored) */
#define XVID_VOP_HQACPRED (1<< 7) /* high quality ac prediction
*/
#define XVID_VOP_MODEDECISION_RD (1<< 8) /* enable DCT-ME and use it f
or mode decision */
#define XVID_VOP_FAST_MODEDECISION_RD (1<<12) /* use simplified R-D mode de
cision */
/** @} */ /* Only valid for vol_flags|=XVID_VOL_INTERLACING */
#define XVID_VOP_TOPFIELDFIRST (1<< 9) /* set top-field-first flag
*/
#define XVID_VOP_ALTERNATESCAN (1<<10) /* set alternate vertical sca
n flag */
/** @} */ /* only valid for vol_flags|=XVID_VOL_REDUCED_ENABLED */
#define XVID_VOP_REDUCED (1<<11) /* reduced resolution vop */
/** /*-------------------------------------------------------------------------
* \defgroup encoder_grp Encoder related functions and structures. ---
* "Motion" flags
* *
* @{ * These flags are used for xvid_enc_frame_t->motion field during frame
*/ * encoding (operation XVID_ENC_ENCODE)
*-------------------------------------------------------------------------
/************************************************************************** -*/
***
* Encoder constants
**************************************************************************
**/
/** /* Motion Estimation Search Patterns */
* \defgroup encgenflags_grp Flags for XVID_ENC_FRAME.general #define XVID_ME_ADVANCEDDIAMOND16 (1<< 0) /* use advdiamonds instead of
* @{ diamonds as search pattern */
*/ #define XVID_ME_ADVANCEDDIAMOND8 (1<< 1) /* use advdiamond for XVID_ME
_EXTSEARCH8 */
#define XVID_ME_USESQUARES16 (1<< 2) /* use squares instead of dia
monds as search pattern */
#define XVID_ME_USESQUARES8 (1<< 3) /* use square for XVID_ME_EXT
SEARCH8 */
#define XVID_VALID_FLAGS 0x80000000 /**< Reserved for future /* SAD operator based flags */
use */ #define XVID_ME_HALFPELREFINE16 (1<< 4)
#define XVID_ME_HALFPELREFINE8 (1<< 6)
#define XVID_ME_QUARTERPELREFINE16 (1<< 7)
#define XVID_ME_QUARTERPELREFINE8 (1<< 8)
#define XVID_ME_GME_REFINE (1<< 9)
#define XVID_ME_EXTSEARCH16 (1<<10) /* extend PMV by more searche
s */
#define XVID_ME_EXTSEARCH8 (1<<11) /* use diamond/square for ext
ended 8x8 search */
#define XVID_ME_CHROMA_PVOP (1<<12) /* also use chroma for P_VOP/
S_VOP ME */
#define XVID_ME_CHROMA_BVOP (1<<13) /* also use chroma for B_VOP
ME */
#define XVID_ME_FASTREFINE16 (1<<25) /* use low-complexity refinem
ent functions */
#define XVID_ME_FASTREFINE8 (1<<29) /* low-complexity 8x8 sub-blo
ck refinement */
#define XVID_CUSTOM_QMATRIX 0x00000004 /**< Use custom quantizat /* Rate Distortion based flags
ion matrices * Valid when XVID_VOP_MODEDECISION_RD is enabled */
#define XVID_ME_HALFPELREFINE16_RD (1<<14) /* perform RD-based halfpel r
* efinement */
* This flag forces XviD to use custom matrices passed to encoder in #define XVID_ME_HALFPELREFINE8_RD (1<<15) /* perform RD-based halfpel r
* XVID_ENC_FRAME structure (members quant_intra_matrix and quant_inter_mat efinement for 8x8 mode */
rix) */ #define XVID_ME_QUARTERPELREFINE16_RD (1<<16) /* perform RD-based qpel refi
#define XVID_H263QUANT 0x00000010 /**< Use H263 quantizatio nement */
n #define XVID_ME_QUARTERPELREFINE8_RD (1<<17) /* perform RD-based qpel refi
nement for 8x8 mode */
* #define XVID_ME_EXTSEARCH_RD (1<<18) /* perform RD-based search us
* This flag forces XviD to use H263 quantization type */ ing square pattern enable XVID_ME_EXTSEARCH8 to do this in 8x8 search as we
#define XVID_MPEGQUANT 0x00000020 /**< Use MPEG4 quantizati ll */
on. #define XVID_ME_CHECKPREDICTION_RD (1<<19) /* always check vector equal
to prediction */
*
* This flag forces XviD to use MPEG4 quantization type */
#define XVID_HALFPEL 0x00000040 /**< Halfpel motion estim
ation
*
* informs xvid to perform a half pixel motion estimation. */
#define XVID_ADAPTIVEQUANT 0x00000080/**< Adaptive quantization
*
* informs xvid to perform an adaptative quantization using a Luminance
* masking algorithm */
#define XVID_LUMIMASKING 0x00000100/**< Lumimasking flag
*
* \deprecated This flag is no longer used. */
#define XVID_LATEINTRA 0x00000200/**< Unknown
*
* \deprecated This flag is no longer used. */
#define XVID_INTERLACING 0x00000400/**< MPEG4 interlacing mod
e.
*
* Enables interlacing encoding mode */
#define XVID_TOPFIELDFIRST 0x00000800/**< Unknown
*
* \deprecated This flag is no longer used. */
#define XVID_ALTERNATESCAN 0x00001000/**<
*
* \deprecated This flag is no longer used. */
#define XVID_HINTEDME_GET 0x00002000/**< Gets Motion vector da
ta from ME system.
*
* informs xvid to return Motion Estimation vectors from the ME encoder
* algorithm. Used during a first pass. */
#define XVID_HINTEDME_SET 0x00004000/**< Gives Motion vectors
hint to ME system.
*
* informs xvid to use the user given motion estimation vectors as hints
* for the encoder ME algorithms. Used during a 2nd pass. */
#define XVID_INTER4V 0x00008000/**< Inter4V mode.
*
* forces XviD to search a vector for each 8x8 block within the 16x16 Macro
* Block. This mode should be used only if the XVID_HALFPEL mode is activa
ted
* (this could change in the future). */
#define XVID_ME_ZERO 0x00010000/**< Unused
*
* Do not use this flag (reserved for future use) */
#define XVID_ME_LOGARITHMIC 0x00020000/**< Unused
*
* Do not use this flag (reserved for future use) */
#define XVID_ME_FULLSEARCH 0x00040000/**< Unused
*
* Do not use this flag (reserved for future use) */
#define XVID_ME_PMVFAST 0x00080000/**< Use PMVfast M
E algorithm.
*
* Switches XviD ME algorithm to PMVfast */
#define XVID_ME_EPZS 0x00100000/**< Use EPZS ME algorithm
.
*
* Switches XviD ME algorithm to EPZS */
#define XVID_GREYSCALE 0x01000000/**< Discard chroma data.
*
* This flags forces XviD to discard chroma data, this is not mpeg4 greyscal
e
* mode, it simply drops chroma MBs using cbp == 0 for these blocks */
#define XVID_GRAYSCALE XVID_GREYSCALE /**< XVID_GREYSCALE a
lias
*
* United States locale support. */
/** @} */ /* Other */
#define XVID_ME_DETECT_STATIC_MOTION (1<<24) /* speed-up ME by detecting s
tationary scenes */
#define XVID_ME_SKIP_DELTASEARCH (1<<26) /* speed-up by skipping b-fra
me delta search */
#define XVID_ME_FAST_MODEINTERPOLATE (1<<27) /* speed-up by partly skippin
g interpolate mode */
#define XVID_ME_BFRAME_EARLYSTOP (1<<28) /* speed-up by early exiting
b-search */
/** /* Unused */
* \defgroup encmotionflags_grp Flags for XVID_ENC_FRAME.motion #define XVID_ME_UNRESTRICTED16 (1<<20) /* unrestricted ME, not imple
* @{ mented */
*/ #define XVID_ME_OVERLAPPING16 (1<<21) /* overlapping ME, not implem
ented */
#define XVID_ME_UNRESTRICTED8 (1<<22) /* unrestricted ME, not imple
mented */
#define XVID_ME_OVERLAPPING8 (1<<23) /* overlapping ME, not implem
ented */
#define PMV_ADVANCEDDIAMOND8 0x00004000/**< Uses advanced diamonds for 8x /*-------------------------------------------------------------------------
8 blocks ---
* xvid_enc_create_t structure definition
* *
* Same as its 16x16 companion option * This structure is passed as param1 during an instance creation (operatio
*/ n
#define PMV_ADVANCEDDIAMOND16 0x00008000/**< Uses advanced diamonds for 1 * XVID_ENC_CREATE)
6x16 blocks *-------------------------------------------------------------------------
-*/
*
* */
#define PMV_HALFPELDIAMOND16 0x00010000/**< Turns on halfpel precision fo
r 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 s
tep
*
* After normal diamond search, an extra halfpel refinement step is perform
ed. Should always be used if
* XVID_HALFPEL is on, because it gives a rather big increase in quality.
*/
#define PMV_EXTSEARCH16 0x00040000/**< Extends search for 16
x16 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 th
resholding
*
* PMVfast and EPZS stop search if current best is below some dynamic thr
eshhold. No diamond search is done,
* only halfpel refinement (if active). Without EARLYSTOP diamond search i
s always done. That would be much slower,
* but not really lead to better quality.
*/
#define PMV_QUICKSTOP16 0x00100000/**< Dynamic ME th
resholding
*
* 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 equ
ivalent
*
* 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 equ
ivalent
*
* Same as its 16x16 companion option */
/** @} */ typedef struct {
int version;
/************************************************************************** int profile; /* [in] profile@level; refer to XVID_PR
*** OFILE_xxx */
* Encoder structures int width; /* [in] frame dimensions; width, pixel
************************************************************************** units */
**/ int height; /* [in] frame dimensions; height, pixel
units */
/** Structure used for encoder instance creation */ int num_zones; /* [in:opt] number of bitrate zones */
typedef struct xvid_enc_zone_t * zones; /* ^^ zone array */
{
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]
*
*
XviD core lib will set this with the creater encoder instance. */
}
XVID_ENC_PARAM;
typedef struct int num_plugins; /* [in:opt] number of plugins */
{ xvid_enc_plugin_t * plugins; /* ^^ plugin array */
int x;
int y;
}
VECTOR;
typedef struct int num_threads; /* [in:opt] number of threads */
{ int max_bframes; /* [in:opt] max sequential bframes (0=d
int mode; /* macroblock mode * isable bframes) */
/
VECTOR mvs[4];
}
MVBLOCKHINT;
typedef struct int global; /* [in:opt] global flags; controls enco
{ ding behavior */
int intra; /* frame intra choic
e */
int fcode; /* frame fcode */
MVBLOCKHINT *block; /* caller-allocated array of
block hints (mb_width * mb_height) */
}
MVFRAMEHINT;
typedef struct /* --- vol-based stuff; included here for convenience */
{ int fincr; /* [in:opt] framerate increment; set to
int rawhints; /* if set, use MVFRAMEHINT, zero for variable framerate */
else use compressed buffer */ int fbase; /* [in] framerate base frame_duration =
fincr/fbase seconds*/
/* ---------------------------------------------- */
MVFRAMEHINT mvhint; /* --- vop-based; included here for convenience */
void *hintstream; /* compressed hint buffer */ int max_key_interval; /* [in:opt] the maximum interval betwee
int hintlength; /* length of buffer (bytes) n key frames */
*/
}
HINTINFO;
/** Structure used to pass a frame to the encoder */ int frame_drop_ratio; /* [in:opt] frame dropping: 0=drop none
typedef struct ... 100=drop all */
{
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 qu
antizer
* 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 s
pecific
* 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 XviD if the frame must be encoded as an int
ra 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 conte
nts 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 ef
fective keyframe state
* of the frame.
* </ul>
*/
HINTINFO hint; /**< [in/out]
*
* mv hint information */
} int bquant_ratio; /* [in:opt] bframe quantizer multipier/
XVID_ENC_FRAME; offeset; used to decide bframes quant when bquant==-1 */
int bquant_offset; /* bquant = (avg(past_ref_quant,future_
ref_quant)*bquant_ratio + bquant_offset) / 100 */
/** Encoding statistics */ int min_quant[3]; /* [in:opt] */
typedef struct int max_quant[3]; /* [in:opt] */
{ /* ---------------------------------------------- */
int quant; /**< [out]
*
* Frame qu
antizer used during encoding */
int hlength; /**< [out]
*
* Header b
ytes in the resulting MPEG4 stream */
int kblks; /**< [out]
*
* Number o
f intra macro blocks */
int mblks; /**< [out]
*
* Number o
f inter macro blocks */
int ublks; /**< [out]
*
* Number o
f skipped macro blocks */
}
XVID_ENC_STATS;
/************************************************************************** void *handle; /* [out] encoder instance handle */
*** } xvid_enc_create_t;
* Encoder entry point
**************************************************************************
**/
/** /*-------------------------------------------------------------------------
* \defgroup encops_grp Encoder operations ---
* * xvid_enc_frame_t structure definition
* These are all the operations XviD's encoder can perform.
* *
* @{ * This structure is passed as param1 during a frame encoding (operation
*/ * XVID_ENC_ENCODE)
*-------------------------------------------------------------------------
-*/
#define XVID_ENC_ENCODE 0 /**< Encodes a frame /* out value for the frame structure->type field
* * unlike stats output in param2, this field is not asynchronous and tells
* This operation constant is used when client application wants to encode * the client app, if the frame written into the stream buffer is an ivop
a * usually used for indexing purpose in the container */
* frame. Client application must also fill XVID_ENC_FRAME appropriately. #define XVID_KEYFRAME (1<<1)
*/
#define XVID_ENC_CREATE 1 /**< Creates a decoder instance /* The structure */
* typedef struct {
* This operation constant is used by a client application in order to crea int version;
te
* an encoder instance. Encoder instances are independant from each other.
*/
#define XVID_ENC_DESTROY 2 /**< Destroys a encoder instance /* VOL related stuff
* * unless XVID_FORCEVOL is set, the encoder will not react to any ch
* This operation constant is used by the client application to destroy a anges
* previously created encoder instance. * here until the next VOL (keyframe). */
*/
/** @} */ int vol_flags; /* [in] vol flags */
unsigned char *quant_intra_matrix; /* [in:opt] custom intra qmatrix
*/
unsigned char *quant_inter_matrix; /* [in:opt] custom inter qmatrix
*/
/** int par; /* [in:opt] pixel aspect ratio (r
* \defgroup encentry_grp Encoder entry point efer to XVID_PAR_xxx above) */
* int par_width; /* [in:opt] aspect ratio width */
* @{ int par_height; /* [in:opt] aspect ratio height *
*/ /
/** /* Other fields that can change on a frame base */
* \brief Encoder entry point.
*
* This is the XviD'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 XVID_ENC_PARAM or XVID_ENC_FRAME structures.
* \param param2 Optionally used to pass the XVID_ENC_STATS structure.
*/
int xvid_encore(void *handle,
int opt,
void *param1,
void *param2);
/** @} */ int fincr; /* [in:opt] framerate increment,
for variable framerate only */
int vop_flags; /* [in] (general)vop-based flags
*/
int motion; /* [in] ME options */
/** @} */ xvid_image_t input; /* [in] input image (read from) *
/
int type; /* [in:opt] coding type */
int quant; /* [in] frame quantizer; if <=0,
automatic (ratecontrol) */
int bframe_threshold;
void *bitstream; /* [in:opt] bitstream ptr (writte
n to)*/
int length; /* [in:opt] bitstream length (byt
es) */
int out_flags; /* [out] bitstream output flags *
/
} xvid_enc_frame_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
 End of changes. 103 change blocks. 
875 lines changed or deleted 756 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/