annotate libmpcodecs/ve_xvid4.c @ 33109:01b19cf2649c

Fix segfault in lavcac3enc audio filter. The FFmpeg ac3 encoder would fail to open if the correct sample format is not set. As the opening is done in control() the audio filter would not fail back, but would instead continue and call encoding functions that dereference NULL pointer.

/*
 * - XviD 1.x decoder module for mplayer/mencoder -
 *
 * Copyright(C) 2003      Marco Belli <[e-mail]>
 *              2003-2004 Edouard Gomez <[e-mail]>
 *
 * This file is part of MPlayer.
 *
 * MPlayer is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * MPlayer is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/*****************************************************************************
 * Includes
 ****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include <limits.h>
#include <time.h>

#include "config.h"
#include "mp_msg.h"
#include "mencoder.h"
#include "codec-cfg.h"
#include "stream/stream.h"
#include "libmpdemux/demuxer.h"
#include "libmpdemux/stheader.h"

#include "stream/stream.h"
#include "libmpdemux/muxer.h"

#include "img_format.h"
#include "mp_image.h"
#include "ve.h"
#include "vf.h"

#include <xvid.h>
#include <stdio.h>
#include <stdarg.h>
#include <limits.h>
#include <assert.h>

#include "m_option.h"
#include "libavutil/avutil.h"

#define FINE (!0)
#define BAD (!FINE)

#define MAX_ZONES   64

// Profile flag definitions
#define PROFILE_ADAPTQUANT 0x00000001
#define PROFILE_BVOP       0x00000002
#define PROFILE_MPEGQUANT  0x00000004
#define PROFILE_INTERLACE  0x00000008
#define PROFILE_QPEL       0x00000010
#define PROFILE_GMC        0x00000020
#define PROFILE_4MV        0x00000040
#define PROFILE_DXN        0x00000080

// Reduce code duplication in profiles[] array
#define PROFILE_S   (PROFILE_4MV)
#define PROFILE_AS  (PROFILE_4MV|PROFILE_ADAPTQUANT|PROFILE_BVOP|PROFILE_MPEGQUANT|PROFILE_INTERLACE|PROFILE_QPEL|PROFILE_GMC)

typedef const struct
{
	const char *name;            ///< profile name
	int id;                      ///< mpeg-4 profile id; iso/iec 14496-2:2001 table G-1
	int width;                   ///< profile width restriction
	int height;                  ///< profile height restriction
	int fps;                     ///< profile frame rate restriction
	int max_objects;             ///< ??????
	int total_vmv_buffer_sz;     ///< macroblock memory; when BVOPS=false, vmv = 2*vcv; when BVOPS=true,  vmv = 3*vcv
	int max_vmv_buffer_sz;       ///< max macroblocks per vop
	int vcv_decoder_rate;        ///< macroblocks decoded per second
	int max_acpred_mbs;          ///< percentage
	int max_vbv_size;            ///< max vbv size (bits) 16368 bits
	int max_video_packet_length; ///< bits
	int max_bitrate;             ///< bits per second
	int vbv_peakrate;            ///< max bits over anyone second period; 0=don't care
	int dxn_max_bframes;         ///< dxn: max consecutive bframes
	unsigned int flags;          ///< flags for allowed options/dxn note the definitions for PROFILE_S and PROFILE_AS
} profile_t;

// Code taken from XviD VfW source for profile support

/* default vbv_occupancy is (64/170)*vbv_buffer_size */

static const profile_t profiles[] =
{
	/*   name               p@l    w    h    fps  obj Tvmv  vmv     vcv  ac%   vbv        pkt     bps    vbv_peak dbf  flags */
	/* unrestricted profile (default) */
	{ "unrestricted",  0x00,    0,   0,  0,  0,    0,    0,      0, 100,   0*16368,    -1,       0,        0, -1, 0xffffffff & ~PROFILE_DXN },

	{ "sp0",           0x08,  176, 144, 15,  1,  198,   99,   1485, 100,  10*16368,  2048,   64000,        0, -1, PROFILE_S },
	/* simple@l0: max f_code=1, intra_dc_vlc_threshold=0 */
	/* if ac preidition is used, adaptive quantization must not be used */
	/* <=qcif must be used */
	{ "sp1",           0x01,  176, 144, 15,  4,  198,   99,   1485, 100,  10*16368,  2048,   64000,        0, -1, PROFILE_S|PROFILE_ADAPTQUANT },
	{ "sp2",           0x02,  352, 288, 15,  4,  792,  396,   5940, 100,  40*16368,  4096,  128000,        0, -1, PROFILE_S|PROFILE_ADAPTQUANT },
	{ "sp3",           0x03,  352, 288, 15,  4,  792,  396,  11880, 100,  40*16368,  8192,  384000,        0, -1, PROFILE_S|PROFILE_ADAPTQUANT },
	/* From ISO/IEC 14496-2:2004/FPDAM 2: New Levels for Simple Profile */
	{ "sp4a",          0x04,  640, 480, 30,  4, 2400, 1200,  36000, 100,  80*16368, 16384, 4000000,        0, -1, PROFILE_S|PROFILE_ADAPTQUANT },
	{ "sp5",           0x05,  720, 576, 30,  4, 3240, 1620,  40500, 100, 112*16368, 16384, 8000000,        0, -1, PROFILE_S|PROFILE_ADAPTQUANT },
	/* From ISO/IEC 14496-2:2004/FPDAM 4: Simple profile level 6 */
	{ "sp6",           0x06, 1280, 720, 30,  4, 7200, 3600, 108000, 100, 248*16368, 16384,12000000,        0, -1, PROFILE_S|PROFILE_ADAPTQUANT },

	{ "asp0",          0xf0,  176, 144, 30,  1,  297,   99,   2970, 100,  10*16368,  2048,  128000,        0, -1, PROFILE_AS },
	{ "asp1",          0xf1,  176, 144, 30,  4,  297,   99,   2970, 100,  10*16368,  2048,  128000,        0, -1, PROFILE_AS },
	{ "asp2",          0xf2,  352, 288, 15,  4, 1188,  396,   5940, 100,  40*16368,  4096,  384000,        0, -1, PROFILE_AS },
	{ "asp3",          0xf3,  352, 288, 30,  4, 1188,  396,  11880, 100,  40*16368,  4096,  768000,        0, -1, PROFILE_AS },
	/*  ISMA Profile 1, (ASP) @ L3b (CIF, 1.5 Mb/s) CIF(352x288), 30fps, 1.5Mbps max ??? */
	{ "asp4",          0xf4,  352, 576, 30,  4, 2376,  792,  23760,  50,  80*16368,  8192, 3000000,        0, -1, PROFILE_AS },
	{ "asp5",          0xf5,  720, 576, 30,  4, 4860, 1620,  48600,  25, 112*16368, 16384, 8000000,        0, -1, PROFILE_AS },

	//	information provided by DivXNetworks, USA.
	//  "DivX Certified Profile Compatibility v1.1", February 2005
	{ "dxnhandheld",   0x00,  176, 144, 15,  1,  198,   99,   1485, 100,   32*8192,    -1,  537600,   800000,  0, PROFILE_ADAPTQUANT|PROFILE_DXN },
	{ "dxnportntsc",   0x00,  352, 240, 30,  1,  990,  330,  36000, 100,  384*8192,    -1, 4854000,  8000000,  1, PROFILE_4MV|PROFILE_ADAPTQUANT|PROFILE_BVOP|PROFILE_DXN },
	{ "dxnportpal",    0x00,  352, 288, 25,  1, 1188,  396,  36000, 100,  384*8192,    -1, 4854000,  8000000,  1, PROFILE_4MV|PROFILE_ADAPTQUANT|PROFILE_BVOP|PROFILE_DXN },
	{ "dxnhtntsc",     0x00,  720, 480, 30,  1, 4050, 1350,  40500, 100,  384*8192,    -1, 4854000,  8000000,  1, PROFILE_4MV|PROFILE_ADAPTQUANT|PROFILE_BVOP|PROFILE_INTERLACE|PROFILE_DXN },
	{ "dxnhtpal",      0x00,  720, 576, 25,  1, 4860, 1620,  40500, 100,  384*8192,    -1, 4854000,  8000000,  1, PROFILE_4MV|PROFILE_ADAPTQUANT|PROFILE_BVOP|PROFILE_INTERLACE|PROFILE_DXN },
	{ "dxnhdtv",       0x00, 1280, 720, 30,  1,10800, 3600, 108000, 100,  768*8192,    -1, 9708400, 16000000,  2, PROFILE_4MV|PROFILE_ADAPTQUANT|PROFILE_BVOP|PROFILE_INTERLACE|PROFILE_DXN },

	{ NULL,            0x00,    0,   0,  0,  0,    0,    0,      0,   0,         0,     0,       0,        0,  0, 0x00000000 },
};

/**
 * \brief return the pointer to a chosen profile
 * \param str the profile name
 * \return pointer of the appropriate profiles array entry or NULL for a mistyped profile name
 */
static const profile_t *profileFromName(const char *str)
{
	profile_t *cur = profiles;
	while (cur->name && strcasecmp(cur->name, str)) cur++;
	if(!cur->name) return NULL;
	return cur;
}

/*****************************************************************************
 * Configuration options
 ****************************************************************************/

static int xvidenc_bitrate = 0;
static int xvidenc_pass = 0;
static float xvidenc_quantizer = 0;

static int xvidenc_packed = 0;
static int xvidenc_closed_gop = 1;
static int xvidenc_interlaced = 0;
static int xvidenc_quarterpel = 0;
static int xvidenc_gmc = 0;
static int xvidenc_trellis = 1;
static int xvidenc_cartoon = 0;
static int xvidenc_hqacpred = 1;
static int xvidenc_chromame = 1;
static int xvidenc_chroma_opt = 0;
static int xvidenc_vhq = 1;
static int xvidenc_bvhq = 1;
static int xvidenc_motion = 6;
static int xvidenc_turbo = 0;
static int xvidenc_stats = 0;
static int xvidenc_max_key_interval = 0; /* Let xvidcore set a 10s interval by default */
static int xvidenc_frame_drop_ratio = 0;
static int xvidenc_greyscale = 0;
static int xvidenc_luminance_masking = 0;
static int xvidenc_debug = 0;
static int xvidenc_psnr = 0;

static int xvidenc_max_bframes = 2;
static int xvidenc_num_threads = 0;
static int xvidenc_bquant_ratio = 150;
static int xvidenc_bquant_offset = 100;
static int xvidenc_bframe_threshold = 0;

static int xvidenc_min_quant[3] = {2, 2, 2};
static int xvidenc_max_quant[3] = {31, 31, 31};
static char *xvidenc_intra_matrix_file = NULL;
static char *xvidenc_inter_matrix_file = NULL;
static char *xvidenc_quant_method = NULL;

static int xvidenc_cbr_reaction_delay_factor = 0;
static int xvidenc_cbr_averaging_period = 0;
static int xvidenc_cbr_buffer = 0;

static int xvidenc_vbr_keyframe_boost = 0;
static int xvidenc_vbr_overflow_control_strength = 5;
static int xvidenc_vbr_curve_compression_high = 0;
static int xvidenc_vbr_curve_compression_low = 0;
static int xvidenc_vbr_max_overflow_improvement = 5;
static int xvidenc_vbr_max_overflow_degradation = 5;
static int xvidenc_vbr_kfreduction = 0;
static int xvidenc_vbr_kfthreshold = 0;
static int xvidenc_vbr_container_frame_overhead = 24; /* mencoder uses AVI container */

static int xvidenc_vbv_size = 0;
static int xvidenc_vbv_initial = 0;
static int xvidenc_vbv_maxrate = 0;

// commandline profile option string - default to unrestricted
static char *xvidenc_profile = "unrestricted";

static char *xvidenc_par = NULL;
static int xvidenc_par_width = 0;
static int xvidenc_par_height = 0;
static float xvidenc_dar_aspect = 0.0f;
static int xvidenc_autoaspect = 0;

static char *xvidenc_zones = NULL; // zones string

const m_option_t xvidencopts_conf[] =
{
	/* Standard things mencoder should be able to treat directly */
	{"bitrate", &xvidenc_bitrate, CONF_TYPE_INT, 0, 0, 0, NULL},
	{"pass", &xvidenc_pass, CONF_TYPE_INT, CONF_RANGE, 1, 2, NULL},
	{"fixed_quant", &xvidenc_quantizer, CONF_TYPE_FLOAT, CONF_RANGE, 1, 31, NULL},

	/* Features */
	{"quant_type", &xvidenc_quant_method, CONF_TYPE_STRING, 0, 0, 0, NULL},
	{"me_quality", &xvidenc_motion, CONF_TYPE_INT, CONF_RANGE, 0, 6, NULL},
	{"chroma_me", &xvidenc_chromame, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"nochroma_me", &xvidenc_chromame, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"chroma_opt", &xvidenc_chroma_opt, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"nochroma_opt", &xvidenc_chroma_opt, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"vhq", &xvidenc_vhq, CONF_TYPE_INT, CONF_RANGE, 0, 4, NULL},
	{"bvhq", &xvidenc_bvhq, CONF_TYPE_INT, CONF_RANGE, 0, 1, NULL},
	{"max_bframes", &xvidenc_max_bframes, CONF_TYPE_INT, CONF_RANGE, 0, 20, NULL},
	{"threads", &xvidenc_num_threads, CONF_TYPE_INT, 0, 0, 0, NULL},
	{"bquant_ratio", &xvidenc_bquant_ratio, CONF_TYPE_INT, CONF_RANGE, 0, 200, NULL},
	{"bquant_offset", &xvidenc_bquant_offset, CONF_TYPE_INT, CONF_RANGE, 0, 200, NULL},
	{"bf_threshold", &xvidenc_bframe_threshold, CONF_TYPE_INT, CONF_RANGE, -255, 255, NULL},
	{"qpel", &xvidenc_quarterpel, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"noqpel", &xvidenc_quarterpel, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"gmc", &xvidenc_gmc, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"nogmc", &xvidenc_gmc, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"trellis", &xvidenc_trellis, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"notrellis", &xvidenc_trellis, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"packed", &xvidenc_packed, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"nopacked", &xvidenc_packed, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"closed_gop", &xvidenc_closed_gop, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"noclosed_gop", &xvidenc_closed_gop, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"interlacing", &xvidenc_interlaced, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"nointerlacing", &xvidenc_interlaced, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"cartoon", &xvidenc_cartoon, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"nocartoon", &xvidenc_cartoon, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"hq_ac", &xvidenc_hqacpred, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"nohq_ac", &xvidenc_hqacpred, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"frame_drop_ratio", &xvidenc_frame_drop_ratio, CONF_TYPE_INT, CONF_RANGE, 0, 100, NULL},
	{"max_key_interval", &xvidenc_max_key_interval, CONF_TYPE_INT, CONF_MIN, 0, 0, NULL},
	{"greyscale", &xvidenc_greyscale, CONF_TYPE_FLAG, 0, 0, 1, NULL}, /* kept for backward compatibility */
	{"grayscale", &xvidenc_greyscale, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"nogreyscale", &xvidenc_greyscale, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"lumi_mask", &xvidenc_luminance_masking, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"nolumi_mask", &xvidenc_luminance_masking, CONF_TYPE_FLAG, 0, 1, 0, NULL},
	{"turbo", &xvidenc_turbo, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"debug", &xvidenc_debug, CONF_TYPE_INT , 0 ,0,-1,NULL},
	{"stats", &xvidenc_stats, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"psnr",  &xvidenc_psnr , CONF_TYPE_FLAG, 0, 0, 1, NULL},


	/* section [quantizer] */
	{"min_iquant", &xvidenc_min_quant[0], CONF_TYPE_INT, CONF_RANGE, 1, 31, NULL},
	{"max_iquant", &xvidenc_max_quant[0], CONF_TYPE_INT, CONF_RANGE, 1, 31, NULL},
	{"min_pquant", &xvidenc_min_quant[1], CONF_TYPE_INT, CONF_RANGE, 1, 31, NULL},
	{"max_pquant", &xvidenc_max_quant[1], CONF_TYPE_INT, CONF_RANGE, 1, 31, NULL},
	{"min_bquant", &xvidenc_min_quant[2], CONF_TYPE_INT, CONF_RANGE, 1, 31, NULL},
	{"max_bquant", &xvidenc_max_quant[2], CONF_TYPE_INT, CONF_RANGE, 1, 31, NULL},
	{"quant_intra_matrix", &xvidenc_intra_matrix_file, CONF_TYPE_STRING, 0, 0, 100, NULL},
	{"quant_inter_matrix", &xvidenc_inter_matrix_file, CONF_TYPE_STRING, 0, 0, 100, NULL},

	/* section [cbr] */
	{"rc_reaction_delay_factor", &xvidenc_cbr_reaction_delay_factor, CONF_TYPE_INT, CONF_RANGE, 0, 100, NULL},
	{"rc_averaging_period", &xvidenc_cbr_averaging_period, CONF_TYPE_INT, CONF_MIN, 0, 0, NULL},
	{"rc_buffer", &xvidenc_cbr_buffer, CONF_TYPE_INT, CONF_MIN, 0, 0, NULL},

	/* section [vbr] */
	{"keyframe_boost", &xvidenc_vbr_keyframe_boost, CONF_TYPE_INT, CONF_RANGE, 0, 100, NULL},
	{"curve_compression_high", &xvidenc_vbr_curve_compression_high, CONF_TYPE_INT, CONF_RANGE, 0, 100, NULL},
	{"curve_compression_low", &xvidenc_vbr_curve_compression_low, CONF_TYPE_INT, CONF_RANGE, 0, 100, NULL},
	{"overflow_control_strength", &xvidenc_vbr_overflow_control_strength, CONF_TYPE_INT, CONF_RANGE, 0, 100, NULL},
	{"max_overflow_improvement", &xvidenc_vbr_max_overflow_improvement, CONF_TYPE_INT, CONF_RANGE, 0, 100, NULL},
	{"max_overflow_degradation", &xvidenc_vbr_max_overflow_degradation, CONF_TYPE_INT, CONF_RANGE, 0, 100, NULL},
	{"kfreduction", &xvidenc_vbr_kfreduction, CONF_TYPE_INT, CONF_RANGE, 0, 100, NULL},
	{"kfthreshold", &xvidenc_vbr_kfthreshold, CONF_TYPE_INT, CONF_MIN, 0, 0, NULL},
	{"container_frame_overhead", &xvidenc_vbr_container_frame_overhead, CONF_TYPE_INT, CONF_MIN, 0, 0, NULL},

	/* section [vbv] */
	{"vbv_bufsize", &xvidenc_vbv_size, CONF_TYPE_INT, CONF_MIN, 0, 0, NULL},
	{"vbv_initial", &xvidenc_vbv_initial, CONF_TYPE_INT, CONF_MIN, 0, 0, NULL},
	{"vbv_maxrate", &xvidenc_vbv_maxrate, CONF_TYPE_INT, CONF_MIN, 0, 0, NULL},

	/* Section Aspect Ratio */
	{"par", &xvidenc_par, CONF_TYPE_STRING, 0, 0, 0, NULL},
	{"par_width", &xvidenc_par_width, CONF_TYPE_INT, CONF_RANGE, 0, 255, NULL},
	{"par_height", &xvidenc_par_height, CONF_TYPE_INT, CONF_RANGE, 0, 255, NULL},
	{"aspect", &xvidenc_dar_aspect, CONF_TYPE_FLOAT, CONF_RANGE, 0.1, 9.99, NULL},
	{"autoaspect", &xvidenc_autoaspect, CONF_TYPE_FLAG, 0, 0, 1, NULL},
	{"noautoaspect", &xvidenc_autoaspect, CONF_TYPE_FLAG, 0, 1, 0, NULL},

	/* Section Zones */
	{"zones", &xvidenc_zones, CONF_TYPE_STRING, 0, 0, 0, NULL},

	/* section profiles */
	{"profile", &xvidenc_profile, CONF_TYPE_STRING, 0, 0, 0, NULL},

	/* End of the config array */
	{NULL, 0, 0, 0, 0, 0, NULL}
};

/*****************************************************************************
 * Module private data
 ****************************************************************************/

typedef struct xvid_mplayer_module_t
{
	/* Instance related global vars */
	void *instance;
	xvid_gbl_init_t      init;
	xvid_enc_create_t    create;
	xvid_enc_frame_t     frame;
	xvid_plugin_single_t onepass;
	xvid_plugin_2pass1_t pass1;
	xvid_plugin_2pass2_t pass2;

	/* This data must survive local block scope, so here it is */
	xvid_enc_plugin_t    plugins[7];
	xvid_enc_zone_t      zones[MAX_ZONES];

	/* MPEG4 stream buffer */
	muxer_stream_t *mux;

	/* Stats accumulators */
	int frames;
	long long sse_y;
	long long sse_u;
	long long sse_v;

	/* Min & Max PSNR */
	int min_sse_y;
	int min_sse_u;
	int min_sse_v;
	int min_framenum;
	int max_sse_y;
	int max_sse_u;
	int max_sse_v;
	int max_framenum;

	int pixels;

	/* DAR/PAR and all that thingies */
	int d_width;
	int d_height;
	FILE *fvstats;
} xvid_mplayer_module_t;

static int dispatch_settings(xvid_mplayer_module_t *mod);
static int set_create_struct(xvid_mplayer_module_t *mod);
static int set_frame_struct(xvid_mplayer_module_t *mod, mp_image_t *mpi);
static void update_stats(xvid_mplayer_module_t *mod, xvid_enc_stats_t *stats);
static void print_stats(xvid_mplayer_module_t *mod);
static void flush_internal_buffers(xvid_mplayer_module_t *mod);
static const char *par_string(int parcode);
static const char *errorstring(int err);

/*****************************************************************************
 * Video Filter API function definitions
 ****************************************************************************/

/*============================================================================
 * config
 *==========================================================================*/

static int
config(struct vf_instance *vf,
       int width, int height, int d_width, int d_height,
       unsigned int flags, unsigned int outfmt)
{
	int err;
	xvid_mplayer_module_t *mod = (xvid_mplayer_module_t *)vf->priv;

	/* Complete the muxer initialization */
	mod->mux->bih->biWidth = width;
	mod->mux->bih->biHeight = height;
	mod->mux->bih->biSizeImage =
		mod->mux->bih->biWidth * mod->mux->bih->biHeight * 3 / 2;
	mod->mux->aspect = (float)d_width/d_height;

	/* Message the FourCC type */
	mp_msg(MSGT_MENCODER, MSGL_INFO,
	       "videocodec: XviD (%dx%d fourcc=%x [%.4s])\n",
	       width, height, mod->mux->bih->biCompression,
	       (char *)&mod->mux->bih->biCompression);

	/* Total number of pixels per frame required for PSNR */
	mod->pixels = mod->mux->bih->biWidth*mod->mux->bih->biHeight;

	/*--------------------------------------------------------------------
	 * Dispatch all module settings to XviD structures
	 *------------------------------------------------------------------*/

	mod->d_width = d_width;
	mod->d_height = d_height;

	if(dispatch_settings(mod) == BAD)
		return BAD;

	/*--------------------------------------------------------------------
	 * Set remaining information in the xvid_enc_create_t structure
	 *------------------------------------------------------------------*/

	if(set_create_struct(mod) == BAD)
		return BAD;

	/*--------------------------------------------------------------------
	 * Encoder instance creation
	 *------------------------------------------------------------------*/

	err = xvid_encore(NULL, XVID_ENC_CREATE, &mod->create, NULL);

	if(err<0) {
		mp_msg(MSGT_MENCODER, MSGL_ERR,
		       "xvid: xvidcore returned a '%s' error\n", errorstring(err));
		return BAD;
	}

	/* Store the encoder instance into the private data */
	mod->instance = mod->create.handle;

	mod->mux->decoder_delay = mod->create.max_bframes ? 1 : 0;

	return FINE;
}

/*============================================================================
 * uninit
 *==========================================================================*/

static void
uninit(struct vf_instance *vf)
{

	xvid_mplayer_module_t *mod = (xvid_mplayer_module_t *)vf->priv;

	/* Destroy xvid instance */
	xvid_encore(mod->instance, XVID_ENC_DESTROY, NULL, NULL);

	/* Display stats (if any) */
	print_stats(mod);

	/* Close PSNR file if ever opened */
	if (mod->fvstats) {
		fclose(mod->fvstats);
		mod->fvstats = NULL;
	}

        /* Free allocated memory */
	free(mod->frame.quant_intra_matrix);
	free(mod->frame.quant_inter_matrix);
	free(mod->mux->bih);
	free(vf->priv);
	vf->priv=NULL;

	return;
}

/*============================================================================
 * control
 *==========================================================================*/

static int
control(struct vf_instance *vf, int request, void* data)
{
xvid_mplayer_module_t *mod = (xvid_mplayer_module_t *)vf->priv;

	switch(request){
	    case  VFCTRL_FLUSH_FRAMES:
	    if(mod)/*paranoid*/
                flush_internal_buffers(mod);
	    break;
	}
	return CONTROL_UNKNOWN;
}

/*============================================================================
 * query_format
 *==========================================================================*/

static int
query_format(struct vf_instance *vf, unsigned int fmt)
{
	switch(fmt){
	case IMGFMT_YV12:
	case IMGFMT_IYUV:
	case IMGFMT_I420:
		return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW;
	case IMGFMT_YUY2:
	case IMGFMT_UYVY:
		return VFCAP_CSP_SUPPORTED;
	}
	return BAD;
}

/*============================================================================
 * put_image
 *==========================================================================*/

static int
put_image(struct vf_instance *vf, mp_image_t *mpi, double pts)
{
	int size;
	xvid_enc_stats_t stats;
	xvid_mplayer_module_t *mod = (xvid_mplayer_module_t *)vf->priv;

	/* Prepare the stats */
	memset(&stats,0,sizeof( xvid_enc_stats_t));
	stats.version = XVID_VERSION;

	/* -------------------------------------------------------------------
	 * Set remaining information in the xvid_enc_frame_t structure
	 * NB: all the other struct members were initialized by
	 *     dispatch_settings
	 * -----------------------------------------------------------------*/

	if(set_frame_struct(mod, mpi) == BAD)
		return BAD;

	mod->frame.type = is_forced_key_frame(pts) || xvidenc_motion == 0 ?
		XVID_TYPE_IVOP : XVID_TYPE_AUTO;

	/* -------------------------------------------------------------------
	 * Encode the frame
	 * ---------------------------------------------------------------- */

	size = xvid_encore(mod->instance, XVID_ENC_ENCODE, &mod->frame, &stats);

	/* Analyse the returned value */
	if(size<0) {
		mp_msg(MSGT_MENCODER, MSGL_ERR,
		       "xvid: xvidcore returned a '%s' error\n", errorstring(size));
		return BAD;
	}

	/* If size is == 0, we're done with that frame */
	if(size == 0) {
		++mod->mux->encoder_delay;
		return FINE;
	}

	/* xvidcore returns stats about encoded frame in an asynchronous way
	 * accumulate these stats */
	update_stats(mod, &stats);

	/* xvidcore outputed bitstream -- mux it */
	muxer_write_chunk(mod->mux,
			  size,
			  (mod->frame.out_flags & XVID_KEYFRAME)?0x10:0, MP_NOPTS_VALUE, MP_NOPTS_VALUE);

	return FINE;
}

/*============================================================================
 * vf_open
 *==========================================================================*/

static int
vf_open(vf_instance_t *vf, char* args)
{
	xvid_mplayer_module_t *mod;
	xvid_gbl_init_t xvid_gbl_init;
	xvid_gbl_info_t xvid_gbl_info;

	/* Setting libmpcodec module API pointers */
	vf->config       = config;
	vf->default_caps = VFCAP_CONSTANT;
	vf->control      = control;
	vf->uninit       = uninit;
	vf->query_format = query_format;
	vf->put_image    = put_image;

	/* Allocate the private part of the codec module */
	vf->priv = malloc(sizeof(xvid_mplayer_module_t));
	mod = (xvid_mplayer_module_t*)vf->priv;

	if(mod == NULL) {
		mp_msg(MSGT_MENCODER,MSGL_ERR,
		       "xvid: memory allocation failure (private data)\n");
		return BAD;
	}

	/* Initialize the module to zeros */
	memset(mod, 0, sizeof(xvid_mplayer_module_t));
	mod->min_sse_y = mod->min_sse_u = mod->min_sse_v = INT_MAX;
	mod->max_sse_y = mod->max_sse_u = mod->max_sse_v = INT_MIN;

	/* Bind the Muxer */
	mod->mux = (muxer_stream_t*)args;

	/* Initialize muxer BITMAP header */
	mod->mux->bih = calloc(1, sizeof(*mod->mux->bih));

	if(mod->mux->bih  == NULL) {
		mp_msg(MSGT_MENCODER,MSGL_ERR,
		       "xvid: memory allocation failure (BITMAP header)\n");
		return BAD;
	}

	mod->mux->bih->biSize = sizeof(*mod->mux->bih);
	mod->mux->bih->biWidth = 0;
	mod->mux->bih->biHeight = 0;
	mod->mux->bih->biPlanes = 1;
	mod->mux->bih->biBitCount = 12;
	mod->mux->bih->biCompression = mmioFOURCC('X','V','I','D');

	/* Retrieve information about the host XviD library */
	memset(&xvid_gbl_info, 0, sizeof(xvid_gbl_info_t));
	xvid_gbl_info.version = XVID_VERSION;

	if (xvid_global(NULL, XVID_GBL_INFO, &xvid_gbl_info, NULL) < 0) {
		mp_msg(MSGT_MENCODER,MSGL_WARN, "xvid: could not get information about the library\n");
	} else {
		mp_msg(MSGT_MENCODER,MSGL_INFO, "xvid: using library version %d.%d.%d (build %s)\n",
		       XVID_VERSION_MAJOR(xvid_gbl_info.actual_version),
		       XVID_VERSION_MINOR(xvid_gbl_info.actual_version),
		       XVID_VERSION_PATCH(xvid_gbl_info.actual_version),
		       xvid_gbl_info.build);
	}

	/* Initialize the xvid_gbl_init structure */
	memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init_t));
	xvid_gbl_init.version = XVID_VERSION;
	xvid_gbl_init.debug = xvidenc_debug;

	/* Initialize the xvidcore library */
	if (xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL) < 0) {
		mp_msg(MSGT_MENCODER,MSGL_ERR, "xvid: initialisation failure\n");
		return BAD;
	}

	return FINE;
}

/*****************************************************************************
 * Helper functions
 ****************************************************************************/

static void *read_matrix(unsigned char *filename);

static int dispatch_settings(xvid_mplayer_module_t *mod)
{
	xvid_enc_create_t *create     = &mod->create;
	xvid_enc_frame_t  *frame      = &mod->frame;
	xvid_plugin_single_t *onepass = &mod->onepass;
	xvid_plugin_2pass2_t *pass2   = &mod->pass2;
	AVRational ar;

	const int motion_presets[7] =
		{
			0,
			0,
			0,
			0,
			XVID_ME_HALFPELREFINE16,
			XVID_ME_HALFPELREFINE16 | XVID_ME_ADVANCEDDIAMOND16,
			XVID_ME_HALFPELREFINE16 | XVID_ME_EXTSEARCH16 |
			XVID_ME_HALFPELREFINE8  | XVID_ME_USESQUARES16
		};

	//profile is unrestricted as default
	const profile_t *selected_profile =  profileFromName("unrestricted");
	if(xvidenc_profile)
		selected_profile = profileFromName(xvidenc_profile);
	if(!selected_profile)
	{
		mp_msg(MSGT_MENCODER,MSGL_ERR,
			"xvid:[ERROR] \"%s\" is an invalid profile name\n", xvidenc_profile);
		return BAD;
	}

	/* -------------------------------------------------------------------
	 * Dispatch all settings having an impact on the "create" structure
	 * This includes plugins as they are passed to encore through the
	 * create structure
	 * -----------------------------------------------------------------*/

	/* -------------------------------------------------------------------
	 * The create structure
	 * ---------------------------------------------------------------- */

	create->global = 0;

        if(xvidenc_psnr)
	    xvidenc_stats = 1;

	if(xvidenc_stats)
		create->global |= XVID_GLOBAL_EXTRASTATS_ENABLE;

	create->num_zones = 0;
	create->zones = NULL;
	create->num_plugins = 0;
	create->plugins = NULL;
	create->num_threads = xvidenc_num_threads;

	if( (selected_profile->flags & PROFILE_BVOP) &&
		/* dxn: prevent bframes usage if interlacing is selected */
		!((selected_profile->flags & PROFILE_DXN) && xvidenc_interlaced) )
	{
	create->max_bframes = xvidenc_max_bframes;
	create->bquant_ratio = xvidenc_bquant_ratio;
	create->bquant_offset = xvidenc_bquant_offset;
		if(xvidenc_packed)
			create->global |= XVID_GLOBAL_PACKED;
		if(xvidenc_closed_gop)
			create->global |= XVID_GLOBAL_CLOSED_GOP;

		/* dxn: restrict max bframes, require closed gop
			and require packed b-frames */
		if(selected_profile->flags & PROFILE_DXN)
		{
			if(create->max_bframes > selected_profile->dxn_max_bframes)
				create->max_bframes = selected_profile->dxn_max_bframes;
			create->global |= XVID_GLOBAL_CLOSED_GOP;
			create->global |= XVID_GLOBAL_PACKED;
		}
	}
	else
		create->max_bframes = 0;

#if XVID_API >= XVID_MAKE_API(4,1)
	/* dxn: always write divx5 userdata */
	if(selected_profile->flags & PROFILE_DXN)
		create->global |= XVID_GLOBAL_DIVX5_USERDATA;
#endif

	create->max_key_interval = xvidenc_max_key_interval;
	create->frame_drop_ratio = xvidenc_frame_drop_ratio;
	create->min_quant[0] = xvidenc_min_quant[0];
	create->min_quant[1] = xvidenc_min_quant[1];
	create->min_quant[2] = xvidenc_min_quant[2];
	create->max_quant[0] = xvidenc_max_quant[0];
	create->max_quant[1] = xvidenc_max_quant[1];
	create->max_quant[2] = xvidenc_max_quant[2];


	/* -------------------------------------------------------------------
	 * The single pass plugin
	 * ---------------------------------------------------------------- */

	if (xvidenc_bitrate > 16000) onepass->bitrate = xvidenc_bitrate;
	else onepass->bitrate = xvidenc_bitrate*1000;
	onepass->reaction_delay_factor = xvidenc_cbr_reaction_delay_factor;
	onepass->averaging_period = xvidenc_cbr_averaging_period;
	onepass->buffer = xvidenc_cbr_buffer;

	/* -------------------------------------------------------------------
	 * The pass2 plugin
	 * ---------------------------------------------------------------- */

	pass2->keyframe_boost = xvidenc_vbr_keyframe_boost;
	pass2->overflow_control_strength = xvidenc_vbr_overflow_control_strength;
	pass2->curve_compression_high = xvidenc_vbr_curve_compression_high;
	pass2->curve_compression_low = xvidenc_vbr_curve_compression_low;
	pass2->max_overflow_improvement = xvidenc_vbr_max_overflow_improvement;
	pass2->max_overflow_degradation = xvidenc_vbr_max_overflow_degradation;
	pass2->kfreduction = xvidenc_vbr_kfreduction;
	pass2->kfthreshold = xvidenc_vbr_kfthreshold;
	pass2->container_frame_overhead = xvidenc_vbr_container_frame_overhead;

	/* VBV */

#if XVID_API >= XVID_MAKE_API(4,1)
	if(xvidenc_vbv_size > 0) {
		if(selected_profile->max_vbv_size > 0 && xvidenc_vbv_size > selected_profile->max_vbv_size) {
			mp_msg(MSGT_MENCODER,MSGL_ERR,
				"xvid:[ERROR] Selected profile limits vbv_bufsize <= %d\n", selected_profile->max_vbv_size);
			return BAD;
		}

		pass2->vbv_size = xvidenc_vbv_size;
	} else {
		pass2->vbv_size = selected_profile->max_vbv_size;
	}

	if(xvidenc_vbv_initial > 0) {
		if(xvidenc_vbv_initial > pass2->vbv_size) {
			mp_msg(MSGT_MENCODER,MSGL_ERR,
				"xvid:[ERROR] vbv_initial must be <= vbv_bufsize\n");
			return BAD;
		}

		pass2->vbv_initial = xvidenc_vbv_initial;
	} else {
		pass2->vbv_initial = (pass2->vbv_size*3)>>2; /* 75% */
	}

	if(xvidenc_vbv_maxrate > 0) {
		if(selected_profile->max_bitrate > 0 && xvidenc_vbv_maxrate > selected_profile->max_bitrate) {
			mp_msg(MSGT_MENCODER,MSGL_ERR,
				"xvid:[ERROR] Selected profile limits vbv_maxrate <= %d\n", selected_profile->max_bitrate);
			return BAD;
		}

		pass2->vbv_maxrate = xvidenc_vbv_maxrate;
	} else {
		pass2->vbv_maxrate = selected_profile->max_bitrate;
	}

	pass2->vbv_peakrate = selected_profile->vbv_peakrate; /* Useless */
#endif

	create->profile = selected_profile->id;

	/* -------------------------------------------------------------------
	 * The frame structure
	 * ---------------------------------------------------------------- */
	frame->vol_flags = 0;
	frame->vop_flags = 0;
	frame->motion    = 0;

	frame->vop_flags |= XVID_VOP_HALFPEL;
	frame->motion    |= motion_presets[xvidenc_motion];

	if(xvidenc_stats)
		frame->vol_flags |= XVID_VOL_EXTRASTATS;

	if(xvidenc_greyscale)
		frame->vop_flags |= XVID_VOP_GREYSCALE;

	if(xvidenc_cartoon) {
		frame->vop_flags |= XVID_VOP_CARTOON;
		frame->motion |= XVID_ME_DETECT_STATIC_MOTION;
	}

	// MPEG quantisation is only supported in ASP and unrestricted profiles
	if((selected_profile->flags & PROFILE_MPEGQUANT) &&
		(xvidenc_quant_method != NULL) &&
		!strcasecmp(xvidenc_quant_method, "mpeg"))
	{
		frame->vol_flags |= XVID_VOL_MPEGQUANT;
	if(xvidenc_intra_matrix_file != NULL) {
		frame->quant_intra_matrix = (unsigned char*)read_matrix(xvidenc_intra_matrix_file);
		if(frame->quant_intra_matrix != NULL) {
			mp_msg(MSGT_MENCODER, MSGL_INFO, "xvid: Loaded Intra matrix (switching to mpeg quantization type)\n");
			free(xvidenc_quant_method);
			xvidenc_quant_method = strdup("mpeg");
		}
	}
	if(xvidenc_inter_matrix_file != NULL) {
		frame->quant_inter_matrix = read_matrix(xvidenc_inter_matrix_file);
		if(frame->quant_inter_matrix) {
			mp_msg(MSGT_MENCODER, MSGL_INFO, "\nxvid: Loaded Inter matrix (switching to mpeg quantization type)\n");
			free(xvidenc_quant_method);
			xvidenc_quant_method = strdup("mpeg");
		}
	}
	}
	if(xvidenc_quarterpel && (selected_profile->flags & PROFILE_QPEL)) {
		frame->vol_flags |= XVID_VOL_QUARTERPEL;
		frame->motion    |= XVID_ME_QUARTERPELREFINE16;
		frame->motion    |= XVID_ME_QUARTERPELREFINE8;
	}
	if(xvidenc_gmc && (selected_profile->flags & PROFILE_GMC)) {
		frame->vol_flags |= XVID_VOL_GMC;
		frame->motion    |= XVID_ME_GME_REFINE;
	}
	if(xvidenc_interlaced && (selected_profile->flags & PROFILE_INTERLACE)) {
		frame->vol_flags |= XVID_VOL_INTERLACING;
	}
	if(xvidenc_trellis) {
		frame->vop_flags |= XVID_VOP_TRELLISQUANT;
	}
	if(xvidenc_hqacpred) {
		frame->vop_flags |= XVID_VOP_HQACPRED;
	}
	if(xvidenc_chroma_opt) {
		frame->vop_flags |= XVID_VOP_CHROMAOPT;
	}
	if((xvidenc_motion > 4) && (selected_profile->flags & PROFILE_4MV)) {
		frame->vop_flags |= XVID_VOP_INTER4V;
	}
	if(xvidenc_chromame) {
		frame->motion |= XVID_ME_CHROMA_PVOP;
		frame->motion |= XVID_ME_CHROMA_BVOP;
	}
	if(xvidenc_vhq >= 1) {
		frame->vop_flags |= XVID_VOP_MODEDECISION_RD;
	}
	if(xvidenc_vhq >= 2) {
		frame->motion |= XVID_ME_HALFPELREFINE16_RD;
		frame->motion |= XVID_ME_QUARTERPELREFINE16_RD;
	}
	if(xvidenc_vhq >= 3) {
		frame->motion |= XVID_ME_HALFPELREFINE8_RD;
		frame->motion |= XVID_ME_QUARTERPELREFINE8_RD;
		frame->motion |= XVID_ME_CHECKPREDICTION_RD;
	}
	if(xvidenc_vhq >= 4) {
		frame->motion |= XVID_ME_EXTSEARCH_RD;
	}
	if(xvidenc_bvhq >= 1) {
#if XVID_API >= XVID_MAKE_API(4,1)
		frame->vop_flags |= XVID_VOP_RD_BVOP;
#endif
	}
	if(xvidenc_turbo) {
		frame->motion |= XVID_ME_FASTREFINE16;
		frame->motion |= XVID_ME_FASTREFINE8;
		frame->motion |= XVID_ME_SKIP_DELTASEARCH;
		frame->motion |= XVID_ME_FAST_MODEINTERPOLATE;
		frame->motion |= XVID_ME_BFRAME_EARLYSTOP;
	}

	/* motion level == 0 means no motion search which is equivalent to
	 * intra coding only */
	if(xvidenc_motion == 0) {
		frame->type = XVID_TYPE_IVOP;
	} else {
		frame->type = XVID_TYPE_AUTO;
	}

	frame->bframe_threshold = xvidenc_bframe_threshold;

	/* PAR related initialization */
	frame->par = XVID_PAR_11_VGA; /* Default */

	if( !(selected_profile->flags & PROFILE_DXN) )
	{
	if(xvidenc_dar_aspect > 0)
	    ar = av_d2q(xvidenc_dar_aspect * mod->mux->bih->biHeight / mod->mux->bih->biWidth, 255);
	else if(xvidenc_autoaspect)
	    ar = av_d2q((float)mod->d_width / mod->d_height * mod->mux->bih->biHeight / mod->mux->bih->biWidth, 255);
	else ar.num = ar.den = 0;

	if(ar.den != 0) {
		if(ar.num == 12 && ar.den == 11)
		    frame->par = XVID_PAR_43_PAL;
		else if(ar.num == 10 && ar.den == 11)
		    frame->par = XVID_PAR_43_NTSC;
		else if(ar.num == 16 && ar.den == 11)
		    frame->par = XVID_PAR_169_PAL;
		else if(ar.num == 40 && ar.den == 33)
		    frame->par = XVID_PAR_169_NTSC;
		else
		{
		    frame->par = XVID_PAR_EXT;
		    frame->par_width = ar.num;
		    frame->par_height= ar.den;
		}

	} else if(xvidenc_par != NULL) {
		if(strcasecmp(xvidenc_par, "pal43") == 0)
			frame->par = XVID_PAR_43_PAL;
		else if(strcasecmp(xvidenc_par, "pal169") == 0)
			frame->par = XVID_PAR_169_PAL;
		else if(strcasecmp(xvidenc_par, "ntsc43") == 0)
			frame->par = XVID_PAR_43_NTSC;
		else if(strcasecmp(xvidenc_par, "ntsc169") == 0)
			frame->par = XVID_PAR_169_NTSC;
		else if(strcasecmp(xvidenc_par, "ext") == 0)
			frame->par = XVID_PAR_EXT;

	if(frame->par == XVID_PAR_EXT) {
		if(xvidenc_par_width)
			frame->par_width = xvidenc_par_width;
		else
			frame->par_width = 1;

		if(xvidenc_par_height)
			frame->par_height = xvidenc_par_height;
		else
			frame->par_height = 1;
	}
	}

	/* Display par information */
	mp_msg(MSGT_MENCODER, MSGL_INFO, "xvid: par=%d/%d (%s), displayed=%dx%d, sampled=%dx%d\n",
			ar.num, ar.den, par_string(frame->par),
			mod->d_width, mod->d_height, mod->mux->bih->biWidth, mod->mux->bih->biHeight);
	}
	else
		mp_msg(MSGT_MENCODER, MSGL_INFO,
			"xvid: par=0/0 (vga11) forced by choosing a DXN profile\n");
	return FINE;
}

static int set_create_struct(xvid_mplayer_module_t *mod)
{
	int pass;
	int doZones = 0;
	xvid_enc_create_t *create    = &mod->create;

	// profile is unrestricted as default
	profile_t *selected_profile =  profileFromName("unrestricted");
	if(xvidenc_profile)
		selected_profile = profileFromName(xvidenc_profile);
	if(!selected_profile)
		return BAD;

	/* Most of the structure is initialized by dispatch settings, only a
	 * few things are missing  */
	create->version = XVID_VERSION;

	/* Width and Height */
	create->width  = mod->mux->bih->biWidth;
	create->height = mod->mux->bih->biHeight;

	/* Check resolution of video to be coded is within profile width/height
	   restrictions */
	if( ((selected_profile->width != 0) &&
		(mod->mux->bih->biWidth > selected_profile->width)) ||
		((selected_profile->height != 0) &&
		(mod->mux->bih->biHeight > selected_profile->height)) )
	{
		mp_msg(MSGT_MENCODER,MSGL_ERR,
			"xvid:[ERROR] resolution must be <= %dx%d for the chosen profile\n",
			selected_profile->width, selected_profile->height);
		return BAD;
	}

	/* FPS */
	create->fincr = mod->mux->h.dwScale;
	create->fbase = mod->mux->h.dwRate;

	// Check frame rate is within profile restrictions
	if( ((float)mod->mux->h.dwRate/(float)mod->mux->h.dwScale > (float)selected_profile->fps) &&
		(selected_profile->fps != 0))
	{
		mp_msg(MSGT_MENCODER,MSGL_WARN,
			"xvid:[WARNING] frame rate should be <= %d for the chosen profile\n",
			selected_profile->fps);
	}

	/* Encodings zones */
	memset(mod->zones, 0, sizeof(mod->zones));
	create->zones     = mod->zones;
	create->num_zones = 0;

	/* Plugins */
	memset(mod->plugins, 0, sizeof(mod->plugins));
	create->plugins     = mod->plugins;
	create->num_plugins = 0;

	/* -------------------------------------------------------------------
	 * Initialize and bind the right rate controller plugin
	 * ---------------------------------------------------------------- */

	/* First we try to sort out configuration conflicts */
	if(xvidenc_quantizer != 0 && (xvidenc_bitrate || xvidenc_pass)) {
		mp_msg(MSGT_MENCODER, MSGL_ERR,
		       "xvid: you can't mix Fixed Quantizer Rate Control"
		       " with other Rate Control mechanisms\n");
		return BAD;
	}

	if(xvidenc_bitrate != 0 && xvidenc_pass == 1) {
		mp_msg(MSGT_MENCODER, MSGL_WARN,
		       "xvid: bitrate setting is ignored during first pass\n");
	}

	/* Sort out which sort of pass we are supposed to do
	 * pass == 1<<0 CBR
	 * pass == 1<<1 Two pass first pass
	 * pass == 1<<2 Two pass second pass
	 * pass == 1<<3 Constant quantizer
	 */
#define MODE_CBR    (1<<0)
#define MODE_2PASS1 (1<<1)
#define MODE_2PASS2 (1<<2)
#define MODE_QUANT  (1<<3)

	pass = 0;

	if(xvidenc_bitrate != 0 && xvidenc_pass == 0)
		pass |= MODE_CBR;

	if(xvidenc_pass == 1)
		pass |= MODE_2PASS1;

	if(xvidenc_bitrate != 0 && xvidenc_pass == 2)
		pass |= MODE_2PASS2;

	if(xvidenc_quantizer != 0  && xvidenc_pass == 0)
		pass |= MODE_QUANT;

	/* We must be in at least one RC mode */
	if(pass == 0) {
		mp_msg(MSGT_MENCODER, MSGL_ERR,
		       "xvid: you must specify one or a valid combination of "
		       "'bitrate', 'pass', 'fixed_quant' settings\n");
		return BAD;
	}

	/* Sanity checking */
	if(pass != MODE_CBR    && pass != MODE_QUANT &&
	   pass != MODE_2PASS1 && pass != MODE_2PASS2) {
		mp_msg(MSGT_MENCODER, MSGL_ERR,
		       "xvid: this code should not be reached - fill a bug "
		       "report\n");
		return BAD;
	}

	/* This is a single pass encoding: either a CBR pass or a constant
	 * quantizer pass */
	if(pass == MODE_CBR  || pass == MODE_QUANT) {
		xvid_plugin_single_t *onepass = &mod->onepass;

		/* There is not much left to initialize after dispatch settings */
		onepass->version = XVID_VERSION;
		if (xvidenc_bitrate > 16000) onepass->bitrate = xvidenc_bitrate;
		else onepass->bitrate = xvidenc_bitrate*1000;

		/* Quantizer mode uses the same plugin, we have only to define
		 * a constant quantizer zone beginning at frame 0 */
		if(pass == MODE_QUANT) {
                        AVRational squant;
			squant = av_d2q(xvidenc_quantizer,128);

			create->zones[create->num_zones].mode      = XVID_ZONE_QUANT;
			create->zones[create->num_zones].frame     = 0;
			create->zones[create->num_zones].increment = squant.num;
			create->zones[create->num_zones].base      = squant.den;
			create->num_zones++;

			mp_msg(MSGT_MENCODER, MSGL_INFO,
			       "xvid: Fixed Quant Rate Control -- quantizer=%d/%d=%2.2f\n",
			       squant.num,
			       squant.den,
			       (float)(squant.num)/(float)(squant.den));

		} else {
			mp_msg(MSGT_MENCODER, MSGL_INFO,
			       "xvid: CBR Rate Control -- bitrate=%dkbit/s\n",
			       xvidenc_bitrate>16000?xvidenc_bitrate/1000:xvidenc_bitrate);
			doZones = 1;
		}

		create->plugins[create->num_plugins].func  = xvid_plugin_single;
		create->plugins[create->num_plugins].param = onepass;
		create->num_plugins++;
	}

	/* This is the first pass of a Two pass process */
	if(pass == MODE_2PASS1) {
		xvid_plugin_2pass1_t *pass1 = &mod->pass1;

		/* There is not much to initialize for this plugin */
		pass1->version  = XVID_VERSION;
		pass1->filename = passtmpfile;

		create->plugins[create->num_plugins].func  = xvid_plugin_2pass1;
		create->plugins[create->num_plugins].param = pass1;
		create->num_plugins++;

		mp_msg(MSGT_MENCODER, MSGL_INFO,
		       "xvid: 2Pass Rate Control -- 1st pass\n");
	}

	/* This is the second pass of a Two pass process */
	if(pass == MODE_2PASS2) {
		xvid_plugin_2pass2_t *pass2 = &mod->pass2;

		/* There is not much left to initialize after dispatch settings */
		pass2->version  = XVID_VERSION;
		pass2->filename =  passtmpfile;

		/* Positive bitrate values are bitrates as usual but if the
		 * value is negative it is considered as being a total size
		 * to reach (in kilobytes) */
		if(xvidenc_bitrate > 0) {
			if(xvidenc_bitrate > 16000) pass2->bitrate = xvidenc_bitrate;
			else pass2->bitrate = xvidenc_bitrate*1000;
			mp_msg(MSGT_MENCODER, MSGL_INFO,
			       "xvid: 2Pass Rate Control -- 2nd pass -- bitrate=%dkbit/s\n",
			       xvidenc_bitrate>16000?xvidenc_bitrate/1000:xvidenc_bitrate);
		} else {
			pass2->bitrate  = xvidenc_bitrate;
			mp_msg(MSGT_MENCODER, MSGL_INFO,
			       "xvid: 2Pass Rate Control -- 2nd pass -- total size=%dkB\n",
			       -xvidenc_bitrate);
		}

		create->plugins[create->num_plugins].func  = xvid_plugin_2pass2;
		create->plugins[create->num_plugins].param = pass2;
		create->num_plugins++;
		doZones = 1;
	}

	if(xvidenc_luminance_masking && (selected_profile->flags & PROFILE_ADAPTQUANT)) {
		create->plugins[create->num_plugins].func = xvid_plugin_lumimasking;
		create->plugins[create->num_plugins].param = NULL;
		create->num_plugins++;
	}

	// parse zones
	if (xvidenc_zones != NULL && doZones > 0) // do not apply zones in CQ, and first pass mode (xvid vfw doesn't allow them in those modes either)
	{
		char *p;
		int i;
		p = xvidenc_zones;
		create->num_zones = 0; // set the number of zones back to zero, this overwrites the zone defined for CQ - desired because each zone has to be specified on the commandline even in cq mode
		for(i = 0; p; i++)
		{
        		int start;
        		int q;
			double value;
			char mode;
        		int e = sscanf(p, "%d,%c,%lf", &start, &mode, &value); // start,mode(q = constant quant, w = weight),value
        		if(e != 3)
			{
	    			mp_msg(MSGT_MENCODER,MSGL_ERR, "error parsing zones\n");
            		return BAD;
        		}
			q = (int)(value * 100);
			if (mode == 'q')
			{
				if (q < 200 || q > 3100) // make sure that quantizer is in allowable range
				{
					mp_msg(MSGT_MENCODER, MSGL_ERR, "zone quantizer must be between 2 and 31\n");
					return BAD;
				}
				else
				{
					create->zones[create->num_zones].mode      = XVID_ZONE_QUANT;
				}
			}
			if (mode == 'w')
			{
				if (q < 1 || q > 200)
				{
					mp_msg(MSGT_MENCODER, MSGL_ERR, "zone weight must be between 1 and 200\n");
					return BAD;
				}
				else
				{
					create->zones[create->num_zones].mode      = XVID_ZONE_WEIGHT;
				}
			}
			create->zones[create->num_zones].frame     = start;
			create->zones[create->num_zones].increment = q;
			create->zones[create->num_zones].base      = 100; // increment is 100 times the actual value
			create->num_zones++;
			if (create->num_zones > MAX_ZONES) // show warning if we have too many zones
			{
				mp_msg(MSGT_MENCODER, MSGL_ERR, "too many zones, zones will be ignored\n");
			}
        		p = strchr(p, '/');
        		if(p) p++;
    		}
	}
	return FINE;
}

static int set_frame_struct(xvid_mplayer_module_t *mod, mp_image_t *mpi)
{
	xvid_enc_frame_t *frame = &mod->frame;

	/* Most of the initialization is done during dispatch_settings */
	frame->version = XVID_VERSION;

	/* Bind output buffer */
	frame->bitstream = mod->mux->buffer;
	frame->length    = -1;

	/* Frame format */
	switch(mpi->imgfmt) {
	case IMGFMT_YV12:
	case IMGFMT_IYUV:
	case IMGFMT_I420:
		frame->input.csp = XVID_CSP_USER;
		break;
	case IMGFMT_YUY2:
		frame->input.csp = XVID_CSP_YUY2;
		break;
	case IMGFMT_UYVY:
		frame->input.csp = XVID_CSP_UYVY;
		break;
	default:
		mp_msg(MSGT_MENCODER, MSGL_ERR,
		       "xvid: unsupported picture format (%s)!\n",
		       vo_format_name(mpi->imgfmt));
		return BAD;
	}

	/* Bind source frame */
	frame->input.plane[0]  = mpi->planes[0];
	frame->input.plane[1]  = mpi->planes[1];
	frame->input.plane[2]  = mpi->planes[2];
	frame->input.stride[0] = mpi->stride[0];
	frame->input.stride[1] = mpi->stride[1];
	frame->input.stride[2] = mpi->stride[2];

	/* Force the right quantizer -- It is internally managed by RC
	 * plugins */
	frame->quant = 0;

	return FINE;
}

static void
flush_internal_buffers(xvid_mplayer_module_t *mod)
{
	int size;
	xvid_enc_frame_t *frame = &mod->frame;

	if (mod->instance == NULL)
	    return; /* encoder not initialized */

	/* Init a fake frame to force flushing */
	frame->version = XVID_VERSION;
	frame->bitstream = mod->mux->buffer;
	frame->length    = -1;
	frame->input.csp = XVID_CSP_NULL;
	frame->input.plane[0] = NULL;
	frame->input.plane[1] = NULL;
	frame->input.plane[2] = NULL;
	frame->input.stride[0] = 0;
	frame->input.stride[1] = 0;
	frame->input.stride[2] = 0;
	frame->quant = 0;

	/* Flush encoder buffers caused by bframes usage */
	do {
		xvid_enc_stats_t stats;
		memset(&stats, 0, sizeof(xvid_enc_stats_t));
		stats.version = XVID_VERSION;

		/* Encode internal buffer */
		size = xvid_encore(mod->instance, XVID_ENC_ENCODE, &mod->frame, &stats);

		if (size>0) {
			/* Update stats */
			update_stats(mod, &stats);

			/* xvidcore outputed bitstream -- mux it */
			muxer_write_chunk(mod->mux, size,
					(mod->frame.out_flags & XVID_KEYFRAME)?0x10:0, MP_NOPTS_VALUE, MP_NOPTS_VALUE);
		}
	} while (size>0);
}

#define SSE2PSNR(sse, nbpixels) \
		((!(sse)) ? 99.99f : 48.131f - 10*(double)log10((double)(sse)/(double)((nbpixels))))
static void
update_stats(xvid_mplayer_module_t *mod, xvid_enc_stats_t *stats)
{
	if(xvidenc_stats && stats->type > 0) {
		mod->sse_y += stats->sse_y;
		mod->sse_u += stats->sse_u;
		mod->sse_v += stats->sse_v;

		if(mod->min_sse_y > stats->sse_y) {
			mod->min_sse_y = stats->sse_y;
			mod->min_sse_u = stats->sse_u;
			mod->min_sse_v = stats->sse_v;
			mod->min_framenum = mod->frames;
		}

		if(mod->max_sse_y < stats->sse_y) {
			mod->max_sse_y = stats->sse_y;
			mod->max_sse_u = stats->sse_u;
			mod->max_sse_v = stats->sse_v;
			mod->max_framenum = mod->frames;
		}

		if (xvidenc_psnr) {
			if (!mod->fvstats) {
				char filename[20];
				time_t today2;
				struct tm *today;
				today2 = time (NULL);
				today = localtime (&today2);
				sprintf (filename, "psnr_%02d%02d%02d.log", today->tm_hour, today->tm_min, today->tm_sec);
				mod->fvstats = fopen (filename,"w");
				if (!mod->fvstats) {
					perror ("fopen");
					/* Disable PSNR file output so we don't get here again */
					xvidenc_psnr = 0;
				}
			}
			fprintf (mod->fvstats, "%6d, %2d, %6d, %2.2f, %2.2f, %2.2f, %2.2f %c\n",
					mod->frames,
					stats->quant,
					stats->length,
					SSE2PSNR (stats->sse_y, mod->pixels),
					SSE2PSNR (stats->sse_u, mod->pixels / 4),
					SSE2PSNR (stats->sse_v, mod->pixels / 4),
					SSE2PSNR (stats->sse_y + stats->sse_u + stats->sse_v,(double)mod->pixels * 1.5),
					stats->type==1?'I':stats->type==2?'P':stats->type==3?'B':stats->type?'S':'?'
				);
		}
		mod->frames++;
	}
}

static void
print_stats(xvid_mplayer_module_t *mod)
{
	if (mod->frames) {
		mod->sse_y /= mod->frames;
		mod->sse_u /= mod->frames;
		mod->sse_v /= mod->frames;

		mp_msg(MSGT_MENCODER, MSGL_INFO,
				"The value 99.99dB is a special value and represents "
				"the upper range limit\n");
		mp_msg(MSGT_MENCODER, MSGL_INFO,
				"xvid:     Min PSNR Y:%.2f, Cb:%.2f, Cr:%.2f, All:%.2f in frame %d\n",
				SSE2PSNR(mod->max_sse_y, mod->pixels),
				SSE2PSNR(mod->max_sse_u, mod->pixels/4),
				SSE2PSNR(mod->max_sse_v, mod->pixels/4),
				SSE2PSNR(mod->max_sse_y + mod->max_sse_u + mod->max_sse_v, mod->pixels*1.5),
				mod->max_framenum);
		mp_msg(MSGT_MENCODER, MSGL_INFO,
				"xvid: Average PSNR Y:%.2f, Cb:%.2f, Cr:%.2f, All:%.2f for %d frames\n",
				SSE2PSNR(mod->sse_y, mod->pixels),
				SSE2PSNR(mod->sse_u, mod->pixels/4),
				SSE2PSNR(mod->sse_v, mod->pixels/4),
				SSE2PSNR(mod->sse_y + mod->sse_u + mod->sse_v, mod->pixels*1.5),
				mod->frames);
		mp_msg(MSGT_MENCODER, MSGL_INFO,
				"xvid:     Max PSNR Y:%.2f, Cb:%.2f, Cr:%.2f, All:%.2f in frame %d\n",
				SSE2PSNR(mod->min_sse_y, mod->pixels),
				SSE2PSNR(mod->min_sse_u, mod->pixels/4),
				SSE2PSNR(mod->min_sse_v, mod->pixels/4),
				SSE2PSNR(mod->min_sse_y + mod->min_sse_u + mod->min_sse_v, mod->pixels*1.5),
				mod->min_framenum);
	}
}
#undef SSE2PSNR

static void *read_matrix(unsigned char *filename)
{
	int i;
	unsigned char *matrix;
	FILE *input;

	/* Allocate matrix space */
	if((matrix = malloc(64*sizeof(unsigned char))) == NULL)
	   return NULL;

	/* Open the matrix file */
	if((input = fopen(filename, "rb")) == NULL) {
		mp_msg(MSGT_MENCODER, MSGL_ERR,
			"xvid: Error opening the matrix file %s\n",
			filename);
		free(matrix);
		return NULL;
	}

	/* Read the matrix */
	for(i=0; i<64; i++) {

		int value;

		/* If fscanf fails then get out of the loop */
		if(fscanf(input, "%d", &value) != 1) {
			mp_msg(MSGT_MENCODER, MSGL_ERR,
				"xvid: Error reading the matrix file %s\n",
				filename);
			free(matrix);
			fclose(input);
			return NULL;
		}

		/* Clamp the value to safe range */
		value     = (value<  1)?1  :value;
		value     = (value>255)?255:value;
		matrix[i] = value;
	}

	/* Fills the rest with 1 */
	while(i<64) matrix[i++] = 1;

	/* We're done */
	fclose(input);

	return matrix;

}


static const char *
par_string(int parcode)
{
	const char *par_string;
	switch (parcode) {
	case XVID_PAR_11_VGA:
		par_string = "vga11";
		break;
	case XVID_PAR_43_PAL:
		par_string = "pal43";
		break;
	case XVID_PAR_43_NTSC:
		par_string = "ntsc43";
		break;
	case XVID_PAR_169_PAL:
		par_string = "pal169";
		break;
	case XVID_PAR_169_NTSC:
		par_string = "ntsc69";
		break;
	case XVID_PAR_EXT:
		par_string = "ext";
		break;
	default:
		par_string = "unknown";
		break;
	}
	return par_string;
}

static const char *errorstring(int err)
{
	const char *error;
	switch(err) {
	case XVID_ERR_FAIL:
		error = "General fault";
		break;
	case XVID_ERR_MEMORY:
		error =  "Memory allocation error";
		break;
	case XVID_ERR_FORMAT:
		error =  "File format error";
		break;
	case XVID_ERR_VERSION:
		error =  "Structure version not supported";
		break;
	case XVID_ERR_END:
		error =  "End of stream reached";
		break;
	default:
		error = "Unknown";
	}

	return error;
}

/*****************************************************************************
 * Module structure definition
 ****************************************************************************/

const vf_info_t ve_info_xvid = {
	"XviD 1.0 encoder",
	"xvid",
	"Marco Belli <[e-mail]>, Edouard Gomez <[e-mail]>",
	"No comment",
	vf_open
};


/* Please do not change that tag comment.
 * arch-tag: 42ccc257-0548-4a3e-9617-2876c4e8ac88 mplayer xvid encoder module */