TDE
/
extra-dependencies
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/extra-dependencies.git
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e6ba08c3b2'
${ noResults }
extra-dependencies/debian/transcode/transcode-1.1.7/encode/encode_xvid.c

1079 lines
35 KiB
Raw Normal View History Unescape

Added debian extra dependency packages. Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
4 years ago
/*****************************************************************************
* - XviD Transcode Export Module -
*
* Copyright (C) 2001-2003 - Thomas Oestreich
*
* Author : Edouard Gomez <ed.gomez@free.fr>
*
* Port to transcode 1.1.0+ Module System:
* (C) 2005-2010 Francesco Romani <fromani at gmail dot com>
*
* This file is part of transcode, a video stream processing tool
*
* transcode 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.
*
* This program 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 this program ; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*****************************************************************************/
/*****************************************************************************
* Includes
****************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include <math.h>
#include "transcode.h"
#include "libtcvideo/tcvideo.h"
#include "libtc/cfgfile.h"
#include "libtc/optstr.h"
#include "libtc/tcmodule-plugin.h"
#include "libtc/tccodecs.h"
#include <xvid.h>
/*
* notes:
* - tc_xvid_ prefix is used to avoid any possible name clash with XviD code
* - export_xvid4.c was a really nice and well-written module, this module
* is largely based on such module and share a large portion of code with
* it. So hopefully it should work nicely :)
* - handling of dynamic loading of further shared objects (XviD codec, here)
* isn't optimal, such details should be handled by libtc.
* libdldarwin too should be merged with libtc, or maybe we should switch
* to libtool wizardry.
*/
/*****************************************************************************
* Transcode module binding functions and strings
****************************************************************************/
#define MOD_NAME "encode_xvid.so"
#define MOD_VERSION "v0.0.6 (2008-03-14)"
#define MOD_CAP "XviD 1.1.x encoder"
#define MOD_FEATURES \
TC_MODULE_FEATURE_ENCODE|TC_MODULE_FEATURE_VIDEO
#define MOD_FLAGS \
TC_MODULE_FLAG_RECONFIGURABLE
#define XVID_CONFIG_FILE "xvid.cfg"
static const char xvid_help[] = ""
"Overview:\n"
" this module encodes raw RGB/YUV video frames in MPEG4, using XviD.\n"
" XviD is a high quality/performance ISO MPEG4 codec.\n"
"Options:\n"
" help produce module overview and options explanations\n";
/*****************************************************************************
* XviD symbols grouped in a nice struct.
****************************************************************************/
typedef int (*xvid_function_t)(void *handle, int opt,
void *param1, void *param2);
/*****************************************************************************
* Transcode module private data
****************************************************************************/
typedef struct {
/* Instance related global vars */
void *instance;
xvid_gbl_init_t xvid_gbl_init;
xvid_enc_create_t xvid_enc_create;
xvid_enc_frame_t xvid_enc_frame;
/* This data must survive local block scope, so here it is */
xvid_enc_plugin_t plugins[7];
xvid_enc_zone_t zones[2];
xvid_plugin_single_t onepass;
xvid_plugin_2pass1_t pass1;
xvid_plugin_2pass2_t pass2;
/* Options from the config file */
xvid_enc_create_t cfg_create;
xvid_enc_frame_t cfg_frame;
xvid_plugin_single_t cfg_onepass;
xvid_plugin_2pass2_t cfg_pass2;
char *cfg_intra_matrix_file;
char *cfg_inter_matrix_file;
char *cfg_quant_method;
int cfg_packed;
int cfg_closed_gop;
int cfg_interlaced;
int cfg_quarterpel;
int cfg_gmc;
int cfg_trellis;
int cfg_cartoon;
int cfg_hqacpred;
int cfg_chromame;
int cfg_vhq;
int cfg_bvhq;
int cfg_motion;
int cfg_stats;
int cfg_greyscale;
int cfg_turbo;
int cfg_full1pass;
int cfg_lumimask;
/* MPEG4 stream buffer */
int stream_size;
uint8_t *stream;
/* Stats accumulators */
int frames;
int64_t sse_y;
int64_t sse_u;
int64_t sse_v;
/* Image format conversion handle */
TCVHandle tcvhandle;
int flush_flag;
} XviDPrivateData;
static const char *errorstring(int err);
static void reset_module(XviDPrivateData *mod);
static void cleanup_module(XviDPrivateData *mod);
static void read_config_file(XviDPrivateData *mod);
static void dispatch_settings(XviDPrivateData *mod);
static void set_create_struct(XviDPrivateData *mod, const vob_t *vob);
static void set_frame_struct(XviDPrivateData *mod, vob_t *vob,
const vframe_list_t *inframe,
vframe_list_t *outframe);
/***************************************************************************/
static int tc_xvid_configure(TCModuleInstance *self,
const char *options, vob_t *vob)
{
int ret;
XviDPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "configure");
TC_MODULE_SELF_CHECK(vob, "configure"); /* uhu, hackish? */
pd = self->userdata;
pd->flush_flag = vob->encoder_flush;
/* Load the config file settings */
read_config_file(pd);
/* Dispatch settings to xvid structures that hold the config ready to
* be copied to encoder structures */
dispatch_settings(pd);
/* Init the xvidcore lib */
memset(&pd->xvid_gbl_init, 0, sizeof(xvid_gbl_init_t));
pd->xvid_gbl_init.version = XVID_VERSION;
ret = xvid_global(NULL, XVID_GBL_INIT, &pd->xvid_gbl_init, NULL);
if (ret < 0) {
tc_log_error(MOD_NAME, "configure: library initialization failed");
return TC_ERROR;
}
/* Combine both the config settings with the transcode direct options
* into the final xvid_enc_create_t struct */
set_create_struct(pd, vob);
ret = xvid_encore(NULL, XVID_ENC_CREATE, &pd->xvid_enc_create, NULL);
if (ret < 0) {
tc_log_error(MOD_NAME, "configure: encoder initialization failed"
" (XviD returned %i)", ret);
return TC_ERROR;
}
/* Attach returned instance */
pd->instance = pd->xvid_enc_create.handle;
return TC_OK;
}
static int tc_xvid_init(TCModuleInstance *self, uint32_t features)
{
XviDPrivateData *pd = NULL;
vob_t *vob = tc_get_vob();
TC_MODULE_SELF_CHECK(self, "init");
TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features);
/* Check frame dimensions */
if (vob->ex_v_width % 2 || vob->ex_v_height % 2) {
tc_log_warn(MOD_NAME, "init: only even dimensions allowed (%dx%d)",
vob->ex_v_width, vob->ex_v_height);
return TC_ERROR;
}
pd = tc_malloc(sizeof(XviDPrivateData));
if (!pd) {
tc_log_error(MOD_NAME, "init: can't allocate XviD private data");
return TC_ERROR;
}
/* Buffer allocation
* We allocate width*height*bpp/8 to "receive" the compressed stream
* I don't think the codec will ever return more than that. It's and
* encoder, so if it fails delivering smaller frames than original
* ones, something really odd occurs somewhere and i prefer the
* application crash */
if (vob->im_v_codec == CODEC_RGB || vob->im_v_codec == CODEC_YUV422) {
pd->tcvhandle = tcv_init();
if (!pd->tcvhandle) {
tc_log_warn(MOD_NAME, "init: tcv_init failed");
goto init_failed;
}
}
reset_module(pd);
self->userdata = pd;
if (verbose) {
tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP);
}
return TC_OK;
init_failed:
tc_free(pd);
self->userdata = NULL; /* paranoia */
return TC_ERROR;
}
static int tc_xvid_inspect(TCModuleInstance *self,
const char *param, const char **value)
{
TC_MODULE_SELF_CHECK(self, "inspect");
if (optstr_lookup(param, "help")) {
*value = xvid_help;
}
return TC_OK;
}
static int tc_xvid_flush(TCModuleInstance *self, vframe_list_t *outframe)
{
int bytes;
xvid_enc_stats_t xvid_enc_stats;
vob_t *vob = tc_get_vob();
XviDPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "encode_video");
pd = self->userdata;
/* Init the stat structure */
memset(&xvid_enc_stats, 0, sizeof(xvid_enc_stats_t));
xvid_enc_stats.version = XVID_VERSION;
/* Combine both the config settings with the transcode direct options
* into the final xvid_enc_frame_t struct */
set_frame_struct(pd, vob, NULL, outframe);
bytes = xvid_encore(pd->instance, XVID_ENC_ENCODE,
&pd->xvid_enc_frame, &xvid_enc_stats);
outframe->video_len = bytes;
if (bytes > 0) {
/* Extract stats info */
if (xvid_enc_stats.type > 0 && pd->cfg_stats) {
pd->frames++;
pd->sse_y += xvid_enc_stats.sse_y;
pd->sse_u += xvid_enc_stats.sse_u;
pd->sse_v += xvid_enc_stats.sse_v;
}
if (pd->xvid_enc_frame.out_flags & XVID_KEYFRAME) {
outframe->attributes |= TC_FRAME_IS_KEYFRAME;
}
}
return TC_OK;
}
static int tc_xvid_encode_video(TCModuleInstance *self,
vframe_list_t *inframe, vframe_list_t *outframe)
{
int bytes;
xvid_enc_stats_t xvid_enc_stats;
vob_t *vob = tc_get_vob();
XviDPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "encode_video");
pd = self->userdata;
if (inframe == NULL && pd->flush_flag) {
return tc_xvid_flush(self, outframe); // FIXME
}
/* Init the stat structure */
memset(&xvid_enc_stats, 0, sizeof(xvid_enc_stats_t));
xvid_enc_stats.version = XVID_VERSION;
if(vob->im_v_codec == CODEC_YUV422) {
/* Convert to UYVY */
tcv_convert(pd->tcvhandle, inframe->video_buf, inframe->video_buf,
vob->ex_v_width, vob->ex_v_height, IMG_YUV422P, IMG_UYVY);
} else if (vob->im_v_codec == CODEC_RGB) {
/* Convert to BGR (why isn't RGB supported??) */
tcv_convert(pd->tcvhandle, inframe->video_buf, inframe->video_buf,
vob->ex_v_width, vob->ex_v_height, IMG_RGB24, IMG_BGR24);
}
/* Combine both the config settings with the transcode direct options
* into the final xvid_enc_frame_t struct */
set_frame_struct(pd, vob, inframe, outframe);
bytes = xvid_encore(pd->instance, XVID_ENC_ENCODE,
&pd->xvid_enc_frame, &xvid_enc_stats);
/* Error handling */
if (bytes < 0) {
tc_log_error(MOD_NAME, "encode_video: xvidcore returned"
" an error: \"%s\"",
errorstring(bytes));
return TC_ERROR;
}
outframe->video_len = bytes;
/* Extract stats info */
if (xvid_enc_stats.type > 0 && pd->cfg_stats) {
pd->frames++;
pd->sse_y += xvid_enc_stats.sse_y;
pd->sse_u += xvid_enc_stats.sse_u;
pd->sse_v += xvid_enc_stats.sse_v;
}
/* XviD Core rame buffering handling
* We must make sure audio A/V is still good and does not run away */
if (bytes == 0) {
outframe->attributes |= TC_FRAME_IS_DELAYED;
return TC_OK;
}
if (pd->xvid_enc_frame.out_flags & XVID_KEYFRAME) {
outframe->attributes |= TC_FRAME_IS_KEYFRAME;
}
return TC_OK;
}
#define SSE2PSNR(sse, width, height) \
((!(sse)) ? (99.0f) : (48.131f - 10*(float)log10((float)(sse)/((float)((width)*(height))))))
static int tc_xvid_stop(TCModuleInstance *self)
{
int ret;
XviDPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "stop");
pd = self->userdata;
/* ToDo: Can we flush the last frames here ? */
if (pd->instance != NULL) {
/* Destroy the encoder instance */
ret = xvid_encore(pd->instance, XVID_ENC_DESTROY, NULL, NULL);
if (ret < 0) {
tc_log_warn(MOD_NAME, "stop: encoder instance releasing failed");
return TC_ERROR;
}
/* Print stats before resting the complete module structure */
if (pd->cfg_stats) {
if(pd->frames > 0) {
pd->sse_y /= pd->frames;
pd->sse_u /= pd->frames;
pd->sse_v /= pd->frames;
} else {
pd->sse_y = 0;
pd->sse_u = 0;
pd->sse_v = 0;
}
tc_log_info(MOD_NAME,
"psnr y = %.2f dB, "
"psnr u = %.2f dB, "
"psnr v = %.2f dB",
SSE2PSNR(pd->sse_y,
pd->xvid_enc_create.width,
pd->xvid_enc_create.height),
SSE2PSNR(pd->sse_u,
pd->xvid_enc_create.width/2,
pd->xvid_enc_create.height/2),
SSE2PSNR(pd->sse_v,
pd->xvid_enc_create.width/2,
pd->xvid_enc_create.height/2));
}
pd->instance = NULL;
}
return TC_OK;
}
#undef SSE2PSNR
static int tc_xvid_fini(TCModuleInstance *self)
{
XviDPrivateData *pd = NULL;
TC_MODULE_SELF_CHECK(self, "fini");
tc_xvid_stop(self);
pd = self->userdata;
/* Free all dynamic memory allocated in the module structure */
cleanup_module(pd);
/* This is the last function according to the transcode API
* this should be safe to reset the module structure */
reset_module(pd);
tc_free(self->userdata);
self->userdata = NULL;
return TC_OK;
}
/*************************************************************************/
static const TCCodecID tc_xvid_codecs_in[] = {
TC_CODEC_RGB, TC_CODEC_YUV422P, TC_CODEC_YUV420P,
TC_CODEC_ERROR
};
static const TCCodecID tc_xvid_codecs_out[] = {
TC_CODEC_MPEG4VIDEO,
TC_CODEC_ERROR
};
TC_MODULE_CODEC_FORMATS(tc_xvid);
TC_MODULE_INFO(tc_xvid);
static const TCModuleClass xvid_class = {
TC_MODULE_CLASS_HEAD(tc_xvid),
.init = tc_xvid_init,
.fini = tc_xvid_fini,
.configure = tc_xvid_configure,
.stop = tc_xvid_stop,
.inspect = tc_xvid_inspect,
.encode_video = tc_xvid_encode_video
};
TC_MODULE_ENTRY_POINT(xvid)
/*****************************************************************************
* Transcode module helper functions
****************************************************************************/
static void reset_module(XviDPrivateData *mod)
{
/* Default options */
mod->cfg_packed = 0;
mod->cfg_closed_gop = 1;
mod->cfg_interlaced = 0;
mod->cfg_quarterpel = 0;
mod->cfg_gmc = 0;
mod->cfg_trellis = 0;
mod->cfg_cartoon = 0;
mod->cfg_hqacpred = 1;
mod->cfg_chromame = 1;
mod->cfg_vhq = 1;
mod->cfg_bvhq = 0;
mod->cfg_motion = 6;
mod->cfg_turbo = 0;
mod->cfg_full1pass = 0;
mod->cfg_stats = 0;
mod->cfg_greyscale = 0;
mod->cfg_quant_method = "h263";
mod->cfg_create.max_bframes = 1;
mod->cfg_create.bquant_ratio = 150;
mod->cfg_create.bquant_offset = 100;
mod->cfg_lumimask = 0;
}
static void cleanup_module(XviDPrivateData *mod)
{
/* Free tcvideo handle */
if (mod->tcvhandle != NULL) {
tcv_free(mod->tcvhandle);
mod->tcvhandle = NULL;
}
/* Release stream buffer memory */
if(mod->stream != NULL) {
free(mod->stream);
mod->stream = NULL;
}
/* Release the matrix file name string */
if(mod->cfg_inter_matrix_file != NULL) {
tc_free(mod->cfg_inter_matrix_file);
mod->cfg_inter_matrix_file = NULL;
}
/* Release the matrix definition */
if(mod->cfg_frame.quant_inter_matrix != NULL) {
tc_free(mod->cfg_frame.quant_inter_matrix);
mod->cfg_frame.quant_inter_matrix = NULL;
}
/* Release the matrix file name string */
if(mod->cfg_intra_matrix_file != NULL) {
tc_free(mod->cfg_intra_matrix_file);
mod->cfg_intra_matrix_file = NULL;
}
/* Release the matrix definition */
if(mod->cfg_frame.quant_intra_matrix != NULL) {
tc_free(mod->cfg_frame.quant_intra_matrix);
mod->cfg_frame.quant_intra_matrix = NULL;
}
}
/*****************************************************************************
* Configuration functions
*
* They fill the .cfg_xxx members of the module structure.
* - read_config_file reads the values from the config file and sets .cfg_xxx
* members of the module structure.
* - dispatch_settings uses the values retrieved by read_config_file and
* turns them into XviD settings in the cfg_xxx xvid structure available
* in the module structure.
* - set_create_struct sets a xvid_enc_create structure according to the
* settings generated by the two previous functions calls.
* - set_frame_struct same as above for a xvid_enc_frame_t struct.
****************************************************************************/
#define INTRA_MATRIX 0
#define INTER_MATRIX 1
static void load_matrix(XviDPrivateData *mod, int type)
{
xvid_enc_frame_t *frame = &mod->cfg_frame;
const char *filename = (type == INTER_MATRIX)
?mod->cfg_inter_matrix_file
:mod->cfg_intra_matrix_file;
uint8_t *matrix = NULL;
if (!filename) {
return;
}
matrix = tc_malloc(TC_MATRIX_SIZE);
if (matrix != NULL) {
int ret = tc_read_matrix(filename, matrix, NULL);
if (ret == 0) {
tc_log_info(MOD_NAME, "Loaded %s matrix (switching to "
"mpeg quantization type)",
(type == INTER_MATRIX) ?"Inter" :"Intra");
//print_matrix(matrix, NULL);
//free(mod->cfg_quant_method);
mod->cfg_quant_method = "mpeg";
} else {
tc_free(matrix);
matrix = NULL;
}
}
if (type == INTER_MATRIX) {
frame->quant_inter_matrix = matrix;
} else {
frame->quant_intra_matrix = matrix;
}
}
static void read_config_file(XviDPrivateData *mod)
{
xvid_plugin_single_t *onepass = &mod->cfg_onepass;
xvid_plugin_2pass2_t *pass2 = &mod->cfg_pass2;
xvid_enc_create_t *create = &mod->cfg_create;
xvid_enc_frame_t *frame = &mod->cfg_frame;
TCConfigEntry xvid_config[] = {
/* Section [features] */
// {"features", "Feature settings", TCCONF_TYPE_SECTION, 0, 0, 0},
{"quant_type", &mod->cfg_quant_method, TCCONF_TYPE_STRING, 0, 0, 0},
{"motion", &mod->cfg_motion, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 6},
{"chromame", &mod->cfg_chromame, TCCONF_TYPE_FLAG, 0, 0, 1},
{"vhq", &mod->cfg_vhq, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 4},
{"bvhq", &mod->cfg_bvhq, TCCONF_TYPE_FLAG, 0, 0, 1},
{"max_bframes", &create->max_bframes, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 20},
{"bquant_ratio", &create->bquant_ratio, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 200},
{"bquant_offset", &create->bquant_offset, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 200},
{"bframe_threshold", &frame->bframe_threshold, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -255, 255},
{"quarterpel", &mod->cfg_quarterpel, TCCONF_TYPE_FLAG, 0, 0, 1},
{"gmc", &mod->cfg_gmc, TCCONF_TYPE_FLAG, 0, 0, 1},
{"trellis", &mod->cfg_trellis, TCCONF_TYPE_FLAG, 0, 0, 1},
{"packed", &mod->cfg_packed, TCCONF_TYPE_FLAG, 0, 0, 1},
{"closed_gop", &mod->cfg_closed_gop, TCCONF_TYPE_FLAG, 0, 0, 1},
{"interlaced", &mod->cfg_interlaced, TCCONF_TYPE_FLAG, 0, 0, 1},
{"cartoon", &mod->cfg_cartoon, TCCONF_TYPE_FLAG, 0, 0, 1},
{"hqacpred", &mod->cfg_hqacpred, TCCONF_TYPE_FLAG, 0, 0, 1},
{"frame_drop_ratio", &create->frame_drop_ratio, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100},
{"stats", &mod->cfg_stats, TCCONF_TYPE_FLAG, 0, 0, 1},
{"greyscale", &mod->cfg_greyscale, TCCONF_TYPE_FLAG, 0, 0, 1},
{"turbo", &mod->cfg_turbo, TCCONF_TYPE_FLAG, 0, 0, 1},
#if XVID_API >= XVID_MAKE_API(4,1)
{"threads", &create->num_threads, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 8},
#endif
{"full1pass", &mod->cfg_full1pass, TCCONF_TYPE_FLAG, 0, 0, 1},
{"luminance_masking", &mod->cfg_lumimask, TCCONF_TYPE_FLAG, 0, 0, 1},
/* section [quantizer] */
// {"quantizer", "Quantizer settings", TCCONF_TYPE_SECTION, 0, 0, 0},
{"min_iquant", &create->min_quant[0], TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
{"max_iquant", &create->max_quant[0], TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
{"min_pquant", &create->min_quant[1], TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
{"max_pquant", &create->max_quant[1], TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
{"min_bquant", &create->min_quant[2], TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
{"max_bquant", &create->max_quant[2], TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31},
{"quant_intra_matrix", &mod->cfg_intra_matrix_file, TCCONF_TYPE_STRING, 0, 0, 100},
{"quant_inter_matrix", &mod->cfg_inter_matrix_file, TCCONF_TYPE_STRING, 0, 0, 100},
/* section [cbr] */
// {"cbr", "CBR settings", TCCONF_TYPE_SECTION, 0, 0, 0},
{"reaction_delay_factor", &onepass->reaction_delay_factor, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100},
{"averaging_period", &onepass->averaging_period, TCCONF_TYPE_INT, TCCONF_FLAG_MIN, 0, 0},
{"buffer", &onepass->buffer, TCCONF_TYPE_INT, TCCONF_FLAG_MIN, 0, 0},
/* section [vbr] */
// {"vbr", "VBR settings", TCCONF_TYPE_SECTION, 0, 0, 0},
{"keyframe_boost", &pass2->keyframe_boost, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100},
{"curve_compression_high", &pass2->curve_compression_high, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100},
{"curve_compression_low", &pass2->curve_compression_low, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100},
{"overflow_control_strength", &pass2->overflow_control_strength, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100},
{"max_overflow_improvement", &pass2->max_overflow_improvement, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100},
{"max_overflow_degradation", &pass2->max_overflow_degradation, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100},
{"kfreduction", &pass2->kfreduction, TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100},
{"kfthreshold", &pass2->kfthreshold, TCCONF_TYPE_INT, TCCONF_FLAG_MIN, 0, 0},
{"container_frame_overhead", &pass2->container_frame_overhead, TCCONF_TYPE_INT, TCCONF_FLAG_MIN, 0, 0},
/* End of the config file */
{NULL, 0, 0, 0, 0, 0}
};
/* Read the values */
module_read_config(XVID_CONFIG_FILE, NULL, xvid_config, MOD_NAME);
/* Print the values */
if (verbose & TC_DEBUG) {
module_print_config(xvid_config, MOD_NAME);
}
return;
}
static void dispatch_settings(XviDPrivateData *mod)
{
xvid_enc_create_t *create = &mod->cfg_create;
xvid_enc_frame_t *frame = &mod->cfg_frame;
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
};
/* Dispatch all settings having an impact on the "create" structure */
create->global = 0;
if (mod->cfg_packed) {
create->global |= XVID_GLOBAL_PACKED;
}
if (mod->cfg_closed_gop) {
create->global |= XVID_GLOBAL_CLOSED_GOP;
}
if (mod->cfg_stats) {
create->global |= XVID_GLOBAL_EXTRASTATS_ENABLE;
}
/* Dispatch all settings having an impact on the "frame" structure */
frame->vol_flags = 0;
frame->vop_flags = 0;
frame->motion = 0;
frame->vop_flags |= XVID_VOP_HALFPEL;
frame->motion |= motion_presets[mod->cfg_motion];
if (mod->cfg_stats) {
frame->vol_flags |= XVID_VOL_EXTRASTATS;
}
if (mod->cfg_greyscale) {
frame->vop_flags |= XVID_VOP_GREYSCALE;
}
if (mod->cfg_cartoon) {
frame->vop_flags |= XVID_VOP_CARTOON;
frame->motion |= XVID_ME_DETECT_STATIC_MOTION;
}
load_matrix(mod, INTRA_MATRIX);
load_matrix(mod, INTER_MATRIX);
if (!strcasecmp(mod->cfg_quant_method, "mpeg")) {
frame->vol_flags |= XVID_VOL_MPEGQUANT;
}
if (mod->cfg_quarterpel) {
frame->vol_flags |= XVID_VOL_QUARTERPEL;
frame->motion |= XVID_ME_QUARTERPELREFINE16;
frame->motion |= XVID_ME_QUARTERPELREFINE8;
}
if (mod->cfg_gmc) {
frame->vol_flags |= XVID_VOL_GMC;
frame->motion |= XVID_ME_GME_REFINE;
}
if (mod->cfg_interlaced) {
frame->vol_flags |= XVID_VOL_INTERLACING;
}
if (mod->cfg_trellis) {
frame->vop_flags |= XVID_VOP_TRELLISQUANT;
}
if (mod->cfg_hqacpred) {
frame->vop_flags |= XVID_VOP_HQACPRED;
}
if (mod->cfg_motion > 4) {
frame->vop_flags |= XVID_VOP_INTER4V;
}
if (mod->cfg_chromame) {
frame->motion |= XVID_ME_CHROMA_PVOP;
frame->motion |= XVID_ME_CHROMA_BVOP;
}
if (mod->cfg_vhq >= 1) {
frame->vop_flags |= XVID_VOP_MODEDECISION_RD;
}
if (mod->cfg_vhq >= 2) {
frame->motion |= XVID_ME_HALFPELREFINE16_RD;
frame->motion |= XVID_ME_QUARTERPELREFINE16_RD;
}
if (mod->cfg_vhq >= 3) {
frame->motion |= XVID_ME_HALFPELREFINE8_RD;
frame->motion |= XVID_ME_QUARTERPELREFINE8_RD;
frame->motion |= XVID_ME_CHECKPREDICTION_RD;
}
if (mod->cfg_vhq >= 4) {
frame->motion |= XVID_ME_EXTSEARCH_RD;
}
if (mod->cfg_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;
}
if (mod->cfg_bvhq) {
#if XVID_API >= XVID_MAKE_API(4,1)
frame->vop_flags |= XVID_VOP_RD_BVOP;
#endif
}
/* motion level == 0 means no motion search which is equivalent to
* intra coding only */
if (mod->cfg_motion == 0) {
frame->type = XVID_TYPE_IVOP;
} else {
frame->type = XVID_TYPE_AUTO;
}
return;
}
static void set_create_struct(XviDPrivateData *mod, const vob_t *vob)
{
xvid_enc_create_t *x = &mod->xvid_enc_create;
xvid_enc_create_t *xcfg = &mod->cfg_create;
memset(x, 0, sizeof(xvid_enc_create_t));
x->version = XVID_VERSION;
/* Global encoder options */
x->global = xcfg->global;
/* Width and Height */
x->width = vob->ex_v_width;
x->height = vob->ex_v_height;
/* Max keyframe interval */
x->max_key_interval = vob->divxkeyframes;
/* FPS : we take care of non integer values */
if ((vob->ex_fps - (int)vob->ex_fps) == 0) {
x->fincr = 1;
x->fbase = (int)vob->ex_fps;
} else {
x->fincr = 1001;
x->fbase = (int)(1001 * vob->ex_fps);
}
/* BFrames settings */
x->max_bframes = xcfg->max_bframes;
x->bquant_ratio = xcfg->bquant_ratio;
x->bquant_offset = xcfg->bquant_offset;
/* Frame dropping factor */
x->frame_drop_ratio = xcfg->frame_drop_ratio;
/* Quantizers */
x->min_quant[0] = xcfg->min_quant[0];
x->min_quant[1] = xcfg->min_quant[1];
x->min_quant[2] = xcfg->min_quant[2];
x->max_quant[0] = xcfg->max_quant[0];
x->max_quant[1] = xcfg->max_quant[1];
x->max_quant[2] = xcfg->max_quant[2];
/* Encodings zones
* ToDo?: Allow zones definitions */
memset(mod->zones, 0, sizeof(mod->zones));
x->zones = mod->zones;
if (1 == vob->divxmultipass && mod->cfg_full1pass)
{
x->zones[0].frame = 0;
x->zones[0].mode = XVID_ZONE_QUANT;
x->zones[0].increment = 200;
x->zones[0].base = 100;
x->num_zones = 1;
} else {
x->num_zones = 0;
}
/* Plugins */
memset(mod->plugins, 0, sizeof(mod->plugins));
x->plugins = mod->plugins;
x->num_plugins = 0;
/* Initialize rate controller plugin */
/* This is the first pass of a Two pass process */
if (vob->divxmultipass == 1) {
xvid_plugin_2pass1_t *pass1 = &mod->pass1;
memset(pass1, 0, sizeof(xvid_plugin_2pass1_t));
pass1->version = XVID_VERSION;
pass1->filename = (char*)vob->divxlogfile; /* XXX: ugh */
x->plugins[x->num_plugins].func = xvid_plugin_2pass1;
x->plugins[x->num_plugins].param = pass1;
x->num_plugins++;
}
/* This is the second pass of a Two pass process */
if (vob->divxmultipass == 2) {
xvid_plugin_2pass2_t *pass2 = &mod->pass2;
xvid_plugin_2pass2_t *pass2cfg = &mod->cfg_pass2;
memset(pass2, 0, sizeof(xvid_plugin_2pass2_t));
pass2->version = XVID_VERSION;
pass2->filename = (char*)vob->divxlogfile; /* XXX: ugh */
/* Apply config file settings if any, or all 0s which lets XviD
* apply its defaults */
pass2->keyframe_boost = pass2cfg->keyframe_boost;
pass2->curve_compression_high = pass2cfg->curve_compression_high;
pass2->curve_compression_low = pass2cfg->curve_compression_low;
pass2->overflow_control_strength = pass2cfg->overflow_control_strength;
pass2->max_overflow_improvement = pass2cfg->max_overflow_improvement;
pass2->max_overflow_degradation = pass2cfg->max_overflow_degradation;
pass2->kfreduction = pass2cfg->kfreduction;
pass2->kfthreshold = pass2cfg->kfthreshold;
pass2->container_frame_overhead = pass2cfg->container_frame_overhead;
/* 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 (vob->divxbitrate > 0) {
pass2->bitrate = vob->divxbitrate*1000;
} else {
pass2->bitrate = vob->divxbitrate;
}
x->plugins[x->num_plugins].func = xvid_plugin_2pass2;
x->plugins[x->num_plugins].param = pass2;
x->num_plugins++;
}
/* This is a single pass encoding: either a CBR pass or a constant
* quantizer pass */
if (vob->divxmultipass == 0 || vob->divxmultipass == 3) {
xvid_plugin_single_t *onepass = &mod->onepass;
xvid_plugin_single_t *cfgonepass = &mod->cfg_onepass;
memset(onepass, 0, sizeof(xvid_plugin_single_t));
onepass->version = XVID_VERSION;
onepass->bitrate = vob->divxbitrate*1000;
/* Apply config file settings if any, or all 0s which lets XviD
* apply its defaults */
onepass->reaction_delay_factor = cfgonepass->reaction_delay_factor;
onepass->averaging_period = cfgonepass->averaging_period;
onepass->buffer = cfgonepass->buffer;
/* Quantizer mode uses the same plugin, we have only to define
* a constant quantizer zone beginning at frame 0 */
if (vob->divxmultipass == 3) {
x->zones[x->num_zones].mode = XVID_ZONE_QUANT;
x->zones[x->num_zones].frame = 1;
x->zones[x->num_zones].increment = vob->divxbitrate;
x->zones[x->num_zones].base = 1;
x->num_zones++;
}
x->plugins[x->num_plugins].func = xvid_plugin_single;
x->plugins[x->num_plugins].param = onepass;
x->num_plugins++;
}
if (mod->cfg_lumimask) {
#if XVID_API >= XVID_MAKE_API(4,1)
x->plugins[x->num_plugins].func = xvid_plugin_lumimasking;
x->plugins[x->num_plugins].param = NULL;
x->num_plugins++;
#endif
}
return;
}
static void set_frame_struct(XviDPrivateData *mod, vob_t *vob,
const vframe_list_t *inframe, vframe_list_t *outframe)
{
xvid_enc_frame_t *x = &mod->xvid_enc_frame;
xvid_enc_frame_t *xcfg = &mod->cfg_frame;
memset(x, 0, sizeof(xvid_enc_frame_t));
x->version = XVID_VERSION;
/* Bind output buffer */
x->bitstream = outframe->video_buf;
if (!inframe) { /* flush request */
x->length = -1;
x->input.csp = XVID_CSP_NULL;
x->input.plane[0] = NULL;
// x->input.plane[1] = NULL;
// x->input.plane[2] = NULL;
x->input.stride[0] = 0;
// x->input.stride[1] = 0;
// x->input.stride[2] = 0;
} else {
x->length = outframe->video_size;
/* Bind source frame */
x->input.plane[0] = inframe->video_buf;
if (vob->im_v_codec == CODEC_RGB) {
x->input.csp = XVID_CSP_BGR;
x->input.stride[0] = vob->ex_v_width*3;
} else if (vob->im_v_codec == CODEC_YUV422) {
x->input.csp = XVID_CSP_UYVY;
x->input.stride[0] = vob->ex_v_width*2;
} else {
x->input.csp = XVID_CSP_I420;
x->input.stride[0] = vob->ex_v_width;
}
}
/* Set up core's VOL level features */
x->vol_flags = xcfg->vol_flags;
/* Set up core's VOP level features */
x->vop_flags = xcfg->vop_flags;
/* Frame type -- let core decide for us */
x->type = xcfg->type;
/* Force the right quantizer -- It is internally managed by RC
* plugins */
x->quant = 0;
/* Set up motion estimation flags */
x->motion = xcfg->motion;
/* We don't use special matrices */
x->quant_intra_matrix = xcfg->quant_intra_matrix;
x->quant_inter_matrix = xcfg->quant_inter_matrix;
/* pixel aspect ratio
* transcode.c uses 0 for EXT instead of 15 */
if (vob->ex_par == 0) {
x->par = XVID_PAR_EXT;
x->par_width = vob->ex_par_width;
x->par_height = vob->ex_par_height;
} else {
x->par = vob->ex_par;
/* par_{width,height} already set to zero above */
}
return;
}
/*****************************************************************************
* Returns an error string corresponding to the XviD err code
****************************************************************************/
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;
}
/*************************************************************************/
/*
* Local variables:
* c-file-style: "stroustrup"
* c-file-offsets: ((case-label . *) (statement-case-intro . *))
* indent-tabs-mode: nil
* End:
*
* vim: expandtab shiftwidth=4:
*/