github/mpv
1
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2024-11-07 01:47:00 +01:00
Code Releases Activity
fd55a47f01
mpv/libmpcodecs/ve_divx4.c
arpi 1864646717 I've found some time to implement the encoding support for the new 
DivX API. Now it's possible to play and encode movies with the
latest DivX release.
One thing that doesn't work is the new Video Buffer Verifier (VBV)
multipass encoding. The encoder segfaults. Maybe it just isn't
supported with the standard profile of the released binary encoder.
Andreas Hess <jaska@gmx.net>


git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@10253 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-06-06 19:57:37 +00:00

490 lines
18 KiB
C
Raw Blame History

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../config.h"
#include "../mp_msg.h"
#ifdef HAVE_DIVX4ENCORE
#include "codec-cfg.h"
#include "stream.h"
#include "demuxer.h"
#include "stheader.h"
#include "muxer.h"
#include "img_format.h"
#include "mp_image.h"
#include "vf.h"
/* About XviD VBR Library, Edouard Gomez (GomGom) said:
<GomGom> header bytes == frame header bytes :-)
<GomGom> total bytes = frame bytes == texture + header
<GomGom> quant = quant returned by xvidcore
<GomGom> it's possible that xvid lowers or increases the passed quant because of lumimasking
<GomGom> kblks = blocks coded as intra blocks
<GomGom> mblks = blocks coded as predicted blocks
<GomGom> ublks = skipped blocks
<GomGom> at the moemnt le vbr lib uses total bytes, and quant
<GomGom> so it's easy to use it with divx5 (wo bframes)
<klOUg> bframes breaks what assumptions?
<GomGom> quant estimation for next frame
<GomGom> because of the bframe quant multiplier given to divx5
<GomGom> that the vbr lib does not "know"
*/
//===========================================================================//
static int pass;
extern char* passtmpfile;
#ifdef ENCORE_XVID
#include <divx4.h>
#else
#include <encore2.h>
#endif
#ifndef ENCORE_MAJOR_VERSION
#define ENCORE_MAJOR_VERSION 4000
#endif
#if ENCORE_MAJOR_VERSION < 5200
#include "divx4_vbr.h"
#define HAVE_XVID_VBR
#ifdef HAVE_XVID_VBR
#include "xvid_vbr.h"
#endif
#endif
#if ENCORE_MAJOR_VERSION >= 5200
SETTINGS divx4_param;
#else
ENC_PARAM divx4_param;
#endif
int divx4_crispness;
#ifdef HAVE_XVID_VBR
static int vbrpass = -1;
static int vbrdebug = 0;
#endif
#include "cfgparser.h"
struct config divx4opts_conf[]={
{"pass", &pass, CONF_TYPE_INT, CONF_RANGE,0,2, NULL},
{"br", &divx4_param.bitrate, CONF_TYPE_INT, CONF_RANGE, 4, 24000000, NULL},
#if ENCORE_MAJOR_VERSION < 5200
{"rc_period", &divx4_param.rc_period, CONF_TYPE_INT, 0,0,0, NULL},
{"rc_reaction_period", &divx4_param.rc_reaction_period, CONF_TYPE_INT, 0,0,0, NULL},
{"rc_reaction_ratio", &divx4_param.rc_reaction_ratio, CONF_TYPE_INT, 0,0,0, NULL},
{"min_quant", &divx4_param.min_quantizer, CONF_TYPE_INT, CONF_RANGE,0,32, NULL},
{"max_quant", &divx4_param.max_quantizer, CONF_TYPE_INT, CONF_RANGE,0,32, NULL},
#endif
{"key", &divx4_param.max_key_interval, CONF_TYPE_INT, CONF_MIN,0,0, NULL},
{"deinterlace", &divx4_param.deinterlace, CONF_TYPE_FLAG, 0,0,1, NULL},
{"q", &divx4_param.quality, CONF_TYPE_INT, CONF_RANGE, 1, 5, NULL},
{"crispness", &divx4_crispness, CONF_TYPE_INT, CONF_RANGE,0,100, NULL},
#if ENCORE_MAJOR_VERSION >= 5010
#if ENCORE_MAJOR_VERSION >= 5200
/* rate control modes:
0 (VBV 1-pass)
1 (1-pass constant quality)
2 (VBV multipass 1st-pass)
3 (VBV multipass nth-pass)
4 (original 1-pass)
5 (original 1st pass)
6 (original 2nd pass)
7 (1-pass constant frame size)
*/
{"vbr", &divx4_param.vbr_mode, CONF_TYPE_INT, CONF_RANGE,0,7, NULL},
{"bidirect", &divx4_param.use_bidirect, CONF_TYPE_FLAG, 0,0,1, NULL},
{"key_frame_threshold", &divx4_param.key_frame_threshold, CONF_TYPE_INT, CONF_RANGE,1,100, NULL},
/* default values from the DivX Help Guide:
bitrate size occupancy
128000 262144 196608 (Handheld)
768000 1048576 786432 (Portable)
4000000 3145728 2359296 (Home Theatre)
8000000 6291456 4718592 (High Definition)
Do not mess with these values unless you are absolutely sure of what you are doing!
*/
{"vbv_bitrate", &divx4_param.vbv_bitrate, CONF_TYPE_INT, 0,0,0, NULL},
{"vbv_size", &divx4_param.vbv_size, CONF_TYPE_INT, 0,0,0, NULL},
{"vbv_occupancy", &divx4_param.vbv_occupancy, CONF_TYPE_INT, 0,0,0, NULL},
{"complexity", &divx4_param.complexity_modulation, CONF_TYPE_FLOAT, CONF_RANGE,0.0,1.0, NULL},
{"readlog", &divx4_param.log_file_read, CONF_TYPE_STRING, 0,0,1, NULL},
{"writelog", &divx4_param.log_file_write, CONF_TYPE_STRING, 0,0,1, NULL},
{"mv_file", &divx4_param.mv_file, CONF_TYPE_STRING, 0,0,1, NULL},
{"data_partitioning", &divx4_param.data_partitioning, CONF_TYPE_FLAG, 0,0,1, NULL},
{"qpel", &divx4_param.quarter_pel, CONF_TYPE_FLAG, 0,0,1, NULL},
{"gmc", &divx4_param.use_gmc, CONF_TYPE_FLAG, 0,0,1, NULL},
{"pv", &divx4_param.psychovisual, CONF_TYPE_FLAG, 0,0,1, NULL},
{"pv_strength_frame", &divx4_param.pv_strength_frame, CONF_TYPE_FLOAT, CONF_RANGE,0.0,1.0, NULL},
{"pv_strength_MB", &divx4_param.pv_strength_MB, CONF_TYPE_FLOAT, CONF_RANGE,0.0,1.0, NULL},
{"interlace_mode", &divx4_param.interlace_mode, CONF_TYPE_INT, CONF_RANGE,0,3, NULL},
{"crop", &divx4_param.enable_crop, CONF_TYPE_FLAG, 0,0,1, NULL},
{"resize", &divx4_param.enable_resize, CONF_TYPE_FLAG, 0,0,1, NULL},
{"width", &divx4_param.resize_width, CONF_TYPE_INT, 0,0,0, NULL},
{"height", &divx4_param.resize_height, CONF_TYPE_INT, 0,0,0, NULL},
{"left", &divx4_param.crop_left, CONF_TYPE_INT, 0,0,0, NULL},
{"right", &divx4_param.crop_right, CONF_TYPE_INT, 0,0,0, NULL},
{"top", &divx4_param.crop_top, CONF_TYPE_INT, 0,0,0, NULL},
{"bottom", &divx4_param.crop_bottom, CONF_TYPE_INT, 0,0,0, NULL},
{"resize_mode", &divx4_param.resize_mode, CONF_TYPE_FLAG, 0,0,1, NULL},
{"temporal", &divx4_param.temporal_enable, CONF_TYPE_FLAG, 0,0,1, NULL},
{"spatial", &divx4_param.spatial_passes, CONF_TYPE_INT, CONF_RANGE,0,3, NULL},
{"temporal_level", &divx4_param.temporal_level, CONF_TYPE_FLOAT, CONF_RANGE,0.0,1.0, NULL},
{"spatial_level", &divx4_param.spatial_level, CONF_TYPE_FLOAT, CONF_RANGE,0.0,1.0, NULL},
#else
{"bidirect", &divx4_param.extensions.use_bidirect, CONF_TYPE_FLAG, 0,0,1, NULL},
{"obmc", &divx4_param.extensions.obmc, CONF_TYPE_FLAG, 0,0,1, NULL},
{"data_partitioning", &divx4_param.extensions.data_partitioning, CONF_TYPE_FLAG, 0,0,1, NULL},
// {"mpeg2", &divx4_param.extensions.mpeg2_quant, CONF_TYPE_FLAG, 0,0,1, NULL},
{"qpel", &divx4_param.extensions.quarter_pel, CONF_TYPE_FLAG, 0,0,1, NULL},
{"intra_frame_threshold", &divx4_param.extensions.intra_frame_threshold, CONF_TYPE_INT, CONF_RANGE,1,100, NULL},
{"psychovisual", &divx4_param.extensions.psychovisual, CONF_TYPE_FLAG, 0,0,1, NULL},
{"pv", &divx4_param.extensions.psychovisual, CONF_TYPE_FLAG, 0,0,1, NULL},
{"pv_strength_frame", &divx4_param.extensions.pv_strength_frame, CONF_TYPE_FLOAT, CONF_RANGE,0.0,1.0, NULL},
{"pv_strength_MB", &divx4_param.extensions.pv_strength_MB, CONF_TYPE_FLOAT, CONF_RANGE,0.0,1.0, NULL},
{"testing_param", &divx4_param.extensions.testing_param, CONF_TYPE_FLAG, 0,0,1, NULL},
{"gmc", &divx4_param.extensions.use_gmc, CONF_TYPE_FLAG, 0,0,1, NULL},
{"interlace_mode", &divx4_param.extensions.interlace_mode, CONF_TYPE_INT, CONF_RANGE,0,2, NULL},
{"crop", &divx4_param.extensions.enable_crop, CONF_TYPE_FLAG, 0,0,1, NULL},
{"resize", &divx4_param.extensions.enable_resize, CONF_TYPE_FLAG, 0,0,1, NULL},
{"width", &divx4_param.extensions.resize_width, CONF_TYPE_INT, 0,0,0, NULL},
{"height", &divx4_param.extensions.resize_height, CONF_TYPE_INT, 0,0,0, NULL},
{"left", &divx4_param.extensions.crop_left, CONF_TYPE_INT, 0,0,0, NULL},
{"right", &divx4_param.extensions.crop_right, CONF_TYPE_INT, 0,0,0, NULL},
{"top", &divx4_param.extensions.crop_top, CONF_TYPE_INT, 0,0,0, NULL},
{"bottom", &divx4_param.extensions.crop_bottom, CONF_TYPE_INT, 0,0,0, NULL},
{"resize_mode", &divx4_param.extensions.resize_mode, CONF_TYPE_FLAG, 0,0,1, NULL},
{"temporal", &divx4_param.extensions.temporal_enable, CONF_TYPE_FLAG, 0,0,1, NULL},
{"spatial", &divx4_param.extensions.spatial_passes, CONF_TYPE_INT, CONF_RANGE,0,3, NULL},
{"temporal_level", &divx4_param.extensions.temporal_level, CONF_TYPE_FLOAT, CONF_RANGE,0.0,1.0, NULL},
{"spatial_level", &divx4_param.extensions.spatial_level, CONF_TYPE_FLOAT, CONF_RANGE,0.0,1.0, NULL},
{"mv_file", &divx4_param.extensions.mv_file, CONF_TYPE_STRING, 0,0,1, NULL},
#endif
#endif
#ifdef HAVE_XVID_VBR
{"vbrpass", &vbrpass, CONF_TYPE_INT, CONF_RANGE, 0, 2, NULL},
{"vbrdebug", &vbrdebug, CONF_TYPE_INT, CONF_RANGE, 0, 1, NULL},
#endif
{"help", "TODO: divx4opts help!\n", CONF_TYPE_PRINT, CONF_NOCFG, 0, 0, NULL},
{NULL, NULL, 0, 0, 0, 0, NULL}
};
struct vf_priv_s {
muxer_stream_t* mux;
ENC_RESULT enc_result;
ENC_FRAME enc_frame;
void* enc_handle;
#ifdef HAVE_XVID_VBR
vbr_control_t vbr_state;
#endif
};
#define mux_v (vf->priv->mux)
static int config(struct vf_instance_s* vf,
int width, int height, int d_width, int d_height,
unsigned int flags, unsigned int outfmt){
#if ENCORE_MAJOR_VERSION >= 5200
DivXBitmapInfoHeader format;
char profile = (char) encore(0, ENC_OPT_PROFILE, 0, 0);
mp_msg(MSGT_MENCODER, MSGL_INFO, "encoder binary profile: %c\n", profile);
if((pass <= 1 && (divx4_param.vbr_mode == RCMODE_VBV_MULTIPASS_NTH ||
divx4_param.vbr_mode == RCMODE_502_2PASS_2ND)) ||
(pass == 2 && (divx4_param.vbr_mode == RCMODE_VBV_1PASS ||
divx4_param.vbr_mode == RCMODE_1PASS_CONSTANT_Q ||
divx4_param.vbr_mode == RCMODE_VBV_MULTIPASS_1ST ||
divx4_param.vbr_mode == RCMODE_502_1PASS ||
divx4_param.vbr_mode == RCMODE_502_2PASS_1ST ||
divx4_param.vbr_mode == RCMODE_IMAGE_COMPRESS))) {
mp_msg(MSGT_MENCODER, MSGL_ERR, "pass (%i) and rate control mode (%i) doesn't match, please consult encore2.h\n",
pass, divx4_param.vbr_mode);
abort();
}
#endif
mux_v->bih->biWidth=width;
mux_v->bih->biHeight=height;
mux_v->bih->biSizeImage=width*height*3;
if(!divx4_param.bitrate) divx4_param.bitrate=800000;
else if(divx4_param.bitrate<=16000) divx4_param.bitrate*=1000;
if(!divx4_param.quality) divx4_param.quality=5; // the quality of compression ( 1 - fastest, 5 - best )
#if ENCORE_MAJOR_VERSION >= 5200
format.biSize=sizeof(DivXBitmapInfoHeader);
format.biWidth=width;
format.biHeight=height;
format.biSizeImage=mux_v->bih->biSizeImage;
if(divx4_param.vbv_bitrate > 0) {
divx4_param.vbv_bitrate = ((divx4_param.vbv_bitrate - 1) / 400 + 1) * 400;
divx4_param.vbv_size = ((divx4_param.vbv_size - 1) / 16384 + 1) * 16384;
divx4_param.vbv_occupancy = ((divx4_param.vbv_occupancy - 1) / 64 + 1) * 64;
}
#else
divx4_param.x_dim=width;
divx4_param.y_dim=height;
divx4_param.framerate=(float)mux_v->h.dwRate/mux_v->h.dwScale;
// set some usefull defaults:
if(!divx4_param.min_quantizer) divx4_param.min_quantizer=2;
if(!divx4_param.max_quantizer) divx4_param.max_quantizer=31;
if(!divx4_param.rc_period) divx4_param.rc_period=2000;
if(!divx4_param.rc_reaction_period) divx4_param.rc_reaction_period=10;
if(!divx4_param.rc_reaction_ratio) divx4_param.rc_reaction_ratio=20;
#endif
#ifdef HAVE_XVID_VBR
if (vbrpass >= 0) {
vbrSetDefaults(&vf->priv->vbr_state);
vf->priv->vbr_state.desired_bitrate = divx4_param.bitrate;
switch (vbrpass) {
case 0:
vf->priv->vbr_state.mode = VBR_MODE_1PASS;
break;
case 1:
vf->priv->vbr_state.mode = VBR_MODE_2PASS_1;
break;
case 2:
vf->priv->vbr_state.mode = VBR_MODE_2PASS_2;
break;
default:
abort();
}
vf->priv->vbr_state.debug = vbrdebug;
if (vbrInit(&vf->priv->vbr_state) == -1)
abort();
/* XXX - kludge to workaround some DivX encoder limitations */
if (vf->priv->vbr_state.mode != VBR_MODE_2PASS_2)
divx4_param.min_quantizer = divx4_param.max_quantizer = vbrGetQuant(&vf->priv->vbr_state);
}
#endif
#if ENCORE_MAJOR_VERSION >= 5200
switch(outfmt){
case IMGFMT_YV12: {
format.biCompression=mmioFOURCC('Y','V','1','2');
break;
}
case IMGFMT_IYUV: {
format.biCompression=mmioFOURCC('I','Y','U','V');
break;
}
case IMGFMT_I420: {
format.biCompression=mmioFOURCC('I','4','2','0');
break;
}
case IMGFMT_YUY2: {
format.biCompression=mmioFOURCC('Y','U','Y','2');
break;
}
case IMGFMT_V422: {
format.biCompression=mmioFOURCC('V','4','2','2');
break;
}
case IMGFMT_UYVY: {
format.biCompression=mmioFOURCC('U','Y','V','Y');
break;
}
case IMGFMT_YVYU: {
format.biCompression=mmioFOURCC('Y','V','Y','U');
break;
}
case IMGFMT_BGR24: {
format.biCompression=0;
format.biBitCount=24;
break;
}
case IMGFMT_BGR32: {
format.biCompression=0;
format.biBitCount=32;
break;
}
default:
mp_msg(MSGT_MENCODER,MSGL_ERR,"divx4: unsupported picture format (%s)!\n",
vo_format_name(outfmt));
return 0;
}
encore(&vf->priv->enc_handle, ENC_OPT_INIT, &format, &divx4_param);
#else
divx4_param.handle=NULL;
encore(NULL,ENC_OPT_INIT,&divx4_param,NULL);
vf->priv->enc_handle=divx4_param.handle;
switch(outfmt){
case IMGFMT_YV12: vf->priv->enc_frame.colorspace=ENC_CSP_YV12; break;
case IMGFMT_IYUV:
case IMGFMT_I420: vf->priv->enc_frame.colorspace=ENC_CSP_I420; break;
case IMGFMT_YUY2: vf->priv->enc_frame.colorspace=ENC_CSP_YUY2; break;
case IMGFMT_UYVY: vf->priv->enc_frame.colorspace=ENC_CSP_UYVY; break;
case IMGFMT_RGB24:
case IMGFMT_BGR24:
vf->priv->enc_frame.colorspace=ENC_CSP_RGB24; break;
default:
mp_msg(MSGT_MENCODER,MSGL_ERR,"divx4: unsupported picture format (%s)!\n",
vo_format_name(outfmt));
return 0;
}
switch(pass){
case 1:
if (VbrControl_init_2pass_vbr_analysis(passtmpfile, divx4_param.quality) == -1){
mp_msg(MSGT_MENCODER,MSGL_ERR,"2pass failed: filename=%s\n", passtmpfile);
pass=0;
}
break;
case 2:
if (VbrControl_init_2pass_vbr_encoding(passtmpfile,
divx4_param.bitrate,
divx4_param.framerate,
divx4_crispness,
divx4_param.quality) == -1){
mp_msg(MSGT_MENCODER,MSGL_ERR,"2pass failed: filename=%s\n", passtmpfile);
pass=0;
}
break;
}
#endif
return 1;
}
#ifdef HAVE_XVID_VBR
static void uninit(struct vf_instance_s* vf){
if (vbrpass >= 0 && vbrFinish(&vf->priv->vbr_state) == -1)
abort();
}
#else
static void uninit(struct vf_instance_s* vf){
encore(vf->priv->enc_handle, ENC_OPT_RELEASE, 0, 0);
vf->priv->enc_handle = NULL;
}
#endif
static int control(struct vf_instance_s* vf, int request, void* data){
return CONTROL_UNKNOWN;
}
static int query_format(struct vf_instance_s* vf, unsigned int fmt){
switch(fmt){
case IMGFMT_YV12:
case IMGFMT_IYUV:
case IMGFMT_I420:
return 3; // no conversion
case IMGFMT_YUY2:
case IMGFMT_UYVY:
return 1; // conversion
case IMGFMT_RGB24:
case IMGFMT_BGR24:
return 1 | VFCAP_FLIPPED; // conversion+flipped
}
return 0;
}
static int put_image(struct vf_instance_s* vf, mp_image_t *mpi){
ENC_RESULT enc_result;
vf->priv->enc_frame.image=mpi->planes[0];
vf->priv->enc_frame.bitstream=mux_v->buffer;
vf->priv->enc_frame.length=mux_v->buffer_size;
#if ENCORE_MAJOR_VERSION >= 5200
vf->priv->enc_frame.produce_empty_frame = 0;
encore(vf->priv->enc_handle, ENC_OPT_ENCODE, &vf->priv->enc_frame, &enc_result);
if(enc_result.cType == 'I')
muxer_write_chunk(mux_v,vf->priv->enc_frame.length,0x10);
else
muxer_write_chunk(mux_v,vf->priv->enc_frame.length,0);
#else
vf->priv->enc_frame.mvs=NULL;
#ifdef HAVE_XVID_VBR
if (vbrpass >= 0) {
int quant = vbrGetQuant(&vf->priv->vbr_state);
int intra = vbrGetIntra(&vf->priv->vbr_state);
vf->priv->enc_frame.quant = quant ? quant : 1;
vf->priv->enc_frame.intra = intra;
/* XXX - kludge to workaround some DivX encoder limitations:
only pass 2 needs to call encore with VBR, and then it does
not report quantizer and intra*/
if (vf->priv->vbr_state.mode != VBR_MODE_2PASS_2)
encore(vf->priv->enc_handle, ENC_OPT_ENCODE, &vf->priv->enc_frame, &enc_result);
else {
encore(vf->priv->enc_handle, ENC_OPT_ENCODE_VBR, &vf->priv->enc_frame, &enc_result);
enc_result.quantizer = quant;
if (intra >= 0)
enc_result.is_key_frame = intra;
}
if (vbrUpdate(&vf->priv->vbr_state, enc_result.quantizer, enc_result.is_key_frame,
(enc_result.total_bits - enc_result.texture_bits) / 8, enc_result.total_bits / 8,
0, 0, 0) == -1)
abort();
}
else
#endif
if(pass==2){ // handle 2-pass:
vf->priv->enc_frame.quant = VbrControl_get_quant();
vf->priv->enc_frame.intra = VbrControl_get_intra();
encore(vf->priv->enc_handle,ENC_OPT_ENCODE_VBR,&vf->priv->enc_frame,&enc_result);
VbrControl_update_2pass_vbr_encoding(enc_result.motion_bits,
enc_result.texture_bits,
enc_result.total_bits);
} else {
vf->priv->enc_frame.quant=0;
vf->priv->enc_frame.intra=0;
encore(vf->priv->enc_handle,ENC_OPT_ENCODE,&vf->priv->enc_frame,&enc_result);
if(pass==1){
VbrControl_update_2pass_vbr_analysis(enc_result.is_key_frame,
enc_result.motion_bits,
enc_result.texture_bits,
enc_result.total_bits,
enc_result.quantizer);
}
}
muxer_write_chunk(mux_v,vf->priv->enc_frame.length,enc_result.is_key_frame?0x10:0);
#endif
return 1;
}
//===========================================================================//
static int vf_open(vf_instance_t *vf, char* args){
vf->config=config;
vf->control=control;
vf->query_format=query_format;
vf->put_image=put_image;
//#ifdef HAVE_XVID_VBR
vf->uninit = uninit;
//#endif
vf->priv=malloc(sizeof(struct vf_priv_s));
memset(vf->priv,0,sizeof(struct vf_priv_s));
vf->priv->mux=(muxer_stream_t*)args;
mux_v->bih=malloc(sizeof(BITMAPINFOHEADER));
mux_v->bih->biSize=sizeof(BITMAPINFOHEADER);
mux_v->bih->biWidth=0;
mux_v->bih->biHeight=0;
mux_v->bih->biPlanes=1;
mux_v->bih->biBitCount=24;
#if ENCORE_MAJOR_VERSION >= 5010
mux_v->bih->biCompression=mmioFOURCC('D','X','5','0');
#else
mux_v->bih->biCompression=mmioFOURCC('d','i','v','x');
#endif
return 1;
}
vf_info_t ve_info_divx4 = {
"divx4 encoder",
"divx4",
"A'rpi",
"for internal use by mencoder",
vf_open
};
//===========================================================================//
#endif
View Git Blame Copy Permalink