## OGMRipVideoCodec OGMRipVideoCodec — Base class for video codecs |

## Synopsis

    #include <ogmrip-video-codec.h>

    struct              OGMRipVideoCodec;
    struct              OGMRipVideoCodecClass;
    gboolean            ogmrip_video_codec_analyze          (OGMRipVideoCodec *video,
                                                             guint nframes);
    gboolean            ogmrip_video_codec_autocrop         (OGMRipVideoCodec *video,
                                                             guint nframes);
    void                ogmrip_video_codec_autoscale        (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_autobitrate      (OGMRipVideoCodec *video,
                                                             guint64 nonvideo_size,
                                                             guint64 overhead_size,
                                                             guint64 total_size);
    gboolean            ogmrip_video_codec_get_4mv          (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_4mv          (OGMRipVideoCodec *video,
                                                             gboolean v4mv);
    gint                ogmrip_video_codec_get_angle        (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_angle        (OGMRipVideoCodec *video,
                                                             guint angle);
    void                ogmrip_video_codec_get_aspect_ratio (OGMRipVideoCodec *video,
                                                             guint *num,
                                                             guint *denom);
    void                ogmrip_video_codec_set_aspect_ratio (OGMRipVideoCodec *video,
                                                             guint num,
                                                             guint denom);
    gint                ogmrip_video_codec_get_bitrate      (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_bitrate      (OGMRipVideoCodec *video,
                                                             guint bitrate);
    gdouble             ogmrip_video_codec_get_bits_per_pixel
                                                            (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_bits_per_pixel
                                                            (OGMRipVideoCodec *video,
                                                             gdouble bpp);
    gboolean            ogmrip_video_codec_get_cartoon      (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_cartoon      (OGMRipVideoCodec *video,
                                                             gboolean cartoon);
    gboolean            ogmrip_video_codec_get_crop_size    (OGMRipVideoCodec *video,
                                                             guint *x,
                                                             guint *y,
                                                             guint *width,
                                                             guint *height);
    void                ogmrip_video_codec_set_crop_size    (OGMRipVideoCodec *video,
                                                             guint x,
                                                             guint y,
                                                             guint width,
                                                             guint height);
    gboolean            ogmrip_video_codec_get_deblock      (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_deblock      (OGMRipVideoCodec *video,
                                                             gboolean deblock);
    gint                ogmrip_video_codec_get_deinterlacer (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_deinterlacer (OGMRipVideoCodec *video,
                                                             OGMRipDeintType deint);
    gboolean            ogmrip_video_codec_get_denoise      (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_denoise      (OGMRipVideoCodec *video,
                                                             gboolean denoise);
    gboolean            ogmrip_video_codec_get_dering       (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_dering       (OGMRipVideoCodec *video,
                                                             gboolean dering);
    OGMDvdAudioStream * ogmrip_video_codec_get_ensure_sync  (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_ensure_sync  (OGMRipVideoCodec *video,
                                                             OGMDvdAudioStream *stream);
    gboolean            ogmrip_video_codec_get_grayscale    (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_grayscale    (OGMRipVideoCodec *video,
                                                             gboolean grayscale);
    OGMDvdSubpStream *  ogmrip_video_codec_get_hard_subp    (OGMRipVideoCodec *video,
                                                             gboolean *forced);
    void                ogmrip_video_codec_set_hard_subp    (OGMRipVideoCodec *video,
                                                             OGMDvdSubpStream *stream,
                                                             gboolean forced);
    gint                ogmrip_video_codec_get_max_b_frames (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_max_b_frames (OGMRipVideoCodec *video,
                                                             guint max_b_frames);
    gboolean            ogmrip_video_codec_get_max_size     (OGMRipVideoCodec *video,
                                                             guint *width,
                                                             guint *height,
                                                             gboolean *expand);
    void                ogmrip_video_codec_set_max_size     (OGMRipVideoCodec *video,
                                                             guint width,
                                                             guint height,
                                                             gboolean expand);
    gboolean            ogmrip_video_codec_get_min_size     (OGMRipVideoCodec *video,
                                                             guint *width,
                                                             guint *height);
    void                ogmrip_video_codec_set_min_size     (OGMRipVideoCodec *video,
                                                             guint width,
                                                             guint height);
    gint                ogmrip_video_codec_get_passes       (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_passes       (OGMRipVideoCodec *video,
                                                             guint pass);
    gboolean            ogmrip_video_codec_get_qpel         (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_qpel         (OGMRipVideoCodec *video,
                                                             gboolean qpel);
    gint                ogmrip_video_codec_get_quality      (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_quality      (OGMRipVideoCodec *video,
                                                             OGMRipQualityType quality);
    gdouble             ogmrip_video_codec_get_quantizer    (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_quantizer    (OGMRipVideoCodec *video,
                                                             gdouble quantizer);
    void                ogmrip_video_codec_get_raw_size     (OGMRipVideoCodec *video,
                                                             guint *width,
                                                             guint *height);
    gboolean            ogmrip_video_codec_get_scale_size   (OGMRipVideoCodec *video,
                                                             guint *width,
                                                             guint *height);
    void                ogmrip_video_codec_set_scale_size   (OGMRipVideoCodec *video,
                                                             guint width,
                                                             guint height);
    gint                ogmrip_video_codec_get_scaler       (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_scaler       (OGMRipVideoCodec *video,
                                                             OGMRipScalerType scaler);
    gint                ogmrip_video_codec_get_threads      (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_threads      (OGMRipVideoCodec *video,
                                                             guint threads);
    gboolean            ogmrip_video_codec_get_trellis      (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_trellis      (OGMRipVideoCodec *video,
                                                             gboolean trellis);
    gboolean            ogmrip_video_codec_get_turbo        (OGMRipVideoCodec *video);
    void                ogmrip_video_codec_set_turbo        (OGMRipVideoCodec *video,
                                                             gboolean turbo);
    gint                ogmrip_video_codec_get_start_delay  (OGMRipVideoCodec *video);
    gint                ogmrip_video_codec_is_interlaced    (OGMRipVideoCodec *video);

## Object Hierarchy

      GObject
       +----OGMJobSpawn
             +----OGMJobContainer
                   +----OGMJobBin
                         +----OGMRipCodec
                               +----OGMRipVideoCodec

## Properties

      "angle"                    guint                 : Read / Write
      "bframes"                  guint                 : Read / Write
      "bitrate"                  guint                 : Read / Write
      "bpp"                      gdouble               : Read / Write
      "cartoon"                  gboolean              : Read / Write
      "deblock"                  gboolean              : Read / Write
      "denoise"                  gboolean              : Read / Write
      "dering"                   gboolean              : Read / Write
      "grayscale"                gboolean              : Read / Write
      "passes"                   guint                 : Read / Write
      "qpel"                     gboolean              : Read / Write
      "quantizer"                gdouble               : Read / Write
      "threads"                  guint                 : Read / Write
      "trellis"                  gboolean              : Read / Write
      "turbo"                    gboolean              : Read / Write
      "v4mv"                     gboolean              : Read / Write

## Description

## Details

### struct OGMRipVideoCodec

    struct OGMRipVideoCodec;

### struct OGMRipVideoCodecClass

    struct OGMRipVideoCodecClass {
      OGMRipCodecClass parent_class;

      /* signals */
      void (* pass) (OGMRipVideoCodec *video,
                     guint       pass);

      /* vtable */
      gint (* get_start_delay) (OGMRipVideoCodec  *video);
      void (* set_quality)     (OGMRipVideoCodec  *video,
                                OGMRipQualityType quality);
    };

### ogmrip_video_codec_analyze ()

    gboolean            ogmrip_video_codec_analyze          (OGMRipVideoCodec *video,
                                                             guint nframes);

Analyze the video stream to detect if the video is progressive, interlaced and/or telecine.

`video` : | an OGMRipVideoCodec
`nframes` : | the number of frames
Returns : | `FALSE`, on error or cancel

### ogmrip_video_codec_autocrop ()

    gboolean            ogmrip_video_codec_autocrop         (OGMRipVideoCodec *video,
                                                             guint nframes);

Autodetects the cropping parameters.

`video` : | an OGMRipVideoCodec
`nframes` : | the number of frames
Returns : | `FALSE`, on error or cancel

### ogmrip_video_codec_autoscale ()

    void                ogmrip_video_codec_autoscale        (OGMRipVideoCodec *video);

Autodetects the scaling parameters.

`video` : | an OGMRipVideoCodec

### ogmrip_video_codec_autobitrate ()

    void                ogmrip_video_codec_autobitrate      (OGMRipVideoCodec *video,
                                                             guint64 nonvideo_size,
                                                             guint64 overhead_size,
                                                             guint64 total_size);

Autodetects the video bitrate.

`video` : | an OGMRipVideoCodec
`nonvideo_size` : | the size of the non video streams
`overhead_size` : | the size of the overhead
`total_size` : | the total targetted size

### ogmrip_video_codec_get_4mv ()

    gboolean            ogmrip_video_codec_get_4mv          (OGMRipVideoCodec *video);

Gets whether 4 motion vectors per macroblock are allowed.

`video` : | an OGMRipVideoCodec
Returns : | `TRUE` if 4 motion vectors per macroblock are allowed

### ogmrip_video_codec_set_4mv ()

    void                ogmrip_video_codec_set_4mv          (OGMRipVideoCodec *video,
                                                             gboolean v4mv);

Sets whether to allow 4 motion vectors per macroblock.

`video` : | an OGMRipVideoCodec
`v4mv` : | `TRUE` to allow 4 motion vectors per macroblock

### ogmrip_video_codec_get_angle ()

    gint                ogmrip_video_codec_get_angle        (OGMRipVideoCodec *video);

Gets the current angle.

`video` : | an OGMRipVideoCodec
Returns : | the angle, or -1

### ogmrip_video_codec_set_angle ()

    void                ogmrip_video_codec_set_angle        (OGMRipVideoCodec *video,
                                                             guint angle);

Sets the angle to encode.

`video` : | an OGMRipVideoCodec
`angle` : | the angle

### ogmrip_video_codec_get_aspect_ratio ()

    void                ogmrip_video_codec_get_aspect_ratio (OGMRipVideoCodec *video,
                                                             guint *num,
                                                             guint *denom);

Gets the aspect ratio of the movie.

`video` : | an OGMRipVideoCodec
`num` : | a pointer to store the numerator of the aspect ratio
`denom` : | a pointer to store the denominator of the aspect ratio

### ogmrip_video_codec_set_aspect_ratio ()

    void                ogmrip_video_codec_set_aspect_ratio (OGMRipVideoCodec *video,
                                                             guint num,
                                                             guint denom);

Sets the aspect ratio of the movie.

`video` : | an OGMRipVideoCodec
`num` : | the numerator of the aspect ratio
`denom` : | the denominator of the aspect ratio

### ogmrip_video_codec_get_bitrate ()

    gint                ogmrip_video_codec_get_bitrate      (OGMRipVideoCodec *video);

Gets the video bitrate in bits/second.

`video` : | an OGMRipVideoCodec
Returns : | the video bitrate, or -1

### ogmrip_video_codec_set_bitrate ()

    void                ogmrip_video_codec_set_bitrate      (OGMRipVideoCodec *video,
                                                             guint bitrate);

Sets the video bitrate to be used in bits/second, 4000 being the lowest and 24000000 the highest available bitrates.

`video` : | an OGMRipVideoCodec
`bitrate` : | the video bitrate

### ogmrip_video_codec_get_bits_per_pixel ()

    gdouble             ogmrip_video_codec_get_bits_per_pixel
                                                            (OGMRipVideoCodec *video);

Gets the number of bits per pixel.

`video` : | an OGMRipVideoCodec
Returns : | the number of bits per pixel, or -1

### ogmrip_video_codec_set_bits_per_pixel ()

    void                ogmrip_video_codec_set_bits_per_pixel
                                                            (OGMRipVideoCodec *video,
                                                             gdouble bpp);

Sets the number of bits per pixel to be used.

`video` : | an OGMRipVideoCodec
`bpp` : | the number of bits per pixel

### ogmrip_video_codec_get_cartoon ()

    gboolean            ogmrip_video_codec_get_cartoon      (OGMRipVideoCodec *video);

Gets whether the movie is a cartoon.

`video` : | an OGMRipVideoCodec
Returns : | `TRUE` if movie is a cartoon

### ogmrip_video_codec_set_cartoon ()

    void                ogmrip_video_codec_set_cartoon      (OGMRipVideoCodec *video,
                                                             gboolean cartoon);

Sets whether the movie is a cartoon.

`video` : | an OGMRipVideoCodec
`cartoon` : | `TRUE` if movie is a cartoon

### ogmrip_video_codec_get_crop_size ()

    gboolean            ogmrip_video_codec_get_crop_size    (OGMRipVideoCodec *video,
                                                             guint *x,
                                                             guint *y,
                                                             guint *width,
                                                             guint *height);

Gets whether the video will be cropped and the crop size.

`video` : | an OGMRipVideoCodec
`x` : | a pointer to store the cropped x position
`y` : | a pointer to store the cropped y position
`width` : | a pointer to store the cropped width
`height` : | a pointer to store the cropped height
Returns : | `TRUE` if the video will be cropped

### ogmrip_video_codec_set_crop_size ()

    void                ogmrip_video_codec_set_crop_size    (OGMRipVideoCodec *video,
                                                             guint x,
                                                             guint y,
                                                             guint width,
                                                             guint height);

Sets the crop size of the movie.

`video` : | an OGMRipVideoCodec
`x` : | the cropped x position
`y` : | the cropped y position
`width` : | the cropped width
`height` : | the cropped height

### ogmrip_video_codec_get_deblock ()

    gboolean            ogmrip_video_codec_get_deblock      (OGMRipVideoCodec *video);

Gets whether a deblocking filter will be applied.

`video` : | an OGMRipVideoCodec
Returns : | `TRUE` if a deblocking filter will be applied

### ogmrip_video_codec_set_deblock ()

    void                ogmrip_video_codec_set_deblock      (OGMRipVideoCodec *video,
                                                             gboolean deblock);

Sets whether to apply a deblocking filter.

`video` : | an OGMRipVideoCodec
`deblock` : | `TRUE` to apply a deblocking filter

### ogmrip_video_codec_get_deinterlacer ()

    gint                ogmrip_video_codec_get_deinterlacer (OGMRipVideoCodec *video);

Gets the currnet deinterlacer.

`video` : | an OGMRipVideoCodec
Returns : | the deinterlacer, or -1

### ogmrip_video_codec_set_deinterlacer ()

    void                ogmrip_video_codec_set_deinterlacer (OGMRipVideoCodec *video,
                                                             OGMRipDeintType deint);

Sets the deinterlacer to be used.

`video` : | an OGMRipVideoCodec
`deint` : | an OGMRipDeintType

### ogmrip_video_codec_get_denoise ()

    gboolean            ogmrip_video_codec_get_denoise      (OGMRipVideoCodec *video);

Gets whether to reduce image noise.

`video` : | an OGMRipVideoCodec
Returns : | `TRUE` to reduce image noise

### ogmrip_video_codec_set_denoise ()

    void                ogmrip_video_codec_set_denoise      (OGMRipVideoCodec *video,
                                                             gboolean denoise);

Sets whether to reduce image noise.

`video` : | an OGMRipVideoCodec
`denoise` : | `TRUE` to reduce image noise

### ogmrip_video_codec_get_dering ()

    gboolean            ogmrip_video_codec_get_dering       (OGMRipVideoCodec *video);

Gets whether a deringing filter will be applied.

`video` : | an OGMRipVideoCodec
Returns : | `TRUE` if a deringing filter will be applied

### ogmrip_video_codec_set_dering ()

    void                ogmrip_video_codec_set_dering       (OGMRipVideoCodec *video,
                                                             gboolean dering);

Sets whether to apply a deringing filter.

`video` : | an OGMRipVideoCodec
`dering` : | `TRUE` to apply a deringing filter

### ogmrip_video_codec_get_ensure_sync ()

    OGMDvdAudioStream * ogmrip_video_codec_get_ensure_sync  (OGMRipVideoCodec *video);

Gets the audio stream that will be encoded along with the video to ensure the A/V synchronization.

`video` : | an OGMRipVideoCodec
Returns : | the OGMDvdAudioStream, or NULL

### ogmrip_video_codec_set_ensure_sync ()

    void                ogmrip_video_codec_set_ensure_sync  (OGMRipVideoCodec *video,
                                                             OGMDvdAudioStream *stream);

Sets the audio stream that will be encoded along with the video to ensure the A/V synchronization.

`video` : | an OGMRipVideoCodec
`stream` : | an OGMDvdAudioStream

### ogmrip_video_codec_get_grayscale ()

    gboolean            ogmrip_video_codec_get_grayscale    (OGMRipVideoCodec *video);

Gets whether the movie is grayscale.

`video` : | an OGMRipVideoCodec
Returns : | `TRUE` if movie is grayscale

### ogmrip_video_codec_set_grayscale ()

    void                ogmrip_video_codec_set_grayscale    (OGMRipVideoCodec *video,
                                                             gboolean grayscale);

Sets whether the movie is grayscale.

`video` : | an OGMRipVideoCodec
`grayscale` : | `TRUE` if movie is grayscale

### ogmrip_video_codec_get_hard_subp ()

    OGMDvdSubpStream *  ogmrip_video_codec_get_hard_subp    (OGMRipVideoCodec *video,
                                                             gboolean *forced);

Gets the subp stream that will be hardcoded in the video.

`video` : | an OGMRipVideoCodec
`forced` : | location to store whether to hardcode forced subs only
Returns : | the OGMDvdSubpStream, or NULL

### ogmrip_video_codec_set_hard_subp ()

    void                ogmrip_video_codec_set_hard_subp    (OGMRipVideoCodec *video,
                                                             OGMDvdSubpStream *stream,
                                                             gboolean forced);

Sets the subp stream that will be hardcoded in the video.

`video` : | an OGMRipVideoCodec
`stream` : | an OGMDvdSubpStream
`forced` : | whether to hardcode forced subs only

### ogmrip_video_codec_get_max_b_frames ()

    gint                ogmrip_video_codec_get_max_b_frames (OGMRipVideoCodec *video);

Gets the maximum number of B-frames to put between I/P-frames.

`video` : | an OGMRipVideoCodec
Returns : | the maximum number of B-frames, or -1

### ogmrip_video_codec_set_max_b_frames ()

    void                ogmrip_video_codec_set_max_b_frames (OGMRipVideoCodec *video,
                                                             guint max_b_frames);

Sets the maximum number of B-frames to put between I/P-frames.

`video` : | an OGMRipVideoCodec
`max_b_frames` : | the maximum number of B-frames

### ogmrip_video_codec_get_max_size ()

    gboolean            ogmrip_video_codec_get_max_size     (OGMRipVideoCodec *video,
                                                             guint *width,
                                                             guint *height,
                                                             gboolean *expand);

Gets wether the video has a maximum size and the maximum size.

`video` : | an OGMRipVideoCodec
`width` : | a pointer to store the maximum width
`height` : | a pointer to store the maximum height
`expand` : | whether the video must be expanded
Returns : | `TRUE` if the video has a maximum size

### ogmrip_video_codec_set_max_size ()

    void                ogmrip_video_codec_set_max_size     (OGMRipVideoCodec *video,
                                                             guint width,
                                                             guint height,
                                                             gboolean expand);

Sets the maximum size of the movie.

`video` : | an OGMRipVideoCodec
`width` : | the maximum width
`height` : | the maximum height
`expand` : | wheter to expand the video

### ogmrip_video_codec_get_min_size ()

    gboolean            ogmrip_video_codec_get_min_size     (OGMRipVideoCodec *video,
                                                             guint *width,
                                                             guint *height);

Gets wether the video has a minimum size and the minimum size.

`video` : | an OGMRipVideoCodec
`width` : | a pointer to store the minimum width
`height` : | a pointer to store the minimum height
Returns : | `TRUE` if the video has a minimum size

### ogmrip_video_codec_set_min_size ()

    void                ogmrip_video_codec_set_min_size     (OGMRipVideoCodec *video,
                                                             guint width,
                                                             guint height);

Sets the minimum size of the movie.

`video` : | an OGMRipVideoCodec
`width` : | the minimum width
`height` : | the minimum height

### ogmrip_video_codec_get_passes ()

    gint                ogmrip_video_codec_get_passes       (OGMRipVideoCodec *video);

Gets the number of passes.

`video` : | an OGMRipVideoCodec
Returns : | the pass number, or -1

### ogmrip_video_codec_set_passes ()

    void                ogmrip_video_codec_set_passes       (OGMRipVideoCodec *video,
                                                             guint pass);

Sets the number of passes.

`video` : | an OGMRipVideoCodec
`pass` : | the pass number

### ogmrip_video_codec_get_qpel ()

    gboolean            ogmrip_video_codec_get_qpel         (OGMRipVideoCodec *video);

Sets whether quarter pel motion compensation is used.

`video` : | an OGMRipVideoCodec
Returns : | `TRUE` if quarter pel motion compensation is used

### ogmrip_video_codec_set_qpel ()

    void                ogmrip_video_codec_set_qpel         (OGMRipVideoCodec *video,
                                                             gboolean qpel);

Sets whether to use quarter pel motion compensation.

`video` : | an OGMRipVideoCodec
`qpel` : | `TRUE` to use quarter pel motion compensation

### ogmrip_video_codec_get_quality ()

    gint                ogmrip_video_codec_get_quality      (OGMRipVideoCodec *video);

Gets the quality of the encoding.

`video` : | an OGMRipVideoCodec
Returns : | the OGMRipQualityType, or -1

### ogmrip_video_codec_set_quality ()

    void                ogmrip_video_codec_set_quality      (OGMRipVideoCodec *video,
                                                             OGMRipQualityType quality);

Sets the quality of the encoding.

`video` : | an OGMRipVideoCodec
`quality` : | the OGMRipQualityType

### ogmrip_video_codec_get_quantizer ()

    gdouble             ogmrip_video_codec_get_quantizer    (OGMRipVideoCodec *video);

Gets the video quantizer.

`video` : | an OGMRipVideoCodec
Returns : | the video quantizer, or -1

### ogmrip_video_codec_set_quantizer ()

    void                ogmrip_video_codec_set_quantizer    (OGMRipVideoCodec *video,
                                                             gdouble quantizer);

Sets the video quantizer to be used, 1 being the lowest and 31 the highest available quantizers.

`video` : | an OGMRipVideoCodec
`quantizer` : | the video quantizer

### ogmrip_video_codec_get_raw_size ()

    void                ogmrip_video_codec_get_raw_size     (OGMRipVideoCodec *video,
                                                             guint *width,
                                                             guint *height);

Gets the raw size of the video.

`video` : | an OGMRipVideoCodec
`width` : | a pointer to store the width
`height` : | a pointer to store the height

### ogmrip_video_codec_get_scale_size ()

    gboolean            ogmrip_video_codec_get_scale_size   (OGMRipVideoCodec *video,
                                                             guint *width,
                                                             guint *height);

Gets whether the video will be scaled and the scale size.

`video` : | an OGMRipVideoCodec
`width` : | a pointer to store the scaled width
`height` : | a pointer to store the scaled height
Returns : | `TRUE` if the video will be scaled

### ogmrip_video_codec_set_scale_size ()

    void                ogmrip_video_codec_set_scale_size   (OGMRipVideoCodec *video,
                                                             guint width,
                                                             guint height);

Sets the scaled size of the movie.

`video` : | an OGMRipVideoCodec
`width` : | the scaled width
`height` : | the scaled height

### ogmrip_video_codec_get_scaler ()

    gint                ogmrip_video_codec_get_scaler       (OGMRipVideoCodec *video);

Gets the current software scaler.

`video` : | an OGMRipVideoCodec
Returns : | the software scaler, or -1

### ogmrip_video_codec_set_scaler ()

    void                ogmrip_video_codec_set_scaler       (OGMRipVideoCodec *video,
                                                             OGMRipScalerType scaler);

Sets the software scaler to be used.

`video` : | an OGMRipVideoCodec
`scaler` : | an OGMRipScalerType

### ogmrip_video_codec_get_threads ()

    gint                ogmrip_video_codec_get_threads      (OGMRipVideoCodec *video);

Gets the number of threads.

`video` : | an OGMRipVideoCodec
Returns : | the number of threads, or -1

### ogmrip_video_codec_set_threads ()

    void                ogmrip_video_codec_set_threads      (OGMRipVideoCodec *video,
                                                             guint threads);

Sets the number of threads to be used.

`video` : | an OGMRipVideoCodec
`threads` : | the number of threads

### ogmrip_video_codec_get_trellis ()

    gboolean            ogmrip_video_codec_get_trellis      (OGMRipVideoCodec *video);

Gets whether trellis quantization is enabled.

`video` : | an OGMRipVideoCodec
Returns : | `TRUE` if trellis quantization is enabled

### ogmrip_video_codec_set_trellis ()

    void                ogmrip_video_codec_set_trellis      (OGMRipVideoCodec *video,
                                                             gboolean trellis);

Sets whether trellis quantization will be enabled.

`video` : | an OGMRipVideoCodec
`trellis` : | `TRUE` to enable trellis quantization

### ogmrip_video_codec_get_turbo ()

    gboolean            ogmrip_video_codec_get_turbo        (OGMRipVideoCodec *video);

Gets whether turbo is enabled.

`video` : | an OGMRipVideoCodec
Returns : | `TRUE` if turbo is enabled

### ogmrip_video_codec_set_turbo ()

    void                ogmrip_video_codec_set_turbo        (OGMRipVideoCodec *video,
                                                             gboolean turbo);

Sets whether to enable turbo.

`video` : | an OGMRipVideoCodec
`turbo` : | `TRUE` to enable turbo

### ogmrip_video_codec_get_start_delay ()

    gint                ogmrip_video_codec_get_start_delay  (OGMRipVideoCodec *video);

Gets the start delay that must be applied to audio streams when merging.

`video` : | an OGMRipVideoCodec
Returns : | the start delay, or -1

### ogmrip_video_codec_is_interlaced ()

    gint                ogmrip_video_codec_is_interlaced    (OGMRipVideoCodec *video);

Gets whether the video stream is interlaced.

`video` : | an OGMRipVideoCodec
Returns : | 1 if the video interlaced, 0 if it isn't, -1 otherwise.

## Property Details

### The `"angle"` property

      "angle"                    guint                 : Read / Write

Set angle.

Allowed values: >= 1

Default value: 1

### The `"bframes"` property

      "bframes"                  guint                 : Read / Write

Set b-frames.

Allowed values: <= 4

Default value: 2

### The `"bitrate"` property

      "bitrate"                  guint                 : Read / Write

Set bitrate.

Allowed values: [4000,24000000]

Default value: 800000

### The `"bpp"` property

      "bpp"                      gdouble               : Read / Write

Set bits per pixel.

Allowed values: [0,1]

Default value: 0.25

### The `"cartoon"` property

      "cartoon"                  gboolean              : Read / Write

Set cartoon.

Default value: FALSE

### The `"deblock"` property

      "deblock"                  gboolean              : Read / Write

Set deblock.

Default value: TRUE

### The `"denoise"` property

      "denoise"                  gboolean              : Read / Write

Set denoise.

Default value: FALSE

### The `"dering"` property

      "dering"                   gboolean              : Read / Write

Set dering.

Default value: TRUE

### The `"grayscale"` property

      "grayscale"                gboolean              : Read / Write

Set grayscale.

Default value: FALSE

### The `"passes"` property

      "passes"                   guint                 : Read / Write

Set the number of passes.

Allowed values: >= 1

Default value: 1

### The `"qpel"` property

      "qpel"                     gboolean              : Read / Write

Set quarter pel motion compensation.

Default value: FALSE

### The `"quantizer"` property

      "quantizer"                gdouble               : Read / Write

Set quantizer.

Allowed values: [-1,31]

Default value: -1

### The `"threads"` property

      "threads"                  guint                 : Read / Write

Set the number of threads.

Default value: 0

### The `"trellis"` property

      "trellis"                  gboolean              : Read / Write

Set trellis.

Default value: TRUE

### The `"turbo"` property

      "turbo"                    gboolean              : Read / Write

Set turbo.

Default value: FALSE

### The `"v4mv"` property

      "v4mv"                     gboolean              : Read / Write

Set 4 motion vectors per macroblock.

Default value: TRUE