gstreamer/ext/ffmpeg/gstffmpegcfg.c
Wim Taymans 221ff7e482 ext/ffmpeg/gstffmpegcfg.c: Add h263 to the list of codecs using the mpeg flags and options.
Original commit message from CVS:
* ext/ffmpeg/gstffmpegcfg.c: (gst_ffmpeg_flags_get_type):
Add h263 to the list of codecs using the mpeg flags and options.
Add some more H263 specific flags. Fixes #421068.
2008-01-22 13:54:34 +00:00

1055 lines
37 KiB
C

/* GStreamer
*
* FFMpeg Configuration
*
* Copyright (C) <2006> Mark Nauwelaerts <manauw@skynet.be>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstffmpeg.h"
#include "gstffmpegenc.h"
#include <string.h>
/* some enums used in property declarations */
#define GST_TYPE_FFMPEG_PASS (gst_ffmpeg_pass_get_type ())
static GType
gst_ffmpeg_pass_get_type (void)
{
static GType ffmpeg_pass_type = 0;
if (!ffmpeg_pass_type) {
static const GEnumValue ffmpeg_passes[] = {
{0, "Constant Bitrate Encoding", "cbr"},
{CODEC_FLAG_QSCALE, "Constant Quantizer", "quant"},
{CODEC_FLAG_PASS1, "VBR Encoding - Pass 1", "pass1"},
{CODEC_FLAG_PASS2, "VBR Encoding - Pass 2", "pass2"},
{0, NULL, NULL},
};
ffmpeg_pass_type =
g_enum_register_static ("GstFFMpegEncPass", ffmpeg_passes);
}
return ffmpeg_pass_type;
}
#if 0
/* some do not support 2-pass */
#define GST_TYPE_FFMPEG_LIM_PASS (gst_ffmpeg_lim_pass_get_type ())
static GType
gst_ffmpeg_lim_pass_get_type (void)
{
static GType ffmpeg_lim_pass_type = 0;
if (!ffmpeg_lim_pass_type) {
static const GEnumValue ffmpeg_lim_passes[] = {
{0, "Constant Bitrate Encoding", "cbr"},
{CODEC_FLAG_QSCALE, "Constant Quantizer", "quant"},
{0, NULL, NULL},
};
ffmpeg_lim_pass_type =
g_enum_register_static ("GstFFMpegEncLimPass", ffmpeg_lim_passes);
}
return ffmpeg_lim_pass_type;
}
#endif
#define GST_TYPE_FFMPEG_MB_DECISION (gst_ffmpeg_mb_decision_get_type ())
static GType
gst_ffmpeg_mb_decision_get_type (void)
{
static GType ffmpeg_mb_decision_type = 0;
if (!ffmpeg_mb_decision_type) {
static const GEnumValue ffmpeg_mb_decisions[] = {
{FF_MB_DECISION_SIMPLE, "Use method set by mb-cmp", "simple"},
{FF_MB_DECISION_BITS,
"Chooses the one which needs the fewest bits aka vhq mode", "bits"},
{FF_MB_DECISION_RD, "Rate Distortion", "rd"},
{0, NULL, NULL},
};
ffmpeg_mb_decision_type =
g_enum_register_static ("GstFFMpegEncMBDecision", ffmpeg_mb_decisions);
}
return ffmpeg_mb_decision_type;
}
#define GST_TYPE_FFMPEG_CMP_FUNCTION (gst_ffmpeg_mb_cmp_get_type ())
static GType
gst_ffmpeg_mb_cmp_get_type (void)
{
static GType ffmpeg_mb_cmp_type = 0;
/* TODO fill out remaining values */
if (!ffmpeg_mb_cmp_type) {
static const GEnumValue ffmpeg_mb_cmps[] = {
{FF_CMP_SAD, "Sum of Absolute Differences", "sad"},
{FF_CMP_SSE, "Sum of Squared Errors", "sse"},
{FF_CMP_SATD, "Sum of Absolute Hadamard Transformed Differences", "satd"},
{FF_CMP_DCT, "Sum of Absolute DCT Transformed Differences", "dct"},
{FF_CMP_PSNR, "Sum of the Squared Quantization Errors", "psnr"},
{FF_CMP_BIT, "Sum of the Bits needed for the block", "bit"},
{FF_CMP_RD, "Rate Distortion optimal", "rd"},
{FF_CMP_ZERO, "ZERO", "zero"},
{FF_CMP_VSAD, "VSAD", "vsad"},
{FF_CMP_VSSE, "VSSE", "vsse"},
#if 0
/* economize a bit for now */
{FF_CMP_NSSE, "NSSE", "nsse"},
{FF_CMP_W53, "W53", "w53"},
{FF_CMP_W97, "W97", "w97"},
#endif
{0, NULL, NULL},
};
ffmpeg_mb_cmp_type =
g_enum_register_static ("GstFFMpegCMPFunction", ffmpeg_mb_cmps);
}
return ffmpeg_mb_cmp_type;
}
#define GST_TYPE_FFMPEG_DCT_ALGO (gst_ffmpeg_dct_algo_get_type ())
static GType
gst_ffmpeg_dct_algo_get_type (void)
{
static GType ffmpeg_dct_algo_type = 0;
if (!ffmpeg_dct_algo_type) {
static const GEnumValue ffmpeg_dct_algos[] = {
{FF_DCT_AUTO, "Automatically select a good one", "auto"},
{FF_DCT_FASTINT, "Fast Integer", "fastint"},
{FF_DCT_INT, "Accurate Integer", "int"},
{FF_DCT_MMX, "MMX", "mmx"},
{FF_DCT_MLIB, "MLIB", "mlib"},
{FF_DCT_ALTIVEC, "ALTIVEC", "altivec"},
{FF_DCT_FAAN, "FAAN", "faan"},
{0, NULL, NULL},
};
ffmpeg_dct_algo_type =
g_enum_register_static ("GstFFMpegDCTAlgo", ffmpeg_dct_algos);
}
return ffmpeg_dct_algo_type;
}
#define GST_TYPE_FFMPEG_IDCT_ALGO (gst_ffmpeg_idct_algo_get_type ())
static GType
gst_ffmpeg_idct_algo_get_type (void)
{
static GType ffmpeg_idct_algo_type = 0;
if (!ffmpeg_idct_algo_type) {
static const GEnumValue ffmpeg_idct_algos[] = {
{FF_IDCT_AUTO, "Automatically select a good one", "auto"},
{FF_IDCT_INT, "JPEG reference Integer", "int"},
{FF_IDCT_SIMPLE, "Simple", "simple"},
{FF_IDCT_SIMPLEMMX, "Simple MMX", "simplemmx"},
{FF_IDCT_LIBMPEG2MMX, "LIBMPEG2MMX", "libmpeg2mmx"},
{FF_IDCT_PS2, "PS2", "ps2"},
{FF_IDCT_MLIB, "MLIB", "mlib"},
{FF_IDCT_ARM, "ARM", "arm"},
{FF_IDCT_ALTIVEC, "ALTIVEC", "altivec"},
{FF_IDCT_SH4, "SH4", "sh4"},
{FF_IDCT_SIMPLEARM, "SIMPLEARM", "simplearm"},
{FF_IDCT_H264, "H264", "h264"},
{FF_IDCT_VP3, "VP3", "vp3"},
{FF_IDCT_IPP, "IPP", "ipp"},
{FF_IDCT_XVIDMMX, "XVIDMMX", "xvidmmx"},
{0, NULL, NULL},
};
ffmpeg_idct_algo_type =
g_enum_register_static ("GstFFMpegIDCTAlgo", ffmpeg_idct_algos);
}
return ffmpeg_idct_algo_type;
}
#define GST_TYPE_FFMPEG_QUANT_TYPE (gst_ffmpeg_quant_type_get_type ())
static GType
gst_ffmpeg_quant_type_get_type (void)
{
static GType ffmpeg_quant_type_type = 0;
if (!ffmpeg_quant_type_type) {
static const GEnumValue ffmpeg_quant_types[] = {
{0, "H263 quantization", "h263"},
{1, "MPEG quantization", "mpeg"},
{0, NULL, NULL},
};
ffmpeg_quant_type_type =
g_enum_register_static ("GstFFMpegEncQuantTypes", ffmpeg_quant_types);
}
return ffmpeg_quant_type_type;
}
#define GST_TYPE_FFMPEG_PRE_ME (gst_ffmpeg_pre_me_get_type ())
static GType
gst_ffmpeg_pre_me_get_type (void)
{
static GType ffmpeg_pre_me_type = 0;
if (!ffmpeg_pre_me_type) {
static const GEnumValue ffmpeg_pre_mes[] = {
{0, "Disabled", "off"},
{1, "Only after I-frames", "key"},
{2, "Always", "all"},
{0, NULL, NULL}
};
ffmpeg_pre_me_type =
g_enum_register_static ("GstFFMpegEncPreME", ffmpeg_pre_mes);
}
return ffmpeg_pre_me_type;
}
#define GST_TYPE_FFMPEG_PRED_METHOD (gst_ffmpeg_pred_method_get_type ())
static GType
gst_ffmpeg_pred_method_get_type (void)
{
static GType ffmpeg_pred_method = 0;
if (!ffmpeg_pred_method) {
static const GEnumValue ffmpeg_pred_methods[] = {
{FF_PRED_LEFT, "Left", "left"},
{FF_PRED_PLANE, "Plane", "plane"},
{FF_PRED_MEDIAN, "Median", "median"},
{0, NULL, NULL}
};
ffmpeg_pred_method =
g_enum_register_static ("GstFFMpegEncPredMethod", ffmpeg_pred_methods);
}
return ffmpeg_pred_method;
}
#define GST_TYPE_FFMPEG_FLAGS (gst_ffmpeg_flags_get_type())
static GType
gst_ffmpeg_flags_get_type (void)
{
static GType ffmpeg_flags_type = 0;
if (!ffmpeg_flags_type) {
static const GFlagsValue ffmpeg_flags[] = {
{CODEC_FLAG_4MV, "Allow 4 MV per MB", "4mv"},
{CODEC_FLAG_H263P_AIV, "H.263 alternative inter VLC", "aiv"},
{CODEC_FLAG_QPEL, "Quartel Pel Motion Compensation", "qpel"},
{CODEC_FLAG_GMC, "GMC", "gmc"},
{CODEC_FLAG_MV0, "Always try a MB with MV (0,0)", "mv0"},
{CODEC_FLAG_PART,
"Store MV, DC and AC coefficients in seperate partitions", "part"},
{CODEC_FLAG_GRAY, "Only decode/encode grayscale", "gray"},
{CODEC_FLAG_NORMALIZE_AQP,
"Normalize Adaptive Quantization (masking, etc)", "aqp"},
{CODEC_FLAG_TRELLIS_QUANT, "Trellis Quantization", "trellis"},
{CODEC_FLAG_GLOBAL_HEADER,
"Global headers in extradata instead of every keyframe",
"global-headers"},
{CODEC_FLAG_AC_PRED, "H263 Advanced Intra Coding / MPEG4 AC prediction",
"aic"},
{CODEC_FLAG_H263P_UMV, "Unlimited Motion Vector", "umv"},
{CODEC_FLAG_CBP_RD, "Rate Distoration Optimization for CBP", "cbp-rd"},
{CODEC_FLAG_QP_RD, "Rate Distoration Optimization for QP selection",
"qp-rd"},
{CODEC_FLAG_H263P_SLICE_STRUCT, "H263 slice struct", "ss"},
{CODEC_FLAG_SVCD_SCAN_OFFSET,
"Reserve space for SVCD scan offset user data", "scanoffset"},
{CODEC_FLAG_CLOSED_GOP, "Closed GOP", "closedgop"},
{0, NULL, NULL},
};
ffmpeg_flags_type =
g_flags_register_static ("GstFFMpegFlags", ffmpeg_flags);
}
return ffmpeg_flags_type;
}
/* provides additional info to attach to a property */
typedef struct _GParamSpecData GParamSpecData;
struct _GParamSpecData
{
/* offset of member in the element struct that stores the property */
guint offset;
/* size of the above member */
guint size;
/* if TRUE, try to get the default from lavc and ignore the paramspec default */
gboolean lavc_default;
/* these lists are arrays terminated by CODEC_ID_NONE entry:
* property applies to a codec if it's not in the exclude_list
* and in exclude_list (or the latter is NULL) */
gint *include_list;
gint *exclude_list;
};
/* properties whose member offset is higher than the config base
* can be copied directly at context configuration time;
* and can also retrieve a default value from lavc */
#define CONTEXT_CONFIG_OFFSET G_STRUCT_OFFSET (GstFFMpegEnc, config)
/* additional info is named pointer specified by the quark */
static GQuark quark;
/* central configuration store:
* list of GParamSpec's with GParamSpecData attached as named pointer */
static GList *property_list;
/* add the GParamSpec pspec to store with GParamSpecData
* constructed from struct_type, member, default and include and exclude */
#define gst_ffmpeg_add_pspec_full(pspec, store, struct_type, member, \
default, include, exclude) \
G_STMT_START { \
GParamSpecData *_qdata = g_new0 (GParamSpecData, 1); \
GstFFMpegEnc _enc; \
_qdata->offset = G_STRUCT_OFFSET (struct_type, member); \
_qdata->size = sizeof (_enc.member); \
_qdata->lavc_default = default; \
_qdata->include_list = include; \
_qdata->exclude_list = exclude; \
g_param_spec_set_qdata_full (pspec, quark, _qdata, g_free); \
store = g_list_append (store, pspec); \
} G_STMT_END
#define gst_ffmpeg_add_pspec(pspec, member, default, include, exclude) \
gst_ffmpeg_add_pspec_full (pspec, property_list, GstFFMpegEnc, member, \
default, include, exclude)
/* ==== BEGIN CONFIGURATION SECTION ==== */
/* some typical include and exclude lists; modify and/or add where needed */
static gint mpeg[] = {
CODEC_ID_MPEG4,
CODEC_ID_MSMPEG4V1,
CODEC_ID_MSMPEG4V2,
CODEC_ID_MSMPEG4V3,
CODEC_ID_MPEG1VIDEO,
CODEC_ID_MPEG2VIDEO,
CODEC_ID_H263P,
CODEC_ID_FLV1,
CODEC_ID_NONE
};
static gint huffyuv[] = {
CODEC_ID_HUFFYUV,
CODEC_ID_FFVHUFF,
CODEC_ID_NONE
};
/* Properties should be added here for registration into the config store.
* Note that some may occur more than once, with different include/exclude lists,
* as some may require different defaults for different codecs,
* or some may have slightly varying enum-types with more or less options.
* The enum-types themselves should be declared above. */
void
gst_ffmpeg_cfg_init ()
{
GParamSpec *pspec;
/* initialize global config vars */
quark = g_quark_from_static_string ("ffmpeg-cfg-param-spec-data");
property_list = NULL;
/* list properties here */
pspec = g_param_spec_enum ("pass", "Encoding pass/type",
"Encoding pass/type", GST_TYPE_FFMPEG_PASS, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, pass, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("quantizer", "Constant Quantizer",
"Constant Quantizer", 0, 30, 0.01f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, quantizer, FALSE, mpeg, NULL);
pspec = g_param_spec_string ("statsfile", "Statistics Filename",
"Filename to store data for 2-pass encoding", "stats.log",
G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, filename, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("bitrate-tolerance", "Bitrate Tolerance",
"Number of bits the bitstream is allowed to diverge from the reference",
0, 100000000, 8000000, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.bit_rate_tolerance, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("mb-decision", "Macroblock Decision",
"Macroblok Decision Mode",
GST_TYPE_FFMPEG_MB_DECISION, FF_CMP_SAD, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.mb_decision, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("mb-cmp", "Macroblock Compare Function",
"Macroblok Compare Function",
GST_TYPE_FFMPEG_CMP_FUNCTION, FF_CMP_SAD, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.mb_cmp, FALSE, mpeg, NULL);
pspec =
g_param_spec_enum ("me-pre-cmp",
"Motion Estimation Pre Pass Compare Function",
"Motion Estimation Pre Pass Compare Function",
GST_TYPE_FFMPEG_CMP_FUNCTION, FF_CMP_SAD, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.me_pre_cmp, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("me-cmp", "Motion Estimation Compare Function",
"Motion Estimation Compare Function",
GST_TYPE_FFMPEG_CMP_FUNCTION, FF_CMP_SAD, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.me_cmp, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("me-sub-cmp",
"Subpixel Motion Estimation Compare Function",
"Subpixel Motion Estimation Compare Function",
GST_TYPE_FFMPEG_CMP_FUNCTION, FF_CMP_SAD, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.me_sub_cmp, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("ildct-cmp", "Interlaced DCT Compare Function",
"Interlaced DCT Compare Function",
GST_TYPE_FFMPEG_CMP_FUNCTION, FF_CMP_VSAD, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.ildct_cmp, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("dct-algo", "DCT Algorithm",
"DCT Algorithm",
GST_TYPE_FFMPEG_DCT_ALGO, FF_DCT_AUTO, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.dct_algo, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("idct-algo", "IDCT Algorithm",
"IDCT Algorithm",
GST_TYPE_FFMPEG_IDCT_ALGO, FF_IDCT_AUTO, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.idct_algo, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("quant-type", "Quantizer Type",
"Quantizer Type", GST_TYPE_FFMPEG_QUANT_TYPE, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.mpeg_quant, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("qmin", "Minimum Quantizer",
"Minimum Quantizer", 1, 31, 2, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.qmin, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("qmax", "Maximum Quantizer",
"Maximum Quantizer", 1, 31, 31, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.qmax, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("max-qdiff", "Maximum Quantizer Difference",
"Maximum Quantizer Difference between frames",
1, 31, 3, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.max_qdiff, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("mb_qmin", "Minimum MB Quantizer",
"Minimum MB Quantizer", 0, 31, 2, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.mb_qmin, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("mb_qmax", "Maximum MB Quantizer",
"Maximum MB Quantizer", 0, 31, 31, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.mb_qmax, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("lmin", "Minimum Lagrange Multiplier",
"Minimum Lagrange Multiplier", 1, 31, 2, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, lmin, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("lmax", "Maximum Lagrange Multiplier",
"Maximum Lagrange Multiplier", 1, 31, 31, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, lmax, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("qcompress", "Quantizer Change",
"Quantizer Change between easy and hard scenes",
0, 1.0f, 0.5f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.qcompress, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("qblur", "Quantizer Smoothing",
"Quantizer Smoothing over time", 0, 1.0f, 0.5f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.qblur, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("rc-qsquish", "Ratecontrol Limiting Method",
"0 means limit by clipping, otherwise use nice continuous function",
0, 99.0f, 1.0f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.rc_qsquish, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("rc-qmod-amp", "Ratecontrol Mod",
"Ratecontrol Mod", 0, 99.0f, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.rc_qmod_amp, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("rc-qmod-freq", "Ratecontrol Freq",
"Ratecontrol Freq", 0, 0, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.rc_qmod_freq, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("rc-buffer-size", "Ratecontrol Buffer Size",
"Decoder bitstream buffer size", 0, G_MAXINT, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.rc_buffer_size, FALSE, mpeg, NULL);
pspec =
g_param_spec_float ("rc-buffer-aggressivity",
"Ratecontrol Buffer Aggressivity", "Ratecontrol Buffer Aggressivity", 0,
99.0f, 1.0f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.rc_buffer_aggressivity, FALSE, mpeg,
NULL);
pspec = g_param_spec_int ("rc-max-rate", "Ratecontrol Maximum Bitrate",
"Ratecontrol Maximum Bitrate", 0, G_MAXINT, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.rc_max_rate, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("rc-min-rate", "Ratecontrol Minimum Bitrate",
"Ratecontrol Minimum Bitrate", 0, G_MAXINT, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.rc_min_rate, FALSE, mpeg, NULL);
pspec =
g_param_spec_float ("rc-initial-cplx",
"Initial Complexity for Pass 1 Ratecontrol",
"Initial Complexity for Pass 1 Ratecontrol", 0, 9999999.0f, 0,
G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.rc_initial_cplx, FALSE, mpeg, NULL);
pspec = g_param_spec_string ("rc-eq", "Ratecontrol Equation",
"Ratecontrol Equation", "tex^qComp", G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.rc_eq, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("b-quant-factor", "B-Quantizer Factor",
"Factor in B-Frame Quantizer Computation",
-31.0f, 31.0f, 1.25f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.b_quant_factor, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("b-quant-offset", "B-Quantizer Offset",
"Offset in B-Frame Quantizer Computation",
0.0f, 31.0f, 1.25f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.b_quant_offset, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("i-quant-factor", "I-Quantizer Factor",
"Factor in P-Frame Quantizer Computation",
-31.0f, 31.0f, 0.8f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.i_quant_factor, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("i-quant-offset", "I-Quantizer Offset",
"Offset in P-Frame Quantizer Computation",
0.0f, 31.0f, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.i_quant_offset, FALSE, mpeg, NULL);
/* note overlap with gop-size; 0 means do not override */
pspec = g_param_spec_int ("max-key-interval", "Maximum Key Interval",
"Maximum number of frames between two keyframes (< 0 is in sec)",
-100, G_MAXINT, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, max_key_interval, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("luma-elim-threshold",
"Luma Elimination Threshold",
"Luma Single Coefficient Elimination Threshold",
-99, 99, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.luma_elim_threshold, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("chroma-elim-threshold",
"Chroma Elimination Threshold",
"Chroma Single Coefficient Elimination Threshold",
-99, 99, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.chroma_elim_threshold, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("lumi-masking", "Luminance Masking",
"Luminance Masking", -1.0f, 1.0f, 0.0f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.lumi_masking, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("dark-masking", "Darkness Masking",
"Darkness Masking", -1.0f, 1.0f, 0.0f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.dark_masking, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("temporal-cplx-masking",
"Temporal Complexity Masking",
"Temporal Complexity Masking", -1.0f, 1.0f, 0.0f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.temporal_cplx_masking, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("spatial-cplx-masking",
"Spatial Complexity Masking",
"Spatial Complexity Masking", -1.0f, 1.0f, 0.0f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.spatial_cplx_masking, FALSE, mpeg, NULL);
pspec = g_param_spec_float ("p-masking", "P Block Masking",
"P Block Masking", -1.0f, 1.0f, 0.0f, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.p_masking, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("dia-size",
"Motion Estimation Diamond Size/Shape",
"Motion Estimation Diamond Size/Shape",
-2000, 2000, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.dia_size, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("pre-dia-size",
"Motion Estimation Pre Pass Diamond Size/Shape",
"Motion Estimation Diamond Size/Shape",
-2000, 2000, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.pre_dia_size, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("last-predictor-count",
"Last Predictor Count",
"Amount of previous Motion Vector predictors",
0, 2000, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.last_predictor_count, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("pre-me",
"Pre Pass for Motion Estimation",
"Pre Pass for Motion Estimation",
GST_TYPE_FFMPEG_PRE_ME, 1, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.pre_me, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("me-subpel-quality",
"Motion Estimation Subpixel Quality",
"Motion Estimation Subpixel Refinement Quality",
0, 8, 8, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.me_subpel_quality, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("me-range",
"Motion Estimation Range",
"Motion Estimation search range in subpel units",
0, 16000, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.me_range, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("intra-quant-bias",
"Intra Quantizer Bias",
"Intra Quantizer Bias",
-1000000, 1000000, FF_DEFAULT_QUANT_BIAS, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.intra_quant_bias, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("inter-quant-bias",
"Inter Quantizer Bias",
"Inter Quantizer Bias",
-1000000, 1000000, FF_DEFAULT_QUANT_BIAS, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.inter_quant_bias, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("noise-reduction",
"Noise Reduction",
"Noise Reduction Strength", 0, 1000000, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.noise_reduction, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("intra-dc-precision",
"Intra DC precision",
"Precision of the Intra DC coefficient - 8", 0, 16, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.intra_dc_precision, FALSE, mpeg, NULL);
/* TODO skipped coder_type, context_model, inter_threshold, scenechange_threshold */
pspec = g_param_spec_flags ("flags", "Flags",
"Flags", GST_TYPE_FFMPEG_FLAGS, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.flags, FALSE, mpeg, NULL);
pspec = g_param_spec_boolean ("interlaced", "Interlaced Material",
"Interlaced Material", FALSE, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, interlaced, FALSE, mpeg, NULL);
pspec = g_param_spec_int ("max-bframes", "Max B-Frames",
"Maximum B-frames in a row", 0, FF_MAX_B_FRAMES, 0, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.max_b_frames, FALSE, mpeg, NULL);
pspec = g_param_spec_enum ("prediction-method", "Prediction Method",
"Prediction Method",
GST_TYPE_FFMPEG_PRED_METHOD, FF_PRED_LEFT, G_PARAM_READWRITE);
gst_ffmpeg_add_pspec (pspec, config.prediction_method, FALSE, huffyuv, NULL);
}
/* ==== END CONFIGURATION SECTION ==== */
/* return TRUE if property described by pspec applies to the codec with codec_id */
static gboolean
gst_ffmpeg_cfg_codec_has_pspec (enum CodecID codec_id, GParamSpec * pspec)
{
GParamSpecData *qdata;
gint *codec;
gboolean ret = FALSE;
qdata = g_param_spec_get_qdata (pspec, quark);
/* check if excluded first */
if ((codec = qdata->exclude_list)) {
for (; *codec != CODEC_ID_NONE; ++codec) {
if (*codec == codec_id)
return FALSE;
}
}
/* no include list means it is accepted */
if ((codec = qdata->include_list)) {
for (; *codec != CODEC_ID_NONE; ++codec) {
if (*codec == codec_id)
ret = TRUE;
}
} else {
ret = TRUE;
}
return ret;
}
/* install all properties for klass that have been registered in property_list */
void
gst_ffmpeg_cfg_install_property (GstFFMpegEncClass * klass, guint base)
{
GParamSpec *pspec;
GList *list;
gint prop_id;
AVCodecContext *ctx;
prop_id = base;
g_return_if_fail (base > 0);
ctx = avcodec_alloc_context ();
if (ctx)
avcodec_get_context_defaults (ctx);
else
g_warning ("could not get context");
for (list = property_list; list; list = list->next) {
pspec = G_PARAM_SPEC (list->data);
if (gst_ffmpeg_cfg_codec_has_pspec (klass->in_plugin->id, pspec)) {
/* 'clone' the paramspec for the various codecs,
* since a single paramspec cannot be owned by distinct types */
const gchar *name = g_param_spec_get_name (pspec);
const gchar *nick = g_param_spec_get_nick (pspec);
const gchar *blurb = g_param_spec_get_blurb (pspec);
GParamSpecData *qdata = g_param_spec_get_qdata (pspec, quark);
gint ctx_offset = 0;
gboolean lavc_default;
/* cannot obtain lavc default if no context */
if (!ctx)
lavc_default = FALSE;
else {
ctx_offset = qdata->offset - CONTEXT_CONFIG_OFFSET;
/* safety check; is it really member of the avcodec context */
if (ctx_offset < 0)
lavc_default = FALSE;
else
lavc_default = qdata->lavc_default;
}
switch (G_PARAM_SPEC_VALUE_TYPE (pspec)) {
case G_TYPE_STRING:{
GParamSpecString *pstring = G_PARAM_SPEC_STRING (pspec);
pspec = g_param_spec_string (name, nick, blurb,
lavc_default ? G_STRUCT_MEMBER (gchar *, ctx, ctx_offset)
: pstring->default_value, pspec->flags);
break;
}
case G_TYPE_INT:{
GParamSpecInt *pint = G_PARAM_SPEC_INT (pspec);
pspec = g_param_spec_int (name, nick, blurb,
pint->minimum, pint->maximum,
lavc_default ? G_STRUCT_MEMBER (gint, ctx, ctx_offset)
: pint->default_value, pspec->flags);
break;
}
case G_TYPE_UINT:{
GParamSpecUInt *puint = G_PARAM_SPEC_UINT (pspec);
pspec = g_param_spec_uint (name, nick, blurb,
puint->minimum, puint->maximum,
lavc_default ? G_STRUCT_MEMBER (guint, ctx, ctx_offset)
: puint->default_value, pspec->flags);
break;
}
case G_TYPE_ULONG:{
GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (pspec);
pspec = g_param_spec_ulong (name, nick, blurb,
pulong->minimum, pulong->maximum,
lavc_default ? G_STRUCT_MEMBER (gulong, ctx, ctx_offset)
: pulong->default_value, pspec->flags);
break;
}
case G_TYPE_FLOAT:{
GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (pspec);
pspec = g_param_spec_float (name, nick, blurb,
pfloat->minimum, pfloat->maximum,
lavc_default ? G_STRUCT_MEMBER (gfloat, ctx, ctx_offset)
: pfloat->default_value, pspec->flags);
break;
}
case G_TYPE_BOOLEAN:{
GParamSpecBoolean *pboolean = G_PARAM_SPEC_BOOLEAN (pspec);
pspec = g_param_spec_boolean (name, nick, blurb,
lavc_default ? G_STRUCT_MEMBER (gboolean, ctx, ctx_offset)
: pboolean->default_value, pspec->flags);
break;
}
default:
if (G_IS_PARAM_SPEC_ENUM (pspec)) {
GParamSpecEnum *penum = G_PARAM_SPEC_ENUM (pspec);
pspec = g_param_spec_enum (name, nick, blurb,
pspec->value_type,
lavc_default ? G_STRUCT_MEMBER (gint, ctx, ctx_offset)
: penum->default_value, pspec->flags);
} else if (G_IS_PARAM_SPEC_FLAGS (pspec)) {
GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (pspec);
pspec = g_param_spec_flags (name, nick, blurb,
pspec->value_type,
lavc_default ? G_STRUCT_MEMBER (guint, ctx, ctx_offset)
: pflags->default_value, pspec->flags);
} else {
g_critical ("%s does not yet support type %s", GST_FUNCTION,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
continue;
}
break;
}
g_param_spec_set_qdata (pspec, quark, qdata);
g_object_class_install_property (G_OBJECT_CLASS (klass), prop_id, pspec);
++prop_id;
}
}
if (ctx)
av_free (ctx);
}
/* returns TRUE if it is a known property for this config system,
* FALSE otherwise */
gboolean
gst_ffmpeg_cfg_set_property (GObject * object,
const GValue * value, GParamSpec * pspec)
{
GstFFMpegEnc *ffmpegenc = (GstFFMpegEnc *) (object);
GParamSpecData *qdata;
qdata = g_param_spec_get_qdata (pspec, quark);
/* our param specs should have such qdata */
if (!qdata)
return FALSE;
/* set the member using the offset, also mild type check based on size */
switch (G_PARAM_SPEC_VALUE_TYPE (pspec)) {
case G_TYPE_BOOLEAN:
g_return_val_if_fail (qdata->size == sizeof (gboolean), TRUE);
G_STRUCT_MEMBER (gboolean, ffmpegenc, qdata->offset) =
g_value_get_boolean (value);
break;
case G_TYPE_UINT:
g_return_val_if_fail (qdata->size == sizeof (guint), TRUE);
G_STRUCT_MEMBER (guint, ffmpegenc, qdata->offset) =
g_value_get_uint (value);
break;
case G_TYPE_INT:
g_return_val_if_fail (qdata->size == sizeof (gint), TRUE);
G_STRUCT_MEMBER (gint, ffmpegenc, qdata->offset) =
g_value_get_int (value);
break;
case G_TYPE_ULONG:
g_return_val_if_fail (qdata->size == sizeof (gulong), TRUE);
G_STRUCT_MEMBER (glong, ffmpegenc, qdata->offset) =
g_value_get_ulong (value);
break;
case G_TYPE_FLOAT:
g_return_val_if_fail (qdata->size == sizeof (gfloat), TRUE);
G_STRUCT_MEMBER (gfloat, ffmpegenc, qdata->offset) =
g_value_get_float (value);
break;
case G_TYPE_STRING:
g_return_val_if_fail (qdata->size == sizeof (gchar *), TRUE);
g_free (G_STRUCT_MEMBER (gchar *, ffmpegenc, qdata->offset));
G_STRUCT_MEMBER (gchar *, ffmpegenc, qdata->offset) =
g_value_dup_string (value);
break;
default: /* must be enum, given the check above */
if (G_IS_PARAM_SPEC_ENUM (pspec)) {
g_return_val_if_fail (qdata->size == sizeof (gint), TRUE);
G_STRUCT_MEMBER (gint, ffmpegenc, qdata->offset) =
g_value_get_enum (value);
} else if (G_IS_PARAM_SPEC_FLAGS (pspec)) {
g_return_val_if_fail (qdata->size == sizeof (guint), TRUE);
G_STRUCT_MEMBER (guint, ffmpegenc, qdata->offset) =
g_value_get_flags (value);
} else { /* oops, bit lazy we don't cover this case yet */
g_critical ("%s does not yet support type %s", GST_FUNCTION,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
}
break;
}
return TRUE;
}
/* returns TRUE if it is a known property for this config system,
* FALSE otherwise */
gboolean
gst_ffmpeg_cfg_get_property (GObject * object,
GValue * value, GParamSpec * pspec)
{
GstFFMpegEnc *ffmpegenc = (GstFFMpegEnc *) (object);
GParamSpecData *qdata;
qdata = g_param_spec_get_qdata (pspec, quark);
/* our param specs should have such qdata */
if (!qdata)
return FALSE;
/* get the member using the offset, also mild type check based on size */
switch (G_PARAM_SPEC_VALUE_TYPE (pspec)) {
case G_TYPE_BOOLEAN:
g_return_val_if_fail (qdata->size == sizeof (gboolean), TRUE);
g_value_set_boolean (value,
G_STRUCT_MEMBER (gboolean, ffmpegenc, qdata->offset));
break;
case G_TYPE_UINT:
g_return_val_if_fail (qdata->size == sizeof (guint), TRUE);
g_value_set_uint (value,
G_STRUCT_MEMBER (guint, ffmpegenc, qdata->offset));
break;
case G_TYPE_INT:
g_return_val_if_fail (qdata->size == sizeof (gint), TRUE);
g_value_set_int (value, G_STRUCT_MEMBER (gint, ffmpegenc, qdata->offset));
break;
case G_TYPE_ULONG:
g_return_val_if_fail (qdata->size == sizeof (gulong), TRUE);
g_value_set_ulong (value,
G_STRUCT_MEMBER (glong, ffmpegenc, qdata->offset));
break;
case G_TYPE_FLOAT:
g_return_val_if_fail (qdata->size == sizeof (gfloat), TRUE);
g_value_set_float (value,
G_STRUCT_MEMBER (gfloat, ffmpegenc, qdata->offset));
break;
case G_TYPE_STRING:
g_return_val_if_fail (qdata->size == sizeof (gchar *), TRUE);
g_value_take_string (value,
g_strdup (G_STRUCT_MEMBER (gchar *, ffmpegenc, qdata->offset)));
break;
default: /* must be enum, given the check above */
if (G_IS_PARAM_SPEC_ENUM (pspec)) {
g_return_val_if_fail (qdata->size == sizeof (gint), TRUE);
g_value_set_enum (value,
G_STRUCT_MEMBER (gint, ffmpegenc, qdata->offset));
} else if (G_IS_PARAM_SPEC_FLAGS (pspec)) {
g_return_val_if_fail (qdata->size == sizeof (guint), TRUE);
g_value_set_flags (value,
G_STRUCT_MEMBER (guint, ffmpegenc, qdata->offset));
} else { /* oops, bit lazy we don't cover this case yet */
g_critical ("%s does not yet support type %s", GST_FUNCTION,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
}
break;
}
return TRUE;
}
void
gst_ffmpeg_cfg_set_defaults (GstFFMpegEnc * ffmpegenc)
{
GParamSpec **pspecs;
guint num_props, i;
pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (ffmpegenc),
&num_props);
for (i = 0; i < num_props; ++i) {
GValue val = { 0, };
GParamSpec *pspec = pspecs[i];
/* only touch those that are really ours; i.e. should have some qdata */
if (!g_param_spec_get_qdata (pspec, quark))
continue;
g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_param_value_set_default (pspec, &val);
g_object_set_property (G_OBJECT (ffmpegenc),
g_param_spec_get_name (pspec), &val);
g_value_unset (&val);
}
g_free (pspecs);
}
void
gst_ffmpeg_cfg_fill_context (GstFFMpegEnc * ffmpegenc, AVCodecContext * context)
{
GstFFMpegEncClass *klass
= (GstFFMpegEncClass *) G_OBJECT_GET_CLASS (ffmpegenc);
GParamSpec *pspec;
GParamSpecData *qdata;
GList *list;
list = property_list;
while (list) {
gint context_offset;
pspec = G_PARAM_SPEC (list->data);
qdata = g_param_spec_get_qdata (pspec, quark);
context_offset = qdata->offset - CONTEXT_CONFIG_OFFSET;
if (gst_ffmpeg_cfg_codec_has_pspec (klass->in_plugin->id, pspec)
&& context_offset >= 0) {
/* memcpy a bit heavy for a small copy, but hardly part of 'inner loop' */
memcpy (G_STRUCT_MEMBER_P (context, context_offset),
G_STRUCT_MEMBER_P (ffmpegenc, qdata->offset), qdata->size);
}
list = list->next;
}
}
void
gst_ffmpeg_cfg_finalize (GstFFMpegEnc * ffmpegenc)
{
GParamSpec **pspecs;
guint num_props, i;
pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (ffmpegenc),
&num_props);
for (i = 0; i < num_props; ++i) {
GParamSpec *pspec = pspecs[i];
GParamSpecData *qdata;
qdata = g_param_spec_get_qdata (pspec, quark);
/* our param specs should have such qdata */
if (!qdata)
continue;
switch (G_PARAM_SPEC_VALUE_TYPE (pspec)) {
case G_TYPE_STRING:
if (qdata->size == sizeof (gchar *)) {
g_free (G_STRUCT_MEMBER (gchar *, ffmpegenc, qdata->offset));
G_STRUCT_MEMBER (gchar *, ffmpegenc, qdata->offset) = NULL;
}
break;
default:
break;
}
}
g_free (pspecs);
}