diff options
Diffstat (limited to 'ext/mpeg2enc/gstmpeg2encoptions.cc')
| -rw-r--r-- | ext/mpeg2enc/gstmpeg2encoptions.cc | 703 |
1 files changed, 703 insertions, 0 deletions
diff --git a/ext/mpeg2enc/gstmpeg2encoptions.cc b/ext/mpeg2enc/gstmpeg2encoptions.cc new file mode 100644 index 00000000..5dbf9ac7 --- /dev/null +++ b/ext/mpeg2enc/gstmpeg2encoptions.cc @@ -0,0 +1,703 @@ +/* GStreamer mpeg2enc (mjpegtools) wrapper + * (c) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net> + * + * gstmpeg2encoptions.cc: gobject/mpeg2enc option wrapping class + * + * 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 "gstmpeg2encoptions.hh" + +/* + * Property enumeration. + */ + +enum { + ARG_0, + ARG_FORMAT, + ARG_FRAMERATE, + ARG_ASPECT, + ARG_INTERLACE_MODE, + ARG_BITRATE, + ARG_NONVIDEO_BITRATE, + ARG_QUANTISATION, + ARG_VCD_STILL_SIZE, + ARG_MOTION_SEARCH_RADIUS, + ARG_REDUCTION_4_4, + ARG_REDUCTION_2_2, + ARG_UNIT_COEFF_ELIM, + ARG_MIN_GOP_SIZE, + ARG_MAX_GOP_SIZE, + ARG_CLOSED_GOP, + ARG_FORCE_B_B_P, + ARG_B_PER_REFFRAME, + ARG_QUANTISATION_REDUCTION, + ARG_QUANT_REDUCTION_MAX_VAR, + ARG_INTRA_DC_PRECISION, + ARG_REDUCE_HF, + ARG_KEEP_HF, + ARG_QUANTISATION_MATRIX, + ARG_BUFSIZE, + ARG_VIDEO_NORM, + ARG_SEQUENCE_LENGTH, + ARG_3_2_PULLDOWN, + ARG_SEQUENCE_HEADER_EVERY_GOP, + ARG_PLAYBACK_FIELD_ORDER, + ARG_DUMMY_SVCD_SOF, + ARG_CORRECT_SVCD_HDS, + ARG_ALTSCAN_MPEG2, + ARG_CONSTRAINTS + /* FILL ME */ +}; + +/* + * Property enumeration types. + */ + +#define GST_TYPE_MPEG2ENC_FORMAT \ + (gst_mpeg2enc_format_get_type ()) + +static GType +gst_mpeg2enc_format_get_type (void) +{ + static GType mpeg2enc_format_type = 0; + + if (!mpeg2enc_format_type) { + static const GEnumValue mpeg2enc_formats[] = { + { 0, "0", "Generic MPEG-1" }, + { 1, "1", "Standard VCD" }, + { 2, "2", "User VCD" }, + { 3, "3", "Generic MPEG-2" }, + { 4, "4", "Standard SVCD" }, + { 5, "5", "User SVCD" }, + { 6, "6", "VCD Stills sequences" }, + { 7, "7", "SVCD Stills sequences" }, + { 8, "8", "DVD MPEG-2 for dvdauthor" }, + { 9, "9", "DVD MPEG-2" }, + { 0, NULL, NULL }, + }; + + mpeg2enc_format_type = + g_enum_register_static ("GstMpeg2encFormat", + mpeg2enc_formats); + } + + return mpeg2enc_format_type; +} + +#define GST_TYPE_MPEG2ENC_FRAMERATE \ + (gst_mpeg2enc_framerate_get_type ()) + +static GType +gst_mpeg2enc_framerate_get_type (void) +{ + static GType mpeg2enc_framerate_type = 0; + + if (!mpeg2enc_framerate_type) { + static const GEnumValue mpeg2enc_framerates[] = { + { 0, "0", "Same as input" }, + { 1, "1", "24/1.001 (NTSC 3:2 pulldown converted film)" }, + { 2, "2", "24 (native film)" }, + { 3, "3", "25 (PAL/SECAM video)" }, + { 4, "4", "30/1.001 (NTSC video)" }, + { 5, "5", "30" }, + { 6, "6", "50 (PAL/SECAM fields)" }, + { 7, "7", "60/1.001 (NTSC fields)" }, + { 8, "8", "60" }, + { 0, NULL, NULL }, + }; + + mpeg2enc_framerate_type = + g_enum_register_static ("GstMpeg2encFramerate", + mpeg2enc_framerates); + } + + return mpeg2enc_framerate_type; +} + +#define GST_TYPE_MPEG2ENC_ASPECT \ + (gst_mpeg2enc_aspect_get_type ()) + +static GType +gst_mpeg2enc_aspect_get_type (void) +{ + static GType mpeg2enc_aspect_type = 0; + + if (!mpeg2enc_aspect_type) { + static const GEnumValue mpeg2enc_aspects[] = { + { 0, "0", "Deduce from input" }, + { 1, "1", "1:1" }, + { 2, "2", "4:3" }, + { 3, "3", "16:9" }, + { 4, "4", "2.21:1" }, + { 0, NULL, NULL }, + }; + + mpeg2enc_aspect_type = + g_enum_register_static ("GstMpeg2encAspect", + mpeg2enc_aspects); + } + + return mpeg2enc_aspect_type; +} + +#define GST_TYPE_MPEG2ENC_INTERLACE_MODE \ + (gst_mpeg2enc_interlace_mode_get_type ()) + +static GType +gst_mpeg2enc_interlace_mode_get_type (void) +{ + static GType mpeg2enc_interlace_mode_type = 0; + + if (!mpeg2enc_interlace_mode_type) { + static const GEnumValue mpeg2enc_interlace_modes[] = { + { -1, "-1", "Format default mode" }, + { 0, "0", "Progressive" }, + { 1, "1", "Interlaced, per-frame encoding" }, + { 2, "2", "Interlaced, per-field-encoding" }, + { 0, NULL, NULL }, + }; + + mpeg2enc_interlace_mode_type = + g_enum_register_static ("GstMpeg2encInterlaceMode", + mpeg2enc_interlace_modes); + } + + return mpeg2enc_interlace_mode_type; +} + +#define GST_TYPE_MPEG2ENC_QUANTISATION_MATRIX \ + (gst_mpeg2enc_quantisation_matrix_get_type ()) + +#define GST_MPEG2ENC_QUANTISATION_MATRIX_DEFAULT 0 +#define GST_MPEG2ENC_QUANTISATION_MATRIX_HI_RES 1 +#define GST_MPEG2ENC_QUANTISATION_MATRIX_KVCD 2 +#define GST_MPEG2ENC_QUANTISATION_MATRIX_TMPGENC 3 + +static GType +gst_mpeg2enc_quantisation_matrix_get_type (void) +{ + static GType mpeg2enc_quantisation_matrix_type = 0; + + if (!mpeg2enc_quantisation_matrix_type) { + static const GEnumValue mpeg2enc_quantisation_matrixes[] = { + { GST_MPEG2ENC_QUANTISATION_MATRIX_DEFAULT, + "0", "Default" }, + { GST_MPEG2ENC_QUANTISATION_MATRIX_HI_RES, + "1", "High resolution" }, + { GST_MPEG2ENC_QUANTISATION_MATRIX_KVCD, + "2", "KVCD" }, + { GST_MPEG2ENC_QUANTISATION_MATRIX_TMPGENC, + "3", "TMPGEnc" }, + { 0, NULL, NULL }, + }; + + mpeg2enc_quantisation_matrix_type = + g_enum_register_static ("GstMpeg2encQuantisationMatrix", + mpeg2enc_quantisation_matrixes); + } + + return mpeg2enc_quantisation_matrix_type; +} + +#define GST_TYPE_MPEG2ENC_VIDEO_NORM \ + (gst_mpeg2enc_video_norm_get_type ()) + +static GType +gst_mpeg2enc_video_norm_get_type (void) +{ + static GType mpeg2enc_video_norm_type = 0; + + if (!mpeg2enc_video_norm_type) { + static const GEnumValue mpeg2enc_video_norms[] = { + { 0, "0", "Unspecified" }, + { 'p', "p", "PAL" }, + { 'n', "n", "NTSC" }, + { 's', "s", "SECAM" }, + { 0, NULL, NULL }, + }; + + mpeg2enc_video_norm_type = + g_enum_register_static ("GstMpeg2encVideoNorm", + mpeg2enc_video_norms); + } + + return mpeg2enc_video_norm_type; +} + +#define GST_TYPE_MPEG2ENC_PLAYBACK_FIELD_ORDER \ + (gst_mpeg2enc_playback_field_order_get_type ()) + +static GType +gst_mpeg2enc_playback_field_order_get_type (void) +{ + static GType mpeg2enc_playback_field_order_type = 0; + + if (!mpeg2enc_playback_field_order_type) { + static const GEnumValue mpeg2enc_playback_field_orders[] = { + { Y4M_UNKNOWN, "0", "Unspecified" }, + { Y4M_ILACE_TOP_FIRST, "1", "Top-field first" }, + { Y4M_ILACE_BOTTOM_FIRST, "2", "Bottom-field first" }, + { 0, NULL, NULL }, + }; + + mpeg2enc_playback_field_order_type = + g_enum_register_static ("GstMpeg2encPlaybackFieldOrders", + mpeg2enc_playback_field_orders); + } + + return mpeg2enc_playback_field_order_type; +} + +/* + * Class init stuff. + */ + +GstMpeg2EncOptions::GstMpeg2EncOptions () : + MPEG2EncOptions () +{ + /* autodetect number of CPUs */ + num_cpus = sysconf (_SC_NPROCESSORS_ONLN); + if (num_cpus < 0) + num_cpus = 1; + if (num_cpus > 32) + num_cpus = 32; +} + +/* + * Init properties (call once). + */ + +void +GstMpeg2EncOptions::initProperties (GObjectClass *klass) +{ + /* encoding profile */ + g_object_class_install_property (klass, ARG_FORMAT, + g_param_spec_enum ("format", "Format", "Encoding profile format", + GST_TYPE_MPEG2ENC_FORMAT, 0, + (GParamFlags) G_PARAM_READWRITE)); + + /* input/output stream overrides */ + g_object_class_install_property (klass, ARG_FRAMERATE, + g_param_spec_enum ("framerate", "Framerate", "Output framerate", + GST_TYPE_MPEG2ENC_FRAMERATE, 0, + (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_ASPECT, + g_param_spec_enum ("aspect", "Aspect", "Display aspect ratio", + GST_TYPE_MPEG2ENC_ASPECT, 0, + (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_INTERLACE_MODE, + g_param_spec_enum ("interlace-mode", "Interlace mode", + "MPEG-2 motion estimation and encoding modes", + GST_TYPE_MPEG2ENC_INTERLACE_MODE, 0, + (GParamFlags) G_PARAM_READWRITE)); + + /* general encoding stream options */ + g_object_class_install_property (klass, ARG_BITRATE, + g_param_spec_int ("bitrate", "Bitrate", "Compressed video bitrate (kbps)", + 0, 10*1024, 1125, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_NONVIDEO_BITRATE, + g_param_spec_int ("non-video-bitrate", "Non-video bitrate", + "Assumed bitrate of non-video for sequence splitting (kbps)", + 0, 10*1024, 0, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_QUANTISATION, + g_param_spec_int ("quantisation", "Quantisation", + "Quantisation factor (0=default, 1=best, 31=worst)", + 0, 31, 0, (GParamFlags) G_PARAM_READWRITE)); + + /* stills options */ + g_object_class_install_property (klass, ARG_VCD_STILL_SIZE, + g_param_spec_int ("vcd-still-size", "VCD stills size", + "Size of VCD stills (in kB)", + 0, 512, 0, (GParamFlags) G_PARAM_READWRITE)); + + /* motion estimation options */ + g_object_class_install_property (klass, ARG_MOTION_SEARCH_RADIUS, + g_param_spec_int ("motion-search-radius", "Motion search radius", + "Motion compensation search radius", + 0, 32, 16, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_REDUCTION_4_4, + g_param_spec_int ("reduction-4x4", "4x4 reduction", + "Reduction factor for 4x4 subsampled candidate motion estimates" + " (1=max. quality, 4=max. speed)", + 1, 4, 2, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_REDUCTION_2_2, + g_param_spec_int ("reduction-2x2", "2x2 reduction", + "Reduction factor for 2x2 subsampled candidate motion estimates" + " (1=max. quality, 4=max. speed)", + 1, 4, 3, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_UNIT_COEFF_ELIM, + g_param_spec_int ("unit-coeff-elim", "Unit coefficience elimination", + "How agressively small-unit picture blocks should be skipped", + -40, 40, 0, (GParamFlags) G_PARAM_READWRITE)); + + /* GOP options */ + g_object_class_install_property (klass, ARG_MIN_GOP_SIZE, + g_param_spec_int ("min-gop-size", "Min. GOP size", + "Minimal size per Group-of-Pictures (-1=default)", + -1, 250, 0, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_MAX_GOP_SIZE, + g_param_spec_int ("max-gop-size", "Max. GOP size", + "Maximal size per Group-of-Pictures (-1=default)", + -1, 250, 0, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_CLOSED_GOP, + g_param_spec_boolean ("closed-gop", "Closed GOP", + "All Group-of-Pictures are closed (for multi-angle DVDs)", + FALSE, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_FORCE_B_B_P, + g_param_spec_boolean ("force-b-b-p", "Force B-B-P", + "Force two B frames between I/P frames when closing GOP boundaries", + FALSE, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_B_PER_REFFRAME, + g_param_spec_int ("b-per-refframe", "B per ref. frame", + "Number of B frames between each I/P frame", + 0, 2, 2, (GParamFlags) G_PARAM_READWRITE)); + + /* quantisation options */ + g_object_class_install_property (klass, ARG_QUANTISATION_REDUCTION, + g_param_spec_float ("quantisation-reduction", "Quantisation reduction", + "Max. quantisation reduction for highly active blocks", + -4., 10., 0., (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_QUANT_REDUCTION_MAX_VAR, + g_param_spec_float ("quant-reduction-max-var", "Max. quant. reduction variance", + "Maximal luma variance below which quantisation boost is used", + 0., 2500., 0., (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_INTRA_DC_PRECISION, + g_param_spec_int ("intra-dc-prec", "Intra. DC precision", + "Number of bits precision for DC (base colour) in MPEG-2 blocks", + 8, 11, 9, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_REDUCE_HF, + g_param_spec_float ("reduce-hf", "Reduce HF", + "How much to reduce high-frequency resolution (by increasing quantisation)", + 0., 2., 0., (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_KEEP_HF, + g_param_spec_boolean ("keep-hf", "Keep HF", + "Maximize high-frequency resolution (for high-quality sources)", + FALSE, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_QUANTISATION_MATRIX, + g_param_spec_enum ("quant-matrix", "Quant. matrix", + "Quantisation matrix to use for encoding", + GST_TYPE_MPEG2ENC_QUANTISATION_MATRIX, 0, + (GParamFlags) G_PARAM_READWRITE)); + + /* general options */ + g_object_class_install_property (klass, ARG_BUFSIZE, + g_param_spec_int ("bufsize", "Decoder buf. size", + "Target decoders video buffer size (kB)", + 20, 4000, 46, (GParamFlags) G_PARAM_READWRITE)); + + /* header flag settings */ + g_object_class_install_property (klass, ARG_VIDEO_NORM, + g_param_spec_enum ("norm", "Norm", + "Tag output for specific video norm", + GST_TYPE_MPEG2ENC_VIDEO_NORM, 0, + (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_SEQUENCE_LENGTH, + g_param_spec_int ("sequence-length", "Sequence length", + "Place a sequence boundary after each <num> MB (0=disable)", + 0, 10*1024, 0, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_3_2_PULLDOWN, + g_param_spec_boolean ("pulldown-3-2", "3-2 pull down", + "Generate header flags for 3-2 pull down 24fps movies", + FALSE, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_SEQUENCE_HEADER_EVERY_GOP, + g_param_spec_boolean ("sequence-header-every-gop", + "Sequence hdr. every GOP", + "Include a sequence header in every GOP", + FALSE, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_DUMMY_SVCD_SOF, + g_param_spec_boolean ("dummy-svcd-sof", "Dummy SVCD SOF", + "Generate dummy SVCD scan-data (for vcdimager)", + TRUE, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_PLAYBACK_FIELD_ORDER, + g_param_spec_enum ("playback-field-order", "Playback field order", + "Force specific playback field order", + GST_TYPE_MPEG2ENC_PLAYBACK_FIELD_ORDER, Y4M_UNKNOWN, + (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_CORRECT_SVCD_HDS, + g_param_spec_boolean ("correct-svcd-hds", "Correct SVCD hor. size", + "Force SVCD width to 480 instead of 540/720", + FALSE, (GParamFlags) G_PARAM_READWRITE)); + g_object_class_install_property (klass, ARG_ALTSCAN_MPEG2, + g_param_spec_boolean ("altscan-mpeg2", "Alt. MPEG-2 scan", + "Alternate MPEG-2 block scanning. Disabling this might " + "make buggy players play SVCD streams", + TRUE, (GParamFlags) G_PARAM_READWRITE)); +#if 0 +"--dxr2-hack" +#endif + + /* dangerous/experimental stuff */ + g_object_class_install_property (klass, ARG_CONSTRAINTS, + g_param_spec_boolean ("constraints", "Constraints", + "Use strict video resolution and bitrate checks", + TRUE, (GParamFlags) G_PARAM_READWRITE)); +} + +/* + * GObject property foo, C++ style. + */ + +void +GstMpeg2EncOptions::getProperty (guint prop_id, + GValue *value) +{ + switch (prop_id) { + case ARG_FORMAT: + g_value_set_enum (value, format); + break; + case ARG_FRAMERATE: + g_value_set_enum (value, frame_rate); + break; + case ARG_ASPECT: + g_value_set_enum (value, aspect_ratio); + break; + case ARG_INTERLACE_MODE: + g_value_set_enum (value, fieldenc); + break; + case ARG_BITRATE: + g_value_set_int (value, bitrate/1024); + break; + case ARG_NONVIDEO_BITRATE: + g_value_set_int (value, nonvid_bitrate/1024); + break; + case ARG_QUANTISATION: + g_value_set_int (value, quant); + break; + case ARG_VCD_STILL_SIZE: + g_value_set_int (value, still_size / 1024); + break; + case ARG_MOTION_SEARCH_RADIUS: + g_value_set_int (value, searchrad); + break; + case ARG_REDUCTION_4_4: + g_value_set_int (value, me44_red); + break; + case ARG_REDUCTION_2_2: + g_value_set_int (value, me22_red); + break; + case ARG_UNIT_COEFF_ELIM: + g_value_set_int (value, unit_coeff_elim); + break; + case ARG_MIN_GOP_SIZE: + g_value_set_int (value, min_GOP_size); + break; + case ARG_MAX_GOP_SIZE: + g_value_set_int (value, max_GOP_size); + break; + case ARG_CLOSED_GOP: + g_value_set_boolean (value, closed_GOPs); + break; + case ARG_FORCE_B_B_P: + g_value_set_boolean (value, preserve_B); + break; + case ARG_B_PER_REFFRAME: + g_value_set_int (value, Bgrp_size - 1); + break; + case ARG_QUANTISATION_REDUCTION: + g_value_set_float (value, act_boost); + break; + case ARG_QUANT_REDUCTION_MAX_VAR: + g_value_set_float (value, boost_var_ceil); + break; + case ARG_INTRA_DC_PRECISION: + g_value_set_int (value, mpeg2_dc_prec - 8); + break; + case ARG_REDUCE_HF: + g_value_set_float (value, hf_q_boost); + break; + case ARG_KEEP_HF: + g_value_set_boolean (value, hf_quant == 2); + break; + case ARG_QUANTISATION_MATRIX: + switch (hf_quant) { + case 0: + g_value_set_enum (value, GST_MPEG2ENC_QUANTISATION_MATRIX_DEFAULT); + break; + case 2: + g_value_set_enum (value, GST_MPEG2ENC_QUANTISATION_MATRIX_HI_RES); + break; + case 3: + g_value_set_enum (value, GST_MPEG2ENC_QUANTISATION_MATRIX_KVCD); + break; + case 4: + g_value_set_enum (value, GST_MPEG2ENC_QUANTISATION_MATRIX_TMPGENC); + break; + } + break; + case ARG_BUFSIZE: + g_value_set_int (value, video_buffer_size); + break; + case ARG_VIDEO_NORM: + g_value_set_enum (value, norm); + break; + case ARG_SEQUENCE_LENGTH: + g_value_set_int (value, seq_length_limit); + break; + case ARG_3_2_PULLDOWN: + g_value_set_boolean (value, vid32_pulldown); + break; + case ARG_SEQUENCE_HEADER_EVERY_GOP: + g_value_set_boolean (value, seq_hdr_every_gop); + break; + case ARG_DUMMY_SVCD_SOF: + g_value_set_boolean (value, svcd_scan_data); + break; + case ARG_PLAYBACK_FIELD_ORDER: + g_value_set_enum (value, force_interlacing); + break; + case ARG_CORRECT_SVCD_HDS: + g_value_set_boolean (value, !hack_svcd_hds_bug); + break; + case ARG_ALTSCAN_MPEG2: + g_value_set_boolean (value, !hack_altscan_bug); + break; + case ARG_CONSTRAINTS: + g_value_set_boolean (value, !ignore_constraints); + break; + default: + break; + } +} + +void +GstMpeg2EncOptions::setProperty (guint prop_id, + const GValue *value) +{ + switch (prop_id) { + case ARG_FORMAT: + format = g_value_get_enum (value); + break; + case ARG_FRAMERATE: + frame_rate = g_value_get_enum (value); + break; + case ARG_ASPECT: + aspect_ratio = g_value_get_enum (value); + break; + case ARG_INTERLACE_MODE: + fieldenc = g_value_get_enum (value); + break; + case ARG_BITRATE: + bitrate = g_value_get_int (value) * 1024; + break; + case ARG_NONVIDEO_BITRATE: + nonvid_bitrate = g_value_get_int (value) * 1024; + break; + case ARG_QUANTISATION: + quant = g_value_get_int (value); + break; + case ARG_VCD_STILL_SIZE: + still_size = g_value_get_int (value) * 1024; + break; + case ARG_MOTION_SEARCH_RADIUS: + searchrad = g_value_get_int (value); + break; + case ARG_REDUCTION_4_4: + me44_red = g_value_get_int (value); + break; + case ARG_REDUCTION_2_2: + me22_red = g_value_get_int (value); + break; + case ARG_UNIT_COEFF_ELIM: + unit_coeff_elim = g_value_get_int (value); + break; + case ARG_MIN_GOP_SIZE: + min_GOP_size = g_value_get_int (value); + break; + case ARG_MAX_GOP_SIZE: + max_GOP_size = g_value_get_int (value); + break; + case ARG_CLOSED_GOP: + closed_GOPs = g_value_get_boolean (value); + break; + case ARG_FORCE_B_B_P: + preserve_B = g_value_get_boolean (value); + break; + case ARG_B_PER_REFFRAME: + Bgrp_size = g_value_get_int (value) + 1; + break; + case ARG_QUANTISATION_REDUCTION: + act_boost = g_value_get_float (value); + break; + case ARG_QUANT_REDUCTION_MAX_VAR: + boost_var_ceil = g_value_get_float (value); + break; + case ARG_INTRA_DC_PRECISION: + mpeg2_dc_prec = g_value_get_int (value) + 8; + break; + case ARG_REDUCE_HF: + hf_q_boost = g_value_get_float (value); + if (hf_quant == 0 && hf_q_boost != 0.) + hf_quant = 1; + break; + case ARG_KEEP_HF: + hf_quant = g_value_get_boolean (value) ? 2 : 0; + break; + case ARG_QUANTISATION_MATRIX: + switch (g_value_get_enum (value)) { + case GST_MPEG2ENC_QUANTISATION_MATRIX_DEFAULT: + hf_quant = 0; + hf_q_boost = 0; + break; + case GST_MPEG2ENC_QUANTISATION_MATRIX_HI_RES: + hf_quant = 2; + break; + case GST_MPEG2ENC_QUANTISATION_MATRIX_KVCD: + hf_quant = 3; + break; + case GST_MPEG2ENC_QUANTISATION_MATRIX_TMPGENC: + hf_quant = 4; + break; + } + break; + case ARG_BUFSIZE: + video_buffer_size = g_value_get_int (value); + break; + case ARG_VIDEO_NORM: + norm = g_value_get_enum (value); + break; + case ARG_SEQUENCE_LENGTH: + seq_length_limit = g_value_get_int (value); + break; + case ARG_3_2_PULLDOWN: + vid32_pulldown = g_value_get_boolean (value); + break; + case ARG_SEQUENCE_HEADER_EVERY_GOP: + seq_hdr_every_gop = g_value_get_boolean (value); + break; + case ARG_DUMMY_SVCD_SOF: + svcd_scan_data = g_value_get_boolean (value); + break; + case ARG_PLAYBACK_FIELD_ORDER: + force_interlacing = g_value_get_enum (value); + break; + case ARG_CORRECT_SVCD_HDS: + hack_svcd_hds_bug = !g_value_get_boolean (value); + break; + case ARG_ALTSCAN_MPEG2: + hack_altscan_bug = !g_value_get_boolean (value); + break; + case ARG_CONSTRAINTS: + ignore_constraints = !g_value_get_boolean (value); + break; + default: + break; + } +} |