自学教程：C++ xvid_encore函数代码示例

static void mpeg4_stop( struct mpeg4_encoder *en ){	spook_log( SL_DEBUG, "mpeg4: destroying mpeg4 encoder" );	xvid_encore( en->xvid_handle, XVID_ENC_DESTROY, NULL, NULL );	en->xvid_handle = NULL;}

int FFV1_XvidInit(v4linfo *info){int err;	printf("Initializing Xvid with width =%d, height = %d in YUV420P format/n",info->width,info->height);    	XVID_INIT_PARAM xinit;     	memset(&xinit,0,sizeof(xinit));	memset(&fr, 0, sizeof(fr));   	xinit.cpu_flags = XVID_CPU_MMX;	xvid_init(NULL, 0, &xinit, NULL);   	xparam.fincr = 1000;	if(info->ntsc)   		xparam.fbase =29970;	else   		xparam.fbase =25000;	xparam.width 			= info->width;	xparam.height 			= info->height;	xparam.min_quantizer  	= info->quality;	xparam.max_quantizer 	= info->quality;	xparam.max_key_interval = info->keydist;	err = xvid_encore(NULL, XVID_ENC_CREATE, &xparam, NULL); 	if( XVID_ERR_OK!=err)  	{      		printf("/n Error initializing xvid !!!/n");       		return 0;     	}	xvid_handle=xparam.handle;	printf("Xvid successfully initialized/n"); 	return 1;}

static int enc_stop(){	int xerr;	xerr = xvid_encore(enc_handle, XVID_ENC_DESTROY, NULL, NULL);	return xerr;}

void CXvidVideoEncoder::StopEncoder(){  CHECK_AND_FREE(m_vopBuffer);  xvid_encore(m_xvidHandle, XVID_ENC_DESTROY, NULL, NULL);  m_xvidHandle = NULL;#ifdef WRITE_RAW  fclose(m_raw_file);#endif}

uint8_t xvidEncoderCQ::encode(				ADMImage * in,			    uint8_t * out,			    uint32_t * len,       		uint32_t * flags){	XVID_ENC_FRAME xframe; 	int xerr;	memset(&xframe,0,sizeof(xframe));	xframe.general = encode_flags;	xframe.motion = motion_flags;	xframe.bitstream = out;	xframe.length = -1; 	// this is written by the routine	xframe.image = in->data;    	xframe.colorspace = XVID_CSP_YV12;	// defined in <xvid.h>    	xframe.intra = -1; // let the codec decide between I-frame (1) and P-frame (0)	xframe.quant = _q;//        xframe.quant = QUANTI;	// is quant != 0, use a fixed quant (and ignore bitrate)	xerr = xvid_encore(_handle, XVID_ENC_ENCODE, &xframe, &xstats);/*	        enc_result->is_key_frame = xframe.intra;	        enc_result->quantizer = xframe.quant;	        enc_result->total_bits = xframe.length * 8;	        enc_result->motion_bits = xstats.hlength * 8;	        enc_result->texture_bits = enc_result->total_bits - enc_result->motion_bits;*/          	 xvid_res.is_key_frame = xframe.intra;	        xvid_res.quantizer = xframe.quant;	        xvid_res.total_bits = xframe.length * 8;	        xvid_res.motion_bits = xstats.hlength * 8;	        xvid_res.texture_bits = xvid_res.total_bits - xvid_res.motion_bits;		xvid_res.out_quantizer=xstats.quant;/*  This is statictical data, e.g. for 2-pass.    If you are not interested in any of this, you can use NULL instead of &xstats*/	*len = xframe.length; 	 	*flags=0;  	if(xerr!=XVID_ERR_OK) return 0; 	if( xframe.intra)  	{      	*flags=AVI_KEY_FRAME;     }	return 1;}

static void xvid_init_encoder (enix_venc_t *this_gen, enix_stream_t *stream) {    xvid_t            *this = (xvid_t *) this_gen;  XVID_ENC_PARAM     xparam;  int                xerr;  int                width, height, frame_duration;  enix_options_t    *options;  width          = stream->get_property (stream, ENIX_STREAM_PROP_WIDTH);  height         = stream->get_property (stream, ENIX_STREAM_PROP_HEIGHT);  frame_duration = stream->get_property (stream, ENIX_STREAM_PROP_FRAME_DURATION);  options        = this->encoder.options;#ifdef LOG  printf ("xvid: width=%02d, height=%02d/n", width, height);#endif  this->quality                   = options->get_num_option (options,							     "quality");  this->bitrate                   = options->get_num_option (options,							     "bitrate");  xparam.width                    = width;  xparam.height                   = height;  xparam.fbase                    = 90000;  xparam.fincr                    = frame_duration;  xparam.rc_reaction_delay_factor = 16;  xparam.rc_averaging_period      = 100;  xparam.rc_buffer                = 10;  xparam.rc_bitrate               = this->bitrate;  xparam.min_quantizer            = 1;  xparam.max_quantizer            = 31;  xparam.max_key_interval         = 250;  xparam.bquant_ratio             = 120;  xparam.bquant_offset            = 0;  xparam.max_bframes              = options->get_num_option (options,							     "max_bframes");;  xparam.frame_drop_ratio         = 0;  xparam.global                   = 0;  xerr = xvid_encore (NULL, XVID_ENC_CREATE, &xparam, NULL);#ifdef LOG  printf ("xvid: enc_create done, xerr = %d/n", xerr);#endif  if (xerr) {    printf ("xvid: XVID_ENC_CREATE failed./n");    exit (1);  }  this->xvid_handle = xparam.handle;}

void Revel_XvidEncoder::Reset(void){    // Must call base Reset() first!    Revel_BaseEncoder::Reset();    if (m_xvidEncoderHandle != NULL)    {	    int xerr = xvid_encore(m_xvidEncoderHandle, XVID_ENC_DESTROY, NULL, NULL);        m_xvidEncoderHandle = NULL;    }}

//____________________________________________////  Initialize the compressor//uint8_txvid4Encoder::stopEncoder (void){  if (_handle)    {      xvid_encore (_handle, XVID_ENC_DESTROY, NULL, NULL);      printf ("[xvid] Destroying/n");      _handle = NULL;    }  return 1;}

// *************************************************// *************************************************//              Pass1// *************************************************// *************************************************uint8_t  xvid4EncoderPass1::init (uint32_t br, uint32_t fps1000,			   xvid4EncParam * param){  int xerr;  printf ("[xvid] Pass 1 of 2 (log: %s)/n",	  (char *) param->logName);  _fps1000 = fps1000;  memcpy (&_param, param, sizeof (_param));  dump ();  // Here we go...  MMSET (xvid_enc_create);  MMSET (pass1);  xvid_enc_create.version = XVID_VERSION;  xvid_enc_create.width = _w;  xvid_enc_create.height = _h;  plugins[0].func = xvid_plugin_2pass1;  plugins[0].param = &pass1;  pass1.version = XVID_VERSION;  pass1.filename = (char *) _param.logName;  xvid_enc_create.plugins = plugins;  xvid_enc_create.num_plugins = 1;  //Framerate  xvid_enc_create.fincr = 1000;  xvid_enc_create.fbase = _fps1000;  //  createUpdate ();  // Force Qz=2 !  xerr = xvid_encore (NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);  if (xerr < 0)    {      printf ("[xvid] Init error: %d/n", xerr);      return 0;    }  _handle = xvid_enc_create.handle;  printf ("[xvid] Pass 1 init Ok/n");  return 1;}

//____________________________________________////  Initialize the compressor//uint8_t     xvidEncoder::stopEncoder(void ){    int ret;    ADM_assert(_init);        ret = xvid_encore(_handle, XVID_ENC_DESTROY, 0, 0);    _init = 0;    _handle=NULL;    if (ret == XVID_ERR_OK)		return 1;    return 0;}

int FFV1_XvidCompress(unsigned char *in,unsigned char *out,uint32_t  *outlen){int ret;	MMSET(xvid_enc_frame);	MMSET(xvid_enc_stats);		xvid_enc_frame.version = XVID_VERSION;		xvid_enc_stats.version = XVID_VERSION;	xvid_enc_frame.length = 0;	xvid_enc_frame.vop_flags|=XVID_VOP_HALFPEL;		if(vinfo.quant)		xvid_enc_frame.vol_flags|=XVID_VOL_MPEGQUANT;		xvid_enc_frame.input.csp = XVID_CSP_YV12;	xvid_enc_frame.input.stride[0] = _w;	xvid_enc_frame.input.stride[1] = _w>>1;	xvid_enc_frame.input.stride[2] = _w>>1;	xvid_enc_frame.type = XVID_TYPE_AUTO;			/* Set up motion estimation flags */	xvid_enc_frame.input.plane[0] = in;	xvid_enc_frame.input.plane[2] = in+(_w*_h);	xvid_enc_frame.input.plane[1] = in+((_w*_h*5)>>2);			xvid_enc_frame.bitstream = out;			xvid_enc_frame.quant = vinfo.quality;	xvid_enc_frame.motion = X4motion_presets[vinfo.me];	if(nextIsKF)	{    		xvid_enc_frame.type = XVID_TYPE_IVOP; // let the codec decide between I-frame (1) and P-frame (0)		nextIsKF=0;	}	else	{    		xvid_enc_frame.type = XVID_TYPE_VOL; // let the codec decide between I-frame (1) and P-frame (0)	}	ret = xvid_encore(xvid_handle, XVID_ENC_ENCODE, &xvid_enc_frame,					  &xvid_enc_stats);	*outlen = ret; #ifdef ADM_DEBUG	printf("Outlen: %lu/n",*outlen); #endif		return 1;}

/** * Destroy the private context for the encoder. * All buffers are freed, and the Xvid encoder context is destroyed. * * @param avctx AVCodecContext pointer to context * @return Returns 0, success guaranteed */static av_cold int xvid_encode_close(AVCodecContext *avctx) {    struct xvid_context *x = avctx->priv_data;    xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);    av_freep(&avctx->extradata);    if( x->twopassbuffer != NULL ) {        av_free(x->twopassbuffer);        av_free(x->old_twopassbuffer);    }    av_free(x->twopassfile);    av_free(x->intra_matrix);    av_free(x->inter_matrix);    return 0;}

static void xvid_dispose (enix_venc_t *this_gen) {  xvid_t  *this = (xvid_t *) this_gen;  int      xerr;  xerr = xvid_encore (this->xvid_handle, XVID_ENC_DESTROY, NULL, NULL);  this->xvid_handle = 0;  if (this->hints_file) {    fclose (this->hints_file);    this->hints_file = NULL;  }  free (this);}

int Revel_XvidEncoder::CreateXvidEncoder(void **encoderOut){    // Initialize XviD core    xvid_gbl_init_t xvid_gbl_init;    memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init));	xvid_gbl_init.version = XVID_VERSION;    xvid_gbl_init.debug = 0;    xvid_gbl_init.cpu_flags = 0;	xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);        // Initialize XviD encoder    xvid_enc_create_t xvid_enc_create;	memset(&xvid_enc_create, 0, sizeof(xvid_enc_create));	xvid_enc_create.version = XVID_VERSION;	xvid_enc_create.width = m_params.width;	xvid_enc_create.height = m_params.height;	xvid_enc_create.profile = XVID_PROFILE_AS_L4;	// init plugins    xvid_enc_zone_t zones[64];    const int NUM_ZONES = 0;    xvid_enc_create.zones = zones;    xvid_enc_create.num_zones = NUM_ZONES;	xvid_enc_plugin_t plugins[7];	xvid_enc_create.plugins = plugins;	xvid_enc_create.num_plugins = 0;        xvid_enc_create.num_threads = 0;    xvid_enc_create.fincr = 1;	xvid_enc_create.fbase = 24;    xvid_enc_create.max_key_interval = xvid_enc_create.fbase * 10;    xvid_enc_create.max_bframes = 0;	xvid_enc_create.bquant_ratio = 150;	xvid_enc_create.bquant_offset = 100;    xvid_enc_create.frame_drop_ratio = 0;    xvid_enc_create.global = 0;    int xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);	// Retrieve the encoder instance from the structure	*encoderOut = xvid_enc_create.handle;	return xerr;}

static void mpeg4_start( struct mpeg4_encoder *en, struct frame *f ){	xvid_enc_create_t xvid_enc_create;	xvid_enc_plugin_t plugins[1];	xvid_plugin_single_t single;	en->reset_pending = 0;	en->width = f->width;	en->height = f->height;	memset( &xvid_enc_create, 0, sizeof( xvid_enc_create ) );	xvid_enc_create.version = XVID_VERSION;	xvid_enc_create.width = en->width;	xvid_enc_create.height = en->height;	xvid_enc_create.profile = XVID_PROFILE_ARTS_L4;	en->input->stream->get_framerate( en->input->stream,						&xvid_enc_create.fincr,						&xvid_enc_create.fbase );	spook_log( SL_DEBUG, "creating mpeg4 encoder with fincr=%d fbase=%d",			xvid_enc_create.fincr, xvid_enc_create.fbase );	xvid_enc_create.zones = NULL;	xvid_enc_create.num_zones = 0;	xvid_enc_create.plugins = plugins;	xvid_enc_create.num_plugins = 1;	xvid_enc_create.num_threads = 0;	xvid_enc_create.max_key_interval = 300;	xvid_enc_create.max_bframes = 0;	xvid_enc_create.bquant_ratio = 150;	xvid_enc_create.bquant_offset = 100;	xvid_enc_create.frame_drop_ratio = 0;	xvid_enc_create.global = 0;	memset( &single, 0, sizeof( single ) );	single.version = XVID_VERSION;	single.bitrate = en->bitrate * 1000;	plugins[0].func = xvid_plugin_single;	plugins[0].param = &single;	if( xvid_encore( NULL, XVID_ENC_CREATE,				&xvid_enc_create, NULL ) )	{		spook_log( SL_ERR, "mpeg4: unable to start XviD!" );		return;	}	en->xvid_handle = xvid_enc_create.handle;}

int xvid_encode_frame(void* handle, unsigned char* frame, int width, int height, unsigned char* bitstream, unsigned int incr) {	xvid_enc_frame_t xvid_enc_frame;	int ret;	unsigned char *buf;		buf = frame;			/* Version for the frame and the stats */	memset(&xvid_enc_frame, 0, sizeof(xvid_enc_frame));	xvid_enc_frame.version = XVID_VERSION;	/* Bind output buffer */	xvid_enc_frame.bitstream = bitstream;	xvid_enc_frame.length = -1;			/* Initialize input image fields */	xvid_enc_frame.input.plane[0] = buf;	xvid_enc_frame.input.csp = XVID_CSP_I420;	xvid_enc_frame.input.stride[0] = width;			/* Set up core's general features */	xvid_enc_frame.vol_flags = 0;			/* Set up core's general features */	xvid_enc_frame.vop_flags = XVID_VOP_HALFPEL | XVID_VOP_INTER4V;			/* Frame type -- let core decide for us */	xvid_enc_frame.type = XVID_TYPE_AUTO;			/* Force the right quantizer -- It is internally managed by RC plugins */	xvid_enc_frame.quant = 0;			/* Set up motion estimation flags */	xvid_enc_frame.motion = 	XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16;			/* We don't use special matrices */	xvid_enc_frame.quant_intra_matrix = NULL;	xvid_enc_frame.quant_inter_matrix = NULL;	xvid_enc_frame.fincr = 0;		ret = xvid_encore(handle, XVID_ENC_ENCODE, &xvid_enc_frame, NULL, &incr);	return ret;}

uint8_t xvidEncoderCQ::initExtented (uint32_t q, xvidEncParam * extend){  XVID_INIT_PARAM    xinit;  int    xerr;  checkFlags (extend);  memset (&xinit, 0, sizeof (xinit));  memset (&fr, 0, sizeof (fr));  //xinit.cpu_flags=XVID_CPU_FORCE;  xinit.cpu_flags = XVID_CPU_MMX;  //---  _q = q;  printf (" Xvid : Compressing %lu x %lu video in CQ %lu/n", _w, _h, _q);  ADM_assert (0 == _init);  xvid_init (NULL, 0, &xinit, NULL);  xparam.width = _w;  xparam.height = _h;  xparam.fincr = 1;  xparam.fbase = 25;  xparam.rc_bitrate = 1000;  xparam.rc_reaction_delay_factor = 16;  xparam.rc_averaging_period = 100;  xparam.rc_buffer = 100;  xparam.min_quantizer = _q;  xparam.max_quantizer = _q;  xparam.max_key_interval = extend->max_key_interval;  xerr = xvid_encore (NULL, XVID_ENC_CREATE, &xparam, NULL);  if (XVID_ERR_OK != xerr)    {      printf ("/n Error initializing xvid !!!");      return 0;    }  _handle = xparam.handle;  dumpConf ();  return 1;}

static GstStateChangeReturngst_xvidenc_change_state (GstElement * element, GstStateChange transition){  GstXvidEnc *xvidenc = GST_XVIDENC (element);  GstStateChangeReturn ret;  switch (transition) {    case GST_STATE_CHANGE_NULL_TO_READY:      if (!gst_xvid_init ())        return GST_STATE_CHANGE_FAILURE;      break;    case GST_STATE_CHANGE_READY_TO_PAUSED:      xvidenc->delay = g_queue_new ();      break;    default:      break;  }  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);  if (ret == GST_STATE_CHANGE_FAILURE)    goto done;  switch (transition) {    case GST_STATE_CHANGE_PAUSED_TO_READY:      if (xvidenc->handle) {        gst_xvidenc_flush_buffers (xvidenc, FALSE);        xvid_encore (xvidenc->handle, XVID_ENC_DESTROY, NULL, NULL);        xvidenc->handle = NULL;      }      g_queue_free (xvidenc->delay);      xvidenc->delay = NULL;      g_free (xvidenc->xframe_cache);      xvidenc->xframe_cache = NULL;      break;    default:      break;  }done:  return ret;}

int evid_destroy_handler(evid_handler_t *evid_handler, char **errstr) {  handler_t *handler=(handler_t *)evid_handler;  free(handler->filename);  // avilib  if(AVI_close(handler->avilib.avi)) {    x_asprintf(errstr, "Error closing AVI file: %s./n", AVI_strerror());    return 1;  }  // xvid  if(xvid_encore(handler->xvid.handle, XVID_ENC_DESTROY, NULL, NULL)) {    (*errstr)=NULL;    return 1;  }  // free bitstream  free(handler->xvid.bitstream);  // free handle  free(handler);  return 0;}

/** * Destroys the private context for the encoder. * All buffers are freed, and the XviD encoder context is destroyed. * * @param avctx AVCodecContext pointer to context * @return Returns 0, success guaranteed */int ff_xvid_encode_close(AVCodecContext *avctx) {    xvid_context_t *x = avctx->priv_data;    xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);    if( avctx->extradata != NULL )        av_free(avctx->extradata);    if( x->twopassbuffer != NULL ) {        av_free(x->twopassbuffer);        av_free(x->old_twopassbuffer);    }    if( x->twopassfile != NULL )        av_free(x->twopassfile);    if( x->intra_matrix != NULL )        av_free(x->intra_matrix);    if( x->inter_matrix != NULL )        av_free(x->inter_matrix);    return 0;}

static int enc_main(unsigned char* image, unsigned char* bitstream,					long *streamlength, long *frametype){	int xerr;	XVID_ENC_FRAME xframe;	XVID_ENC_STATS xstats;	xframe.bitstream = bitstream;	xframe.length = -1; 	/* this is written by the routine */	xframe.image = image;	xframe.colorspace = XVID_CSP_I420;	/* defined in <xvid.h> */    /* let the codec decide between I-frame (1) and P-frame (0) */    if(filenr % (ARG_NUMBEROFP + 1) == 0)	{		xframe.intra = 1;	}	else	{		xframe.intra = 0;	}	xframe.quant = ARG_QUANTI;	/* is quant != 0, use a fixed quant (and ignore bitrate) */	xframe.motion = motion_presets[ARG_QUALITY];	xframe.general = general_presets[ARG_QUALITY];	xframe.quant_intra_matrix = xframe.quant_inter_matrix = NULL;	xerr = xvid_encore(enc_handle, XVID_ENC_ENCODE, &xframe, &xstats);	/*	 * This is statictical data, e.g. for 2-pass. If you are not	 * interested in any of this, you can use NULL instead of &xstats	 */	*frametype = xframe.intra;	*streamlength = xframe.length;	return xerr;}

static int scxvid_process_frame(scxvid_state_t *state, void *plane_y, int stride_y, void *plane_u, int stride_u, void *plane_v, int stride_v){    state->xvid_enc_frame.input.plane[0] = plane_y;    state->xvid_enc_frame.input.stride[0] = stride_y;    state->xvid_enc_frame.input.plane[1] = plane_u;    state->xvid_enc_frame.input.stride[1] = stride_u;    state->xvid_enc_frame.input.plane[2] = plane_v;    state->xvid_enc_frame.input.stride[2] = stride_v;    state->xvid_enc_frame.length = SCXVID_BUFFER_SIZE;    state->xvid_enc_frame.bitstream = state->output_buffer;    int error = xvid_encore(state->xvid_handle, XVID_ENC_ENCODE, &state->xvid_enc_frame, NULL);    if (error < 0)    {        fprintf(stderr,"SCXvid: xvid_encore returned an error code/n");        return error;    }    return 0;}

uint8_t xvid4Encoder::encode(ADMImage * in,ADMBitstream * out){    int  ret=0;    /* Encode the frame */    xvid_enc_frame.bitstream = out->data;    preAmble (in->data);    ret = xvid_encore (_handle, XVID_ENC_ENCODE, &xvid_enc_frame,                       &xvid_enc_stats);    if (ret < 0)    {        printf ("[xvid] Error calling xvid4 %d/n", ret);        return 0;    }    postAmble (out);    out->len = ret;    if (!ret)        printf ("[xvid] Skipped/n");    return 1;}

bool CXvidVideoEncoder::EncodeImage(				    const u_int8_t* pY, 				    const u_int8_t* pU, 				    const u_int8_t* pV, 				    u_int32_t yStride,				    u_int32_t uvStride,				    bool wantKeyFrame,				    Duration Elapsed,				    Timestamp srcFrameTimestamp){  m_srcFrameTimestamp = srcFrameTimestamp;	m_vopBuffer = (u_int8_t*)malloc(Profile()->m_videoMaxVopSize);	if (m_vopBuffer == NULL) {		return false;	}	XVID_DEC_PICTURE decpict;	decpict.y = (void *)pY;	decpict.u = (void *)pU;	decpict.v = (void *)pV;	decpict.stride_y = yStride;	decpict.stride_u = uvStride;	m_xvidFrame.image = &decpict;	m_xvidFrame.colorspace = XVID_CSP_USER;	m_xvidFrame.bitstream = m_vopBuffer;	m_xvidFrame.intra = (wantKeyFrame ? 1 : -1);	if (xvid_encore(m_xvidHandle, XVID_ENC_ENCODE, &m_xvidFrame, 	  &m_xvidResult) != XVID_ERR_OK) {		debug_message("Xvid can't encode frame!");		CHECK_AND_FREE(m_vopBuffer);		return false;	}	m_vopBufferLength = m_xvidFrame.length;	return true;}

/* Initialize encoder for first use, pass all needed parameters to the codec */static int enc_init(void){	int xerr;		XVID_INIT_PARAM xinit;	XVID_ENC_PARAM xparam;	xinit.cpu_flags = XVID_CPU_FORCE;	xvid_init(NULL, 0, &xinit, NULL);	xparam.width = XDIM;	xparam.height = YDIM;	if ((ARG_FRAMERATE - (int)ARG_FRAMERATE) < SMALL_EPS)	{		xparam.fincr = 1;		xparam.fbase = (int)ARG_FRAMERATE;	}	else	{		xparam.fincr = FRAMERATE_INCR;		xparam.fbase = (int)(FRAMERATE_INCR * ARG_FRAMERATE);	}	xparam.rc_reaction_delay_factor = 16;    xparam.rc_averaging_period = 100;    xparam.rc_buffer = 10;	xparam.rc_bitrate = ARG_BITRATE; 	xparam.min_quantizer = ARG_MINQUANT;	xparam.max_quantizer = ARG_MAXQUANT;	xparam.max_key_interval = (int)ARG_FRAMERATE*10;	/* I use a small value here, since will not encode whole movies, but short clips */	xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xparam, NULL);	enc_handle=xparam.handle;	return xerr;}