ext/mpeg2enc/gstmpeg2encoptions.cc

   1 /* GStreamer mpeg2enc (mjpegtools) wrapper
   2  * (c) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
   3  *
   4  * gstmpeg2encoptions.cc: gobject/mpeg2enc option wrapping class
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include "gstmpeg2encoptions.hh"
  27 #ifdef WIN32
  28 #  include <windows.h> //For GetSystemInfo
  29 #endif
  30
  31 #include <gst/gst.h>
  32
  33 /*
  34  * Property enumeration.
  35  */
  36
  37 enum
  38 {
  39   ARG_0,
  40   ARG_FORMAT,
  41   ARG_FRAMERATE,
  42   ARG_ASPECT,
  43   ARG_INTERLACE_MODE,
  44   ARG_BITRATE,
  45   ARG_NONVIDEO_BITRATE,
  46   ARG_QUANTISATION,
  47   ARG_VCD_STILL_SIZE,
  48   ARG_MOTION_SEARCH_RADIUS,
  49   ARG_REDUCTION_4_4,
  50   ARG_REDUCTION_2_2,
  51   ARG_UNIT_COEFF_ELIM,
  52   ARG_MIN_GOP_SIZE,
  53   ARG_MAX_GOP_SIZE,
  54   ARG_CLOSED_GOP,
  55   ARG_FORCE_B_B_P,
  56   ARG_B_PER_REFFRAME,
  57   ARG_QUANTISATION_REDUCTION,
  58   ARG_QUANT_REDUCTION_MAX_VAR,
  59   ARG_INTRA_DC_PRECISION,
  60   ARG_REDUCE_HF,
  61   ARG_KEEP_HF,
  62   ARG_QUANTISATION_MATRIX,
  63   ARG_BUFSIZE,
  64   ARG_VIDEO_NORM,
  65   ARG_SEQUENCE_LENGTH,
  66   ARG_3_2_PULLDOWN,
  67   ARG_SEQUENCE_HEADER_EVERY_GOP,
  68   ARG_PLAYBACK_FIELD_ORDER,
  69   ARG_DUMMY_SVCD_SOF,
  70   ARG_CORRECT_SVCD_HDS,
  71   ARG_ALTSCAN_MPEG2,
  72   ARG_CONSTRAINTS,
  73   ARG_DUALPRIME_MPEG2
  74       /* FILL ME */
  75 };
  76
  77 /* MPEG1 VCD bitrate is used as default (also by mpeg2enc) */
  78 #define DEFAULT_BITRATE  1125
  79
  80 /*
  81  * Property enumeration types.
  82  */
  83
  84 /* FIXME: nick/name perhaps to be reversed (?) */
  85
  86 #define GST_TYPE_MPEG2ENC_FORMAT \
  87   (gst_mpeg2enc_format_get_type ())
  88
  89 static GType
  90 gst_mpeg2enc_format_get_type (void)
  91 {
  92   static GType mpeg2enc_format_type = 0;
  93
  94   if (!mpeg2enc_format_type) {
  95     static const GEnumValue mpeg2enc_formats[] = {
  96       {MPEG_FORMAT_MPEG1, "Generic MPEG-1", "0"},
  97       {MPEG_FORMAT_VCD, "Standard VCD", "1"},
  98       {MPEG_FORMAT_VCD_NSR, "User VCD", "2"},
  99       {MPEG_FORMAT_MPEG2, "Generic MPEG-2", "3"},
 100       {MPEG_FORMAT_SVCD, "Standard SVCD", "4"},
 101       {MPEG_FORMAT_SVCD_NSR, "User SVCD", "5"},
 102       {MPEG_FORMAT_VCD_STILL, "VCD Stills sequences", "6"},
 103       {MPEG_FORMAT_SVCD_STILL, "SVCD Stills sequences", "7"},
 104       {MPEG_FORMAT_DVD_NAV, "DVD MPEG-2 for dvdauthor", "8"},
 105       {MPEG_FORMAT_DVD, "DVD MPEG-2", "9"},
 106 #ifdef MPEG_FORMAT_ATSC1080i
 107       {MPEG_FORMAT_ATSC480i, "ATSC 480i", "10"},
 108       {MPEG_FORMAT_ATSC480p, "ATSC 480p", "11"},
 109       {MPEG_FORMAT_ATSC720p, "ATSC 720p", "12"},
 110       {MPEG_FORMAT_ATSC1080i, "ATSC 1080i", "13"},
 111 #endif
 112       {0, NULL, NULL},
 113     };
 114
 115     mpeg2enc_format_type =
 116         g_enum_register_static ("GstMpeg2encFormat", mpeg2enc_formats);
 117   }
 118
 119   return mpeg2enc_format_type;
 120 }
 121
 122 #define GST_TYPE_MPEG2ENC_FRAMERATE \
 123   (gst_mpeg2enc_framerate_get_type ())
 124
 125 static GType
 126 gst_mpeg2enc_framerate_get_type (void)
 127 {
 128   static GType mpeg2enc_framerate_type = 0;
 129
 130   if (!mpeg2enc_framerate_type) {
 131     static const GEnumValue mpeg2enc_framerates[] = {
 132       {0, "Same as input", "0"},
 133       {1, "24/1.001 (NTSC 3:2 pulldown converted film)", "1"},
 134       {2, "24 (native film)", "2"},
 135       {3, "25 (PAL/SECAM video)", "3"},
 136       {4, "30/1.001 (NTSC video)", "4"},
 137       {5, "30", "5"},
 138       {6, "50 (PAL/SECAM fields)", "6"},
 139       {7, "60/1.001 (NTSC fields)", "7"},
 140       {8, "60", "8"},
 141       {0, NULL, NULL},
 142     };
 143
 144     mpeg2enc_framerate_type =
 145         g_enum_register_static ("GstMpeg2encFramerate", mpeg2enc_framerates);
 146   }
 147
 148   return mpeg2enc_framerate_type;
 149 }
 150
 151 #define GST_TYPE_MPEG2ENC_ASPECT \
 152   (gst_mpeg2enc_aspect_get_type ())
 153
 154 static GType
 155 gst_mpeg2enc_aspect_get_type (void)
 156 {
 157   static GType mpeg2enc_aspect_type = 0;
 158
 159   if (!mpeg2enc_aspect_type) {
 160     static const GEnumValue mpeg2enc_aspects[] = {
 161       {0, "Deduce from input", "0"},
 162       {1, "1:1", "1"},
 163       {2, "4:3", "2"},
 164       {3, "16:9", "3"},
 165       {4, "2.21:1", "4"},
 166       {0, NULL, NULL},
 167     };
 168
 169     mpeg2enc_aspect_type =
 170         g_enum_register_static ("GstMpeg2encAspect", mpeg2enc_aspects);
 171   }
 172
 173   return mpeg2enc_aspect_type;
 174 }
 175
 176 #define GST_TYPE_MPEG2ENC_INTERLACE_MODE \
 177   (gst_mpeg2enc_interlace_mode_get_type ())
 178
 179 static GType
 180 gst_mpeg2enc_interlace_mode_get_type (void)
 181 {
 182   static GType mpeg2enc_interlace_mode_type = 0;
 183
 184   if (!mpeg2enc_interlace_mode_type) {
 185     static const GEnumValue mpeg2enc_interlace_modes[] = {
 186       {-1, "Format default mode", "-1"},
 187       {0, "Progressive", "0"},
 188       {1, "Interlaced, per-frame encoding", "1"},
 189       {2, "Interlaced, per-field-encoding", "2"},
 190       {0, NULL, NULL},
 191     };
 192
 193     mpeg2enc_interlace_mode_type =
 194         g_enum_register_static ("GstMpeg2encInterlaceMode",
 195         mpeg2enc_interlace_modes);
 196   }
 197
 198   return mpeg2enc_interlace_mode_type;
 199 }
 200
 201 #define GST_TYPE_MPEG2ENC_QUANTISATION_MATRIX \
 202   (gst_mpeg2enc_quantisation_matrix_get_type ())
 203
 204 #define GST_MPEG2ENC_QUANTISATION_MATRIX_DEFAULT 0
 205 #define GST_MPEG2ENC_QUANTISATION_MATRIX_HI_RES  1
 206 #define GST_MPEG2ENC_QUANTISATION_MATRIX_KVCD    2
 207 #define GST_MPEG2ENC_QUANTISATION_MATRIX_TMPGENC 3
 208
 209 static GType
 210 gst_mpeg2enc_quantisation_matrix_get_type (void)
 211 {
 212   static GType mpeg2enc_quantisation_matrix_type = 0;
 213
 214   if (!mpeg2enc_quantisation_matrix_type) {
 215     static const GEnumValue mpeg2enc_quantisation_matrixes[] = {
 216       {GST_MPEG2ENC_QUANTISATION_MATRIX_DEFAULT,
 217           "Default", "9"},
 218       {GST_MPEG2ENC_QUANTISATION_MATRIX_HI_RES,
 219           "High resolution", "1"},
 220       {GST_MPEG2ENC_QUANTISATION_MATRIX_KVCD,
 221           "KVCD", "2"},
 222       {GST_MPEG2ENC_QUANTISATION_MATRIX_TMPGENC,
 223           "TMPGEnc", "3"},
 224       {0, NULL, NULL},
 225     };
 226
 227     mpeg2enc_quantisation_matrix_type =
 228         g_enum_register_static ("GstMpeg2encQuantisationMatrix",
 229         mpeg2enc_quantisation_matrixes);
 230   }
 231
 232   return mpeg2enc_quantisation_matrix_type;
 233 }
 234
 235 #define GST_TYPE_MPEG2ENC_VIDEO_NORM \
 236   (gst_mpeg2enc_video_norm_get_type ())
 237
 238 static GType
 239 gst_mpeg2enc_video_norm_get_type (void)
 240 {
 241   static GType mpeg2enc_video_norm_type = 0;
 242
 243   if (!mpeg2enc_video_norm_type) {
 244     static const GEnumValue mpeg2enc_video_norms[] = {
 245       {0, "Unspecified", "0"},
 246       {'p', "PAL", "p"},
 247       {'n', "NTSC", "n"},
 248       {'s', "SECAM", "s"},
 249       {0, NULL, NULL},
 250     };
 251
 252     mpeg2enc_video_norm_type =
 253         g_enum_register_static ("GstMpeg2encVideoNorm", mpeg2enc_video_norms);
 254   }
 255
 256   return mpeg2enc_video_norm_type;
 257 }
 258
 259 #define GST_TYPE_MPEG2ENC_PLAYBACK_FIELD_ORDER \
 260   (gst_mpeg2enc_playback_field_order_get_type ())
 261
 262 static GType
 263 gst_mpeg2enc_playback_field_order_get_type (void)
 264 {
 265   static GType mpeg2enc_playback_field_order_type = 0;
 266
 267   if (!mpeg2enc_playback_field_order_type) {
 268     static const GEnumValue mpeg2enc_playback_field_orders[] = {
 269       {Y4M_UNKNOWN, "Unspecified", "0"},
 270       {Y4M_ILACE_TOP_FIRST, "Top-field first", "1"},
 271       {Y4M_ILACE_BOTTOM_FIRST, "Bottom-field first", "2"},
 272       {0, NULL, NULL},
 273     };
 274
 275     mpeg2enc_playback_field_order_type =
 276         g_enum_register_static ("GstMpeg2encPlaybackFieldOrders",
 277         mpeg2enc_playback_field_orders);
 278   }
 279
 280   return mpeg2enc_playback_field_order_type;
 281 }
 282
 283 /*
 284  * Class init stuff.
 285  */
 286
 287 GstMpeg2EncOptions::GstMpeg2EncOptions ():
 288 MPEG2EncOptions ()
 289 {
 290   /* autodetect number of CPUs */
 291 #ifndef WIN32
 292   num_cpus = sysconf (_SC_NPROCESSORS_ONLN);
 293 #else
 294   SYSTEM_INFO si;
 295   GetSystemInfo(&si);
 296   num_cpus = si.dwNumberOfProcessors;
 297 #endif
 298   if (num_cpus < 0)
 299     num_cpus = 1;
 300   if (num_cpus > 32)
 301     num_cpus = 32;
 302
 303   /* set some default(s) not set in base class */
 304   bitrate = DEFAULT_BITRATE * 1000;
 305 }
 306
 307 /*
 308  * Init properties (call once).
 309  */
 310
 311 void
 312 GstMpeg2EncOptions::initProperties (GObjectClass * klass)
 313 {
 314   /* encoding profile */
 315   g_object_class_install_property (klass, ARG_FORMAT,
 316       g_param_spec_enum ("format", "Format", "Encoding profile format",
 317           GST_TYPE_MPEG2ENC_FORMAT, 0,
 318           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 319
 320   /* input/output stream overrides */
 321   g_object_class_install_property (klass, ARG_FRAMERATE,
 322       g_param_spec_enum ("framerate", "Framerate", "Output framerate",
 323           GST_TYPE_MPEG2ENC_FRAMERATE, 0,
 324           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 325   g_object_class_install_property (klass, ARG_ASPECT,
 326       g_param_spec_enum ("aspect", "Aspect", "Display aspect ratio",
 327           GST_TYPE_MPEG2ENC_ASPECT, 0,
 328           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 329   g_object_class_install_property (klass, ARG_INTERLACE_MODE,
 330       g_param_spec_enum ("interlace-mode", "Interlace mode",
 331           "MPEG-2 motion estimation and encoding modes",
 332           GST_TYPE_MPEG2ENC_INTERLACE_MODE, 0,
 333           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 334
 335   /* general encoding stream options */
 336   g_object_class_install_property (klass, ARG_BITRATE,
 337       g_param_spec_int ("bitrate", "Bitrate", "Compressed video bitrate (kbps)",
 338           0, 40 * 1000, DEFAULT_BITRATE,
 339           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 340   g_object_class_install_property (klass, ARG_NONVIDEO_BITRATE,
 341       g_param_spec_int ("non-video-bitrate", "Non-video bitrate",
 342           "Assumed bitrate of non-video for sequence splitting (kbps)",
 343           0, 10 * 1000, 0,
 344           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 345   g_object_class_install_property (klass, ARG_QUANTISATION,
 346       g_param_spec_int ("quantisation", "Quantisation",
 347           "Quantisation factor (-1=cbr, 0=default, 1=best, 31=worst)",
 348           -1, 31, 0,
 349           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 350
 351   /* stills options */
 352   g_object_class_install_property (klass, ARG_VCD_STILL_SIZE,
 353       g_param_spec_int ("vcd-still-size", "VCD stills size",
 354           "Size of VCD stills (in KB)",
 355           0, 512, 0,
 356           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 357
 358   /* motion estimation options */
 359   g_object_class_install_property (klass, ARG_MOTION_SEARCH_RADIUS,
 360       g_param_spec_int ("motion-search-radius", "Motion search radius",
 361           "Motion compensation search radius",
 362           0, 32, 16,
 363           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 364   g_object_class_install_property (klass, ARG_REDUCTION_4_4,
 365       g_param_spec_int ("reduction-4x4", "4x4 reduction",
 366           "Reduction factor for 4x4 subsampled candidate motion estimates"
 367           " (1=max. quality, 4=max. speed)",
 368           1, 4, 2,
 369           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 370   g_object_class_install_property (klass, ARG_REDUCTION_2_2,
 371       g_param_spec_int ("reduction-2x2", "2x2 reduction",
 372           "Reduction factor for 2x2 subsampled candidate motion estimates"
 373           " (1=max. quality, 4=max. speed)",
 374           1, 4, 3,
 375           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 376   g_object_class_install_property (klass, ARG_UNIT_COEFF_ELIM,
 377       g_param_spec_int ("unit-coeff-elim", "Unit coefficience elimination",
 378           "How aggressively small-unit picture blocks should be skipped",
 379           -40, 40, 0,
 380           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 381
 382   /* GOP options */
 383   g_object_class_install_property (klass, ARG_MIN_GOP_SIZE,
 384       g_param_spec_int ("min-gop-size", "Min. GOP size",
 385           "Minimal size per Group-of-Pictures (-1=default)",
 386           -1, 250, -1,
 387           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 388   g_object_class_install_property (klass, ARG_MAX_GOP_SIZE,
 389       g_param_spec_int ("max-gop-size", "Max. GOP size",
 390           "Maximal size per Group-of-Pictures (-1=default)",
 391           -1, 250, -1,
 392           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 393   g_object_class_install_property (klass, ARG_CLOSED_GOP,
 394       g_param_spec_boolean ("closed-gop", "Closed GOP",
 395           "All Group-of-Pictures are closed (for multi-angle DVDs)",
 396           FALSE,
 397           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 398   g_object_class_install_property (klass, ARG_FORCE_B_B_P,
 399       g_param_spec_boolean ("force-b-b-p", "Force B-B-P",
 400           "Force two B frames between I/P frames when closing GOP boundaries",
 401           FALSE,
 402           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 403   g_object_class_install_property (klass, ARG_B_PER_REFFRAME,
 404       g_param_spec_int ("b-per-refframe", "B per ref. frame",
 405           "Number of B frames between each I/P frame",
 406           0, 2, 0,
 407           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 408
 409   /* quantisation options */
 410   g_object_class_install_property (klass, ARG_QUANTISATION_REDUCTION,
 411       g_param_spec_float ("quantisation-reduction", "Quantisation reduction",
 412           "Max. quantisation reduction for highly active blocks",
 413           -4., 10., 0.,
 414           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 415   g_object_class_install_property (klass, ARG_QUANT_REDUCTION_MAX_VAR,
 416       g_param_spec_float ("quant-reduction-max-var",
 417           "Max. quant. reduction variance",
 418           "Maximal luma variance below which quantisation boost is used",
 419           0., 2500., 100.,
 420           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 421   g_object_class_install_property (klass, ARG_INTRA_DC_PRECISION,
 422       g_param_spec_int ("intra-dc-prec", "Intra. DC precision",
 423           "Number of bits precision for DC (base colour) in MPEG-2 blocks",
 424           8, 11, 9,
 425           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 426   g_object_class_install_property (klass, ARG_REDUCE_HF,
 427       g_param_spec_float ("reduce-hf", "Reduce HF",
 428           "How much to reduce high-frequency resolution (by increasing quantisation)",
 429           0., 2., 0.,
 430           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 431   g_object_class_install_property (klass, ARG_KEEP_HF,
 432       g_param_spec_boolean ("keep-hf", "Keep HF",
 433           "Maximize high-frequency resolution (for high-quality sources)",
 434           FALSE,
 435           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 436   g_object_class_install_property (klass, ARG_QUANTISATION_MATRIX,
 437       g_param_spec_enum ("quant-matrix", "Quant. matrix",
 438           "Quantisation matrix to use for encoding",
 439           GST_TYPE_MPEG2ENC_QUANTISATION_MATRIX, 0,
 440           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 441
 442   /* general options */
 443   g_object_class_install_property (klass, ARG_BUFSIZE,
 444       g_param_spec_int ("bufsize", "Decoder buf. size",
 445           "Target decoders video buffer size (kB) (default depends on format)",
 446           20, 4000, 46,
 447           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 448
 449   /* header flag settings */
 450   g_object_class_install_property (klass, ARG_VIDEO_NORM,
 451       g_param_spec_enum ("norm", "Norm",
 452           "Tag output for specific video norm",
 453           GST_TYPE_MPEG2ENC_VIDEO_NORM, 0,
 454           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 455   g_object_class_install_property (klass, ARG_SEQUENCE_LENGTH,
 456       g_param_spec_int ("sequence-length", "Sequence length",
 457           "Place a sequence boundary after each <num> MB (0=disable)",
 458           0, 10 * 1024, 0,
 459           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 460   g_object_class_install_property (klass, ARG_3_2_PULLDOWN,
 461       g_param_spec_boolean ("pulldown-3-2", "3-2 pull down",
 462           "Generate header flags for 3-2 pull down 24fps movies",
 463           FALSE,
 464           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 465   g_object_class_install_property (klass, ARG_SEQUENCE_HEADER_EVERY_GOP,
 466       g_param_spec_boolean ("sequence-header-every-gop",
 467           "Sequence hdr. every GOP",
 468           "Include a sequence header in every GOP",
 469           FALSE,
 470           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 471   g_object_class_install_property (klass, ARG_DUMMY_SVCD_SOF,
 472       g_param_spec_boolean ("dummy-svcd-sof", "Dummy SVCD SOF",
 473           "Generate dummy SVCD scan-data (for vcdimager)",
 474           TRUE,
 475           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 476   g_object_class_install_property (klass, ARG_PLAYBACK_FIELD_ORDER,
 477       g_param_spec_enum ("playback-field-order", "Playback field order",
 478           "Force specific playback field order",
 479           GST_TYPE_MPEG2ENC_PLAYBACK_FIELD_ORDER, Y4M_UNKNOWN,
 480           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 481   g_object_class_install_property (klass, ARG_CORRECT_SVCD_HDS,
 482       g_param_spec_boolean ("correct-svcd-hds", "Correct SVCD hor. size",
 483           "Force SVCD width to 480 instead of 540/720",
 484           FALSE,
 485           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 486   g_object_class_install_property (klass, ARG_ALTSCAN_MPEG2,
 487       g_param_spec_boolean ("altscan-mpeg2", "Alt. MPEG-2 scan",
 488           "Alternate MPEG-2 block scanning. Disabling this might "
 489           "make buggy players play SVCD streams",
 490           TRUE,
 491           (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 492
 493   /* dangerous/experimental stuff */
 494   g_object_class_install_property (klass, ARG_CONSTRAINTS,
 495       g_param_spec_boolean ("constraints", "Constraints",
 496           "Use strict video resolution and bitrate checks",
 497           TRUE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 498 #if GST_MJPEGTOOLS_API >= 10800
 499   g_object_class_install_property (klass, ARG_DUALPRIME_MPEG2,
 500       g_param_spec_boolean ("dualprime", "Dual Prime Motion Estimation",
 501           "Dual Prime Motion Estimation Mode for MPEG-2 I/P-frame only "
 502           "streams.  Quite some players do not support this.",
 503           FALSE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
 504 #endif
 505 }
 506
 507 /*
 508  * GObject property foo, C++ style.
 509  */
 510
 511 void
 512 GstMpeg2EncOptions::getProperty (guint prop_id, GValue * value)
 513 {
 514   switch (prop_id) {
 515     case ARG_FORMAT:
 516       g_value_set_enum (value, format);
 517       break;
 518     case ARG_FRAMERATE:
 519       g_value_set_enum (value, frame_rate);
 520       break;
 521     case ARG_ASPECT:
 522       g_value_set_enum (value, aspect_ratio);
 523       break;
 524     case ARG_INTERLACE_MODE:
 525       g_value_set_enum (value, fieldenc);
 526       break;
 527     case ARG_BITRATE:
 528       g_value_set_int (value, bitrate / 1000);
 529       break;
 530     case ARG_NONVIDEO_BITRATE:
 531       g_value_set_int (value, nonvid_bitrate);
 532       break;
 533     case ARG_QUANTISATION:
 534       g_value_set_int (value, force_cbr ? -1 : quant);
 535       break;
 536     case ARG_VCD_STILL_SIZE:
 537       g_value_set_int (value, still_size / 1024);
 538       break;
 539     case ARG_MOTION_SEARCH_RADIUS:
 540       g_value_set_int (value, searchrad);
 541       break;
 542     case ARG_REDUCTION_4_4:
 543       g_value_set_int (value, me44_red);
 544       break;
 545     case ARG_REDUCTION_2_2:
 546       g_value_set_int (value, me22_red);
 547       break;
 548     case ARG_UNIT_COEFF_ELIM:
 549       g_value_set_int (value, unit_coeff_elim);
 550       break;
 551     case ARG_MIN_GOP_SIZE:
 552       g_value_set_int (value, min_GOP_size);
 553       break;
 554     case ARG_MAX_GOP_SIZE:
 555       g_value_set_int (value, max_GOP_size);
 556       break;
 557     case ARG_CLOSED_GOP:
 558       g_value_set_boolean (value, closed_GOPs);
 559       break;
 560     case ARG_FORCE_B_B_P:
 561       g_value_set_boolean (value, preserve_B);
 562       break;
 563     case ARG_B_PER_REFFRAME:
 564       g_value_set_int (value, Bgrp_size - 1);
 565       break;
 566     case ARG_QUANTISATION_REDUCTION:
 567       g_value_set_float (value, act_boost);
 568       break;
 569     case ARG_QUANT_REDUCTION_MAX_VAR:
 570       g_value_set_float (value, boost_var_ceil);
 571       break;
 572     case ARG_INTRA_DC_PRECISION:
 573       g_value_set_int (value, mpeg2_dc_prec + 8);
 574       break;
 575     case ARG_REDUCE_HF:
 576       g_value_set_float (value, hf_q_boost);
 577       break;
 578     case ARG_KEEP_HF:
 579       g_value_set_boolean (value, hf_quant == 2);
 580       break;
 581     case ARG_QUANTISATION_MATRIX:
 582       switch (hf_quant) {
 583         case 0:
 584           g_value_set_enum (value, GST_MPEG2ENC_QUANTISATION_MATRIX_DEFAULT);
 585           break;
 586         case 2:
 587           g_value_set_enum (value, GST_MPEG2ENC_QUANTISATION_MATRIX_HI_RES);
 588           break;
 589         case 3:
 590           g_value_set_enum (value, GST_MPEG2ENC_QUANTISATION_MATRIX_KVCD);
 591           break;
 592         case 4:
 593           g_value_set_enum (value, GST_MPEG2ENC_QUANTISATION_MATRIX_TMPGENC);
 594           break;
 595       }
 596       break;
 597     case ARG_BUFSIZE:
 598       g_value_set_int (value, video_buffer_size);
 599       break;
 600     case ARG_VIDEO_NORM:
 601       g_value_set_enum (value, norm);
 602       break;
 603     case ARG_SEQUENCE_LENGTH:
 604       g_value_set_int (value, seq_length_limit);
 605       break;
 606     case ARG_3_2_PULLDOWN:
 607       g_value_set_boolean (value, vid32_pulldown);
 608       break;
 609     case ARG_SEQUENCE_HEADER_EVERY_GOP:
 610       g_value_set_boolean (value, seq_hdr_every_gop);
 611       break;
 612     case ARG_DUMMY_SVCD_SOF:
 613       g_value_set_boolean (value, svcd_scan_data);
 614       break;
 615     case ARG_PLAYBACK_FIELD_ORDER:
 616       g_value_set_enum (value, force_interlacing);
 617       break;
 618     case ARG_CORRECT_SVCD_HDS:
 619       g_value_set_boolean (value, !hack_svcd_hds_bug);
 620       break;
 621     case ARG_ALTSCAN_MPEG2:
 622       g_value_set_boolean (value, !hack_altscan_bug);
 623       break;
 624     case ARG_CONSTRAINTS:
 625       g_value_set_boolean (value, !ignore_constraints);
 626       break;
 627 #if GST_MJPEGTOOLS_API >= 10800
 628     case ARG_DUALPRIME_MPEG2:
 629       g_value_set_boolean (value, hack_dualprime);
 630       break;
 631 #endif
 632     default:
 633       break;
 634   }
 635 }
 636
 637 void
 638 GstMpeg2EncOptions::setProperty (guint prop_id, const GValue * value)
 639 {
 640   switch (prop_id) {
 641     case ARG_FORMAT:
 642       format = g_value_get_enum (value);
 643       break;
 644     case ARG_FRAMERATE:
 645       frame_rate = g_value_get_enum (value);
 646       break;
 647     case ARG_ASPECT:
 648       aspect_ratio = g_value_get_enum (value);
 649       break;
 650     case ARG_INTERLACE_MODE:
 651       fieldenc = g_value_get_enum (value);
 652       break;
 653     case ARG_BITRATE:
 654       bitrate = g_value_get_int (value) * 1000;
 655       if (bitrate % 400 != 0) {
 656         bitrate = (bitrate / 400 + 1) * 400;
 657         GST_INFO ("MPEG bitrate must be a multiple of 400"
 658             " - rounded up to bitrate %d", bitrate / 1000);
 659       }
 660       break;
 661     case ARG_NONVIDEO_BITRATE:
 662       nonvid_bitrate = g_value_get_int (value);
 663       break;
 664     case ARG_QUANTISATION:
 665       quant = g_value_get_int (value);
 666       if (quant < 0) {
 667         force_cbr = 1;
 668         quant = 0;
 669       }
 670       break;
 671     case ARG_VCD_STILL_SIZE:
 672       still_size = g_value_get_int (value) * 1024;
 673       break;
 674     case ARG_MOTION_SEARCH_RADIUS:
 675       searchrad = g_value_get_int (value);
 676       break;
 677     case ARG_REDUCTION_4_4:
 678       me44_red = g_value_get_int (value);
 679       break;
 680     case ARG_REDUCTION_2_2:
 681       me22_red = g_value_get_int (value);
 682       break;
 683     case ARG_UNIT_COEFF_ELIM:
 684       unit_coeff_elim = g_value_get_int (value);
 685       break;
 686     case ARG_MIN_GOP_SIZE:
 687       min_GOP_size = g_value_get_int (value);
 688       break;
 689     case ARG_MAX_GOP_SIZE:
 690       max_GOP_size = g_value_get_int (value);
 691       break;
 692     case ARG_CLOSED_GOP:
 693       closed_GOPs = g_value_get_boolean (value);
 694       break;
 695     case ARG_FORCE_B_B_P:
 696       preserve_B = g_value_get_boolean (value);
 697       break;
 698     case ARG_B_PER_REFFRAME:
 699       Bgrp_size = g_value_get_int (value) + 1;
 700       break;
 701     case ARG_QUANTISATION_REDUCTION:
 702       act_boost = g_value_get_float (value);
 703       break;
 704     case ARG_QUANT_REDUCTION_MAX_VAR:
 705       boost_var_ceil = g_value_get_float (value);
 706       break;
 707     case ARG_INTRA_DC_PRECISION:
 708       mpeg2_dc_prec = g_value_get_int (value) - 8;
 709       break;
 710     case ARG_REDUCE_HF:
 711       hf_q_boost = g_value_get_float (value);
 712       if (hf_quant == 0 && hf_q_boost != 0.)
 713         hf_quant = 1;
 714       break;
 715     case ARG_KEEP_HF:
 716       hf_quant = g_value_get_boolean (value) ? 2 : 0;
 717       break;
 718     case ARG_QUANTISATION_MATRIX:
 719       switch (g_value_get_enum (value)) {
 720         case GST_MPEG2ENC_QUANTISATION_MATRIX_DEFAULT:
 721           hf_quant = 0;
 722           hf_q_boost = 0;
 723           break;
 724         case GST_MPEG2ENC_QUANTISATION_MATRIX_HI_RES:
 725           hf_quant = 2;
 726           break;
 727         case GST_MPEG2ENC_QUANTISATION_MATRIX_KVCD:
 728           hf_quant = 3;
 729           break;
 730         case GST_MPEG2ENC_QUANTISATION_MATRIX_TMPGENC:
 731           hf_quant = 4;
 732           break;
 733       }
 734       break;
 735     case ARG_BUFSIZE:
 736       video_buffer_size = g_value_get_int (value);
 737       break;
 738     case ARG_VIDEO_NORM:
 739       norm = g_value_get_enum (value);
 740       break;
 741     case ARG_SEQUENCE_LENGTH:
 742       seq_length_limit = g_value_get_int (value);
 743       break;
 744     case ARG_3_2_PULLDOWN:
 745       vid32_pulldown = g_value_get_boolean (value);
 746       break;
 747     case ARG_SEQUENCE_HEADER_EVERY_GOP:
 748       seq_hdr_every_gop = g_value_get_boolean (value);
 749       break;
 750     case ARG_DUMMY_SVCD_SOF:
 751       svcd_scan_data = g_value_get_boolean (value);
 752       break;
 753     case ARG_PLAYBACK_FIELD_ORDER:
 754       force_interlacing = g_value_get_enum (value);
 755       break;
 756     case ARG_CORRECT_SVCD_HDS:
 757       hack_svcd_hds_bug = !g_value_get_boolean (value);
 758       break;
 759     case ARG_ALTSCAN_MPEG2:
 760       hack_altscan_bug = !g_value_get_boolean (value);
 761       break;
 762     case ARG_CONSTRAINTS:
 763       ignore_constraints = !g_value_get_boolean (value);
 764       break;
 765 #if GST_MJPEGTOOLS_API >= 10800
 766     case ARG_DUALPRIME_MPEG2:
 767       hack_dualprime = g_value_get_boolean (value);
 768       break;
 769 #endif
 770     default:
 771       break;
 772   }
 773 }