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;
}
enix_venc_t *create_xvid_enc (void) {
xvid_t *this;
this = malloc (sizeof (xvid_t));
this->encoder.init = xvid_init_encoder;
this->encoder.set_pass = xvid_set_pass;
this->encoder.get_headers = NULL;
this->encoder.encode_frame = xvid_encode_frame;
this->encoder.get_bitstream = xvid_get_bitstream;
this->encoder.flush = xvid_flush;
this->encoder.dispose = xvid_dispose;
this->encoder.get_properties = xvid_get_properties;
this->encoder.get_extra_info = xvid_get_extra_info;
this->encoder.options = enix_create_options ();
this->xvid_handle = 0;
this->xinit.cpu_flags = 0;
this->hints_file = NULL;
this->pass = 0;
this->encoder.options->new_num_option (this->encoder.options, "quality", 7);
this->encoder.options->new_num_option (this->encoder.options, "max_bframes", -1);
this->encoder.options->new_num_option (this->encoder.options, "bitrate", 500000);
xvid_init (NULL, 0, &this->xinit, NULL);
#ifdef LOG
printf ("xvid: api version is 0x%08x\n", this->xinit.api_version);
#endif
return &this->encoder;
}
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 codec_data_t *xvid_create (const char *stream_type,
const char *compressor,
int type,
int profile,
format_list_t *media_fmt,
video_info_t *vinfo,
const uint8_t *userdata,
uint32_t ud_size,
video_vft_t *vft,
void *ifptr)
{
xvid_codec_t *xvid;
xvid = MALLOC_STRUCTURE(xvid_codec_t);
memset(xvid, 0, sizeof(*xvid));
xvid->m_vft = vft;
xvid->m_ifptr = ifptr;
XVID_INIT_PARAM xvid_param;
xvid_param.cpu_flags = 0;
xvid_init(NULL, 0, &xvid_param, NULL);
xvid->m_decodeState = XVID_STATE_VO_SEARCH;
if (media_fmt != NULL && media_fmt->fmt_param != NULL) {
// See if we can decode a passed in vovod header
if (parse_vovod(xvid, media_fmt->fmt_param, 1, 0) == 0) {
xvid->m_decodeState = XVID_STATE_WAIT_I;
}
} else if (userdata != NULL) {
if (parse_vovod(xvid, (char *)userdata, 0, ud_size) == 0) {
xvid->m_decodeState = XVID_STATE_WAIT_I;
}
}
xvid->m_vinfo = vinfo;
xvid->m_num_wait_i = 0;
xvid->m_num_wait_i_frames = 0;
xvid->m_total_frames = 0;
xvid_message(LOG_DEBUG, "xvid", "created xvid");
return ((codec_data_t *)xvid);
}
/* 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;
}
GF_BaseDecoder *NewXVIDDec()
{
const char *sOpt;
GF_MediaDecoder *ifcd;
XVIDDec *dec;
GF_SAFEALLOC(ifcd, GF_MediaDecoder);
GF_SAFEALLOC(dec, XVIDDec);
GF_REGISTER_MODULE_INTERFACE(ifcd, GF_MEDIA_DECODER_INTERFACE, "XviD Decoder", "gpac distribution")
ifcd->privateStack = dec;
if (!xvid_is_init) {
#ifdef XVID_USE_OLD_API
XVID_INIT_PARAM init;
init.api_version = 0;
init.core_build = 0;
/*get info*/
init.cpu_flags = XVID_CPU_CHKONLY;
xvid_init(NULL, 0, &init, NULL);
/*then init*/
xvid_init(NULL, 0, &init, NULL);
#else
xvid_gbl_init_t init;
init.debug = 0;
init.version = XVID_VERSION;
init.cpu_flags = 0; /*autodetect*/
xvid_global(NULL, 0, &init, NULL);
#endif
xvid_is_init = 1;
}
/*get config*/
dec->base_filters = 0;
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcd, "XviD", "PostProc");
if (sOpt) {
#ifndef XVID_USE_OLD_API
if (strstr(sOpt, "FilmEffect")) dec->base_filters |= XVID_FILMEFFECT;
#endif
if (strstr(sOpt, "Deblock_Y")) {
#ifdef XVID_USE_OLD_API
dec->base_filters |= XVID_DEC_DEBLOCKY;
#else
dec->base_filters |= XVID_DEBLOCKY;
#endif
}
if (strstr(sOpt, "Deblock_UV")) {
#ifdef XVID_USE_OLD_API
dec->base_filters |= XVID_DEC_DEBLOCKUV;
#else
dec->base_filters |= XVID_DEBLOCKUV;
#endif
}
}
/*setup our own interface*/
ifcd->AttachStream = XVID_AttachStream;
ifcd->DetachStream = XVID_DetachStream;
ifcd->GetCapabilities = XVID_GetCapabilities;
ifcd->SetCapabilities = XVID_SetCapabilities;
ifcd->GetName = XVID_GetCodecName;
ifcd->CanHandleStream = XVID_CanHandleStream;
ifcd->ProcessData = XVID_ProcessData;
return (GF_BaseDecoder *) ifcd;
}
bool CXvidVideoEncoder::Init (void)
{
XVID_INIT_PARAM xvidInitParams;
memset(&xvidInitParams, 0, sizeof(xvidInitParams));
if (xvid_init(NULL, 0, &xvidInitParams, NULL) != XVID_ERR_OK) {
error_message("Failed to initialize Xvid");
return false;
}
XVID_ENC_PARAM xvidEncParams;
memset(&xvidEncParams, 0, sizeof(xvidEncParams));
xvidEncParams.width = Profile()->m_videoWidth;
xvidEncParams.height = Profile()->m_videoHeight;
if (Profile()->GetIntegerValue(CFG_VIDEO_TIMEBITS) == 0) {
xvidEncParams.fincr = 1;
xvidEncParams.fbase =
(int)(Profile()->GetFloatValue(CFG_VIDEO_FRAME_RATE) + 0.5);
} else {
xvidEncParams.fincr =
(int)(((double)Profile()->GetIntegerValue(CFG_VIDEO_TIMEBITS)) /
Profile()->GetFloatValue(CFG_VIDEO_FRAME_RATE));
xvidEncParams.fbase =
Profile()->GetIntegerValue(CFG_VIDEO_TIMEBITS);
}
xvidEncParams.rc_bitrate =
Profile()->GetIntegerValue(CFG_VIDEO_BIT_RATE) * 1000;
xvidEncParams.min_quantizer = 1;
xvidEncParams.max_quantizer = 31;
xvidEncParams.max_key_interval = (int)
(Profile()->GetFloatValue(CFG_VIDEO_FRAME_RATE)
* Profile()->GetFloatValue(CFG_VIDEO_KEY_FRAME_INTERVAL));
if (xvidEncParams.max_key_interval == 0) {
xvidEncParams.max_key_interval = 1;
}
if (xvid_encore(NULL, XVID_ENC_CREATE, &xvidEncParams, NULL)
!= XVID_ERR_OK) {
error_message("Failed to initialize Xvid encoder");
return false;
}
m_xvidHandle = xvidEncParams.handle;
memset(&m_xvidFrame, 0, sizeof(m_xvidFrame));
m_xvidFrame.general = XVID_HALFPEL | XVID_H263QUANT;
if (!m_realTime) {
m_xvidFrame.motion =
PMV_EARLYSTOP16 | PMV_HALFPELREFINE16
| PMV_EARLYSTOP8 | PMV_HALFPELDIAMOND8;
} else {
m_xvidFrame.motion = PMV_QUICKSTOP16;
}
if (!m_realTime) {
m_xvidFrame.general |= XVID_INTER4V;
}
m_xvidFrame.colorspace = XVID_CSP_I420;
m_xvidFrame.quant = 0;
#ifdef WRITE_RAW
m_raw_file = fopen("raw.xvid", FOPEN_WRITE_BINARY);
#endif
return true;
}
