OGMRipEncoding

## OGMRipEncoding OGMRipEncoding — An all-in-one component to encode DVD titles |

## Synopsis

    #include <ogmrip-encoding.h>

    struct              OGMRipEncoding;
    struct              OGMRipEncodingClass;
    #define             OGMRIP_ENCODING_IS_ANALYZED         (enc)
    #define             OGMRIP_ENCODING_IS_BACKUPED         (enc)
    #define             OGMRIP_ENCODING_IS_BACKUPING        (enc)
    #define             OGMRIP_ENCODING_IS_EXTRACTED        (enc)
    #define             OGMRIP_ENCODING_IS_EXTRACTING       (enc)
    #define             OGMRIP_ENCODING_IS_RUNNING          (enc)
    #define             OGMRIP_ENCODING_IS_TESTED           (enc)
    #define             OGMRIP_ENCODING_IS_TESTING          (enc)
    enum                OGMRipEncodingFlags;
    enum                OGMRipEncodingMethod;
    enum                OGMRipEncodingError;
    enum                OGMRipTaskEvent;
    enum                OGMRipTaskType;
    enum                OGMRipOptionsType;
    gboolean            (*OGMRipEncodingFunc)               (OGMRipEncoding *encoding,
                                                             gpointer data);
    void                (*OGMRipEncodingAudioFunc)          (OGMRipEncoding *encoding,
                                                             OGMDvdAudioStream *stream,
                                                             OGMRipAudioOptions *options,
                                                             gpointer data);
    void                (*OGMRipEncodingSubpFunc)           (OGMRipEncoding *encoding,
                                                             OGMDvdSubpStream *stream,
                                                             OGMRipSubpOptions *options,
                                                             gpointer data);
    void                (*OGMRipEncodingFileFunc)           (OGMRipEncoding *encoding,
                                                             OGMRipFile *file,
                                                             gpointer data);
    OGMRipEncoding *    ogmrip_encoding_new                 (OGMDvdTitle *title,
                                                             const gchar *filename);
    OGMRipEncoding *    ogmrip_encoding_new_from_file       (const gchar *filename,
                                                             GError **error);
    gint                ogmrip_encoding_backup              (OGMRipEncoding *encoding,
                                                             GError **error);
    gint                ogmrip_encoding_test                (OGMRipEncoding *encoding,
                                                             GError **error);
    gint                ogmrip_encoding_extract             (OGMRipEncoding *encoding,
                                                             GError **error);
    void                ogmrip_encoding_cancel              (OGMRipEncoding *encoding);
    void                ogmrip_encoding_suspend             (OGMRipEncoding *encoding);
    void                ogmrip_encoding_resume              (OGMRipEncoding *encoding);
    void                ogmrip_encoding_cleanup             (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_dump                (OGMRipEncoding *encoding,
                                                             const gchar *filename);
    gboolean            ogmrip_encoding_equal               (OGMRipEncoding *encoding1,
                                                             OGMRipEncoding *encoding2);
    gboolean            ogmrip_encoding_check_filename      (OGMRipEncoding *encoding,
                                                             GError **error);
    gboolean            ogmrip_encoding_set_container_type  (OGMRipEncoding *encoding,
                                                             GType type,
                                                             GError **error);
    GType               ogmrip_encoding_get_container_type  (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_set_video_codec_type
                                                            (OGMRipEncoding *encoding,
                                                             GType type,
                                                             GError **error);
    GType               ogmrip_encoding_get_video_codec_type
                                                            (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_add_audio_stream    (OGMRipEncoding *encoding,
                                                             OGMDvdAudioStream *stream,
                                                             OGMRipAudioOptions *options,
                                                             GError **error);
    gint                ogmrip_encoding_get_n_audio_streams (OGMRipEncoding *encoding);
    OGMDvdAudioStream * ogmrip_encoding_get_nth_audio_stream
                                                            (OGMRipEncoding *encoding,
                                                             guint n);
    void                ogmrip_encoding_foreach_audio_streams
                                                            (OGMRipEncoding *encoding,
                                                             OGMRipEncodingAudioFunc func,
                                                             gpointer data);
    gboolean            ogmrip_encoding_get_nth_audio_options
                                                            (OGMRipEncoding *encoding,
                                                             guint n,
                                                             OGMRipAudioOptions *options);
    gboolean            ogmrip_encoding_add_subp_stream     (OGMRipEncoding *encoding,
                                                             OGMDvdSubpStream *stream,
                                                             OGMRipSubpOptions *options,
                                                             GError **error);
    gint                ogmrip_encoding_get_n_subp_streams  (OGMRipEncoding *encoding);
    OGMDvdSubpStream *  ogmrip_encoding_get_nth_subp_stream (OGMRipEncoding *encoding,
                                                             guint n);
    void                ogmrip_encoding_foreach_subp_streams
                                                            (OGMRipEncoding *encoding,
                                                             OGMRipEncodingSubpFunc func,
                                                             gpointer data);
    gboolean            ogmrip_encoding_get_nth_subp_options
                                                            (OGMRipEncoding *encoding,
                                                             guint n,
                                                             OGMRipSubpOptions *options);
    gboolean            ogmrip_encoding_add_audio_file      (OGMRipEncoding *encoding,
                                                             OGMRipFile *file,
                                                             GError **error);
    gint                ogmrip_encoding_get_n_audio_files   (OGMRipEncoding *encoding);
    OGMRipFile *        ogmrip_encoding_get_nth_audio_file  (OGMRipEncoding *encoding,
                                                             guint n);
    void                ogmrip_encoding_foreach_audio_files (OGMRipEncoding *encoding,
                                                             OGMRipEncodingFileFunc func,
                                                             gpointer data);
    gboolean            ogmrip_encoding_add_subp_file       (OGMRipEncoding *encoding,
                                                             OGMRipFile *file,
                                                             GError **error);
    gint                ogmrip_encoding_get_n_subp_files    (OGMRipEncoding *encoding);
    OGMRipFile *        ogmrip_encoding_get_nth_subp_file   (OGMRipEncoding *encoding,
                                                             guint n);
    void                ogmrip_encoding_foreach_subp_files  (OGMRipEncoding *encoding,
                                                             OGMRipEncodingFileFunc func,
                                                             gpointer data);
    gint                ogmrip_encoding_get_angle           (OGMRipEncoding *encoding);
    void                ogmrip_encoding_get_aspect_ratio    (OGMRipEncoding *encoding,
                                                             guint *numerator,
                                                             guint *denominator);
    gboolean            ogmrip_encoding_get_auto_subp       (OGMRipEncoding *encoding);
    gint                ogmrip_encoding_get_bitrate         (OGMRipEncoding *encoding);
    gdouble             ogmrip_encoding_get_bits_per_pixel  (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_can_crop        (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_can_scale       (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_cartoon         (OGMRipEncoding *encoding);
    const gchar *       ogmrip_encoding_get_chapter_label   (OGMRipEncoding *encoding,
                                                             guint nr);
    void                ogmrip_encoding_get_chapters        (OGMRipEncoding *encoding,
                                                             guint *start_chap,
                                                             gint *end_chap);
    gint                ogmrip_encoding_get_chapters_language
                                                            (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_copy_dvd        (OGMRipEncoding *encoding);
    gint                ogmrip_encoding_get_crop            (OGMRipEncoding *encoding,
                                                             guint *x,
                                                             guint *y,
                                                             guint *w,
                                                             guint *h);
    gboolean            ogmrip_encoding_get_deblock         (OGMRipEncoding *encoding);
    gint                ogmrip_encoding_get_deinterlacer    (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_denoise         (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_dering          (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_ensure_sync     (OGMRipEncoding *encoding);
    const gchar *       ogmrip_encoding_get_filename        (OGMRipEncoding *encoding);
    guint32             ogmrip_encoding_get_flags           (OGMRipEncoding *encoding);
    const gchar *       ogmrip_encoding_get_fourcc          (OGMRipEncoding *encoding);
    const gchar *       ogmrip_encoding_get_id              (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_keep_tmp_files  (OGMRipEncoding *encoding);
    const gchar *       ogmrip_encoding_get_label           (OGMRipEncoding *encoding);
    const gchar *       ogmrip_encoding_get_logfile         (OGMRipEncoding *encoding);
    void                ogmrip_encoding_get_max_size        (OGMRipEncoding *encoding,
                                                             guint *width,
                                                             guint *height,
                                                             gboolean *expand);
    gint                ogmrip_encoding_get_method          (OGMRipEncoding *encoding);
    void                ogmrip_encoding_get_min_size        (OGMRipEncoding *encoding,
                                                             guint *width,
                                                             guint *height);
    gint                ogmrip_encoding_get_passes          (OGMRipEncoding *encoding);
    gint                ogmrip_encoding_get_preset          (OGMRipEncoding *encoding);
    const gchar *       ogmrip_encoding_get_profile         (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_qpel            (OGMRipEncoding *encoding);
    gdouble             ogmrip_encoding_get_quantizer       (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_relative        (OGMRipEncoding *encoding);
    gint                ogmrip_encoding_get_scale           (OGMRipEncoding *encoding,
                                                             guint *w,
                                                             guint *h);
    gint                ogmrip_encoding_get_scaler          (OGMRipEncoding *encoding);
    gint                ogmrip_encoding_get_target_number   (OGMRipEncoding *encoding);
    gint                ogmrip_encoding_get_target_size     (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_test            (OGMRipEncoding *encoding);
    gint                ogmrip_encoding_get_threads         (OGMRipEncoding *encoding);
    OGMDvdTitle *       ogmrip_encoding_get_title           (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_trellis         (OGMRipEncoding *encoding);
    gboolean            ogmrip_encoding_get_turbo           (OGMRipEncoding *encoding);
    void                ogmrip_encoding_set_angle           (OGMRipEncoding *encoding,
                                                             guint angle);
    void                ogmrip_encoding_set_aspect_ratio    (OGMRipEncoding *encoding,
                                                             guint numerator,
                                                             guint denominator);
    void                ogmrip_encoding_set_auto_subp       (OGMRipEncoding *encoding,
                                                             gboolean auto_subp);
    void                ogmrip_encoding_set_bitrate         (OGMRipEncoding *encoding,
                                                             guint bitrate);
    void                ogmrip_encoding_set_bits_per_pixel  (OGMRipEncoding *encoding,
                                                             gdouble bpp);
    void                ogmrip_encoding_set_can_crop        (OGMRipEncoding *encoding,
                                                             gboolean can_crop);
    void                ogmrip_encoding_set_can_scale       (OGMRipEncoding *encoding,
                                                             gboolean can_scale);
    void                ogmrip_encoding_set_cartoon         (OGMRipEncoding *encoding,
                                                             gboolean cartoon);
    void                ogmrip_encoding_set_chapter_label   (OGMRipEncoding *encoding,
                                                             guint nr,
                                                             const gchar *label);
    void                ogmrip_encoding_set_chapters        (OGMRipEncoding *encoding,
                                                             guint start_chap,
                                                             gint end_chap);
    void                ogmrip_encoding_set_chapters_language
                                                            (OGMRipEncoding *encoding,
                                                             guint language);
    void                ogmrip_encoding_set_copy_dvd        (OGMRipEncoding *encoding,
                                                             gboolean copy_dvd);
    void                ogmrip_encoding_set_crop            (OGMRipEncoding *encoding,
                                                             OGMRipOptionsType type,
                                                             guint x,
                                                             guint y,
                                                             guint w,
                                                             guint h);
    void                ogmrip_encoding_set_deblock         (OGMRipEncoding *encoding,
                                                             gboolean deblock);
    void                ogmrip_encoding_set_deinterlacer    (OGMRipEncoding *encoding,
                                                             OGMRipDeintType deint);
    void                ogmrip_encoding_set_denoise         (OGMRipEncoding *encoding,
                                                             gboolean denoise);
    void                ogmrip_encoding_set_dering          (OGMRipEncoding *encoding,
                                                             gboolean dering);
    void                ogmrip_encoding_set_ensure_sync     (OGMRipEncoding *encoding,
                                                             gboolean ensure_sync);
    void                ogmrip_encoding_set_filename        (OGMRipEncoding *encoding,
                                                             const gchar *filename);
    void                ogmrip_encoding_set_fourcc          (OGMRipEncoding *encoding,
                                                             const gchar *fourcc);
    void                ogmrip_encoding_set_keep_tmp_files  (OGMRipEncoding *encoding,
                                                             gboolean keep_tmp_files);
    void                ogmrip_encoding_set_label           (OGMRipEncoding *encoding,
                                                             const gchar *label);
    void                ogmrip_encoding_set_max_size        (OGMRipEncoding *encoding,
                                                             guint width,
                                                             guint height,
                                                             gboolean expand);
    void                ogmrip_encoding_set_method          (OGMRipEncoding *encoding,
                                                             OGMRipEncodingMethod method);
    void                ogmrip_encoding_set_min_size        (OGMRipEncoding *encoding,
                                                             guint width,
                                                             guint height);
    gboolean            ogmrip_encoding_set_nth_audio_options
                                                            (OGMRipEncoding *encoding,
                                                             guint n,
                                                             OGMRipAudioOptions *options,
                                                             GError **error);
    gboolean            ogmrip_encoding_set_nth_subp_options
                                                            (OGMRipEncoding *encoding,
                                                             guint n,
                                                             OGMRipSubpOptions *options,
                                                             GError **error);
    void                ogmrip_encoding_set_passes          (OGMRipEncoding *encoding,
                                                             guint passes);
    void                ogmrip_encoding_set_preset          (OGMRipEncoding *encoding,
                                                             OGMRipVideoPreset preset);
    void                ogmrip_encoding_set_profile         (OGMRipEncoding *encoding,
                                                             const gchar *profile);
    void                ogmrip_encoding_set_qpel            (OGMRipEncoding *encoding,
                                                             gboolean qpel);
    void                ogmrip_encoding_set_quantizer       (OGMRipEncoding *encoding,
                                                             gdouble quantizer);
    void                ogmrip_encoding_set_relative        (OGMRipEncoding *encoding,
                                                             gboolean relative);
    void                ogmrip_encoding_set_scale           (OGMRipEncoding *encoding,
                                                             OGMRipOptionsType type,
                                                             guint w,
                                                             guint h);
    void                ogmrip_encoding_set_scaler          (OGMRipEncoding *encoding,
                                                             OGMRipScalerType scaler);
    void                ogmrip_encoding_set_target_number   (OGMRipEncoding *encoding,
                                                             guint target_number);
    void                ogmrip_encoding_set_target_size     (OGMRipEncoding *encoding,
                                                             guint target_size);
    void                ogmrip_encoding_set_test            (OGMRipEncoding *encoding,
                                                             gboolean test);
    void                ogmrip_encoding_set_threads         (OGMRipEncoding *encoding,
                                                             guint threads);
    void                ogmrip_encoding_set_trellis         (OGMRipEncoding *encoding,
                                                             gboolean trellis);
    void                ogmrip_encoding_set_turbo           (OGMRipEncoding *encoding,
                                                             gboolean turbo);

## Object Hierarchy

      GObject
       +----OGMRipEncoding

## Properties

      "aspect-denom"             guint                 : Read / Write
      "aspect-num"               guint                 : Read / Write
      "auto-subp"                gboolean              : Read / Write
      "bitrate"                  guint                 : Read / Write
      "bpp"                      gdouble               : Read / Write
      "can-crop"                 gboolean              : Read / Write
      "can-scale"                gboolean              : Read / Write
      "cartoon"                  gboolean              : Read / Write
      "chapters-lang"            guint                 : Read / Write
      "container-type"           GType*                : Read / Write
      "copy-dvd"                 gboolean              : Read / Write
      "crop-height"              guint                 : Read / Write
      "crop-type"                guint                 : Read / Write
      "crop-width"               guint                 : Read / Write
      "crop-x"                   guint                 : Read / Write
      "crop-y"                   guint                 : Read / Write
      "deblock"                  gboolean              : Read / Write
      "deinterlacer"             guint                 : Read / Write
      "denoise"                  gboolean              : Read / Write
      "dering"                   gboolean              : Read / Write
      "end-chapter"              gint                  : Read / Write
      "ensure-sync"              gboolean              : Read / Write
      "expand"                   gboolean              : Read / Write
      "filename"                 gchar*                : Read / Write
      "fourcc"                   gchar*                : Read / Write
      "keep-tmp-files"           gboolean              : Read / Write
      "label"                    gchar*                : Read / Write
      "max-height"               guint                 : Read / Write
      "max-width"                guint                 : Read / Write
      "method"                   guint                 : Read / Write
      "min-height"               guint                 : Read / Write
      "min-width"                guint                 : Read / Write
      "passes"                   guint                 : Read / Write
      "preset"                   guint                 : Read / Write
      "profile"                  gchar*                : Read / Write
      "qpel"                     gboolean              : Read / Write
      "quantizer"                gdouble               : Read / Write
      "relative"                 gboolean              : Read / Write
      "scale-height"             guint                 : Read / Write
      "scale-type"               guint                 : Read / Write
      "scale-width"              guint                 : Read / Write
      "scaler"                   guint                 : Read / Write
      "start-chapter"            gint                  : Read / Write
      "target-number"            guint                 : Read / Write
      "target-size"              guint                 : Read / Write
      "test"                     gboolean              : Read / Write
      "threads"                  guint                 : Read / Write
      "trellis"                  gboolean              : Read / Write
      "turbo"                    gboolean              : Read / Write
      "video-codec-type"         GType*                : Read / Write

## Signals

      "complete"                                       : No Hooks
      "run"                                            : No Hooks
      "task"                                           : No Hooks

## Description

## Details

### struct OGMRipEncoding

    struct OGMRipEncoding;

### struct OGMRipEncodingClass

    struct OGMRipEncodingClass {
      GObjectClass parent_class;

      void (* run)      (OGMRipEncoding      *encoding);
      void (* complete) (OGMRipEncoding      *encoding,
                         OGMJobResultType    result);

      void (* task)     (OGMRipEncoding      *encoding,
                         OGMRipEncodingTask  *task);
    };

### OGMRIP_ENCODING_IS_ANALYZED()

    #define OGMRIP_ENCODING_IS_ANALYZED(enc)  ((ogmrip_encoding_get_flags (enc) & OGMRIP_ENCODING_ANALYZED) != 0)

Gets whether `encoding` has already been analyzed.

`Returns`: `TRUE` if already analyzed, `FALSE` otherwise

`enc` : | An OGMRipEncoding

### OGMRIP_ENCODING_IS_BACKUPED()

    #define OGMRIP_ENCODING_IS_BACKUPED(enc)  ((ogmrip_encoding_get_flags (enc) & OGMRIP_ENCODING_BACKUPED) != 0)

Gets whether `encoding` has already been backuped.

`Returns`: `TRUE` if already backuped, `FALSE` otherwise

`enc` : | An OGMRipEncoding

### OGMRIP_ENCODING_IS_BACKUPING()

    #define OGMRIP_ENCODING_IS_BACKUPING(enc)  ((ogmrip_encoding_get_flags (enc) & OGMRIP_ENCODING_BACKUPING) != 0)

Gets whether `encoding` is being backuped.

`Returns`: `TRUE` if backuping, `FALSE` otherwise

`enc` : | An OGMRipEncoding

### OGMRIP_ENCODING_IS_EXTRACTED()

    #define OGMRIP_ENCODING_IS_EXTRACTED(enc) ((ogmrip_encoding_get_flags (enc) & OGMRIP_ENCODING_EXTRACTED) != 0)

Gets whether `encoding` has already been extracted.

`Returns`: `TRUE` if already extracted, `FALSE` otherwise

`enc` : | An OGMRipEncoding

### OGMRIP_ENCODING_IS_EXTRACTING()

    #define OGMRIP_ENCODING_IS_EXTRACTING(enc) ((ogmrip_encoding_get_flags (enc) & OGMRIP_ENCODING_EXTRACTING) != 0)

Gets whether `encoding` is being extracted.

`Returns`: `TRUE` if extracting, `FALSE` otherwise

`enc` : | An OGMRipEncoding

### OGMRIP_ENCODING_IS_RUNNING()

    #define             OGMRIP_ENCODING_IS_RUNNING(enc)

Gets whether `encoding` is being backuped, tested, or extracted.

`Returns`: `TRUE` if backuping, testing, or extracting, `FALSE` otherwise

`enc` : | An OGMRipEncoding

### OGMRIP_ENCODING_IS_TESTED()

    #define OGMRIP_ENCODING_IS_TESTED(enc)    ((ogmrip_encoding_get_flags (enc) & OGMRIP_ENCODING_TESTED) != 0)

Gets whether `encoding` has already been tested.

`Returns`: `TRUE` if already tested, `FALSE` otherwise

`enc` : | An OGMRipEncoding

### OGMRIP_ENCODING_IS_TESTING()

    #define OGMRIP_ENCODING_IS_TESTING(enc)    ((ogmrip_encoding_get_flags (enc) & OGMRIP_ENCODING_TESTING) != 0)

Gets whether `encoding` is being tested.

`Returns`: `TRUE` if testing, `FALSE` otherwise

`enc` : | An OGMRipEncoding

### enum OGMRipEncodingFlags

    typedef enum {
      OGMRIP_ENCODING_BACKUPED   = 1 << 0,
      OGMRIP_ENCODING_ANALYZED   = 1 << 1,
      OGMRIP_ENCODING_TESTED     = 1 << 2,
      OGMRIP_ENCODING_EXTRACTED  = 1 << 3,
      OGMRIP_ENCODING_BACKUPING  = 1 << 4,
      OGMRIP_ENCODING_TESTING    = 1 << 5,
      OGMRIP_ENCODING_EXTRACTING = 1 << 6,
      OGMRIP_ENCODING_CANCELING  = 1 << 7
    } OGMRipEncodingFlags;

The encoding flags.

`OGMRIP_ENCODING_BACKUPED` | Whether the encoding has been backuped
`OGMRIP_ENCODING_ANALYZED` | Whether the encoding has been analyzed
`OGMRIP_ENCODING_TESTED` | Whether the encoding has been tested
`OGMRIP_ENCODING_EXTRACTED` | Whether the encoding has been extracted
`OGMRIP_ENCODING_BACKUPING` | If the encoding is being backuped
`OGMRIP_ENCODING_TESTING` | If the encoding is being tested
`OGMRIP_ENCODING_EXTRACTING` | If the encoding is being tested
`OGMRIP_ENCODING_CANCELING` | If the encoding is being cancelled

### enum OGMRipEncodingMethod

    typedef enum {
      OGMRIP_ENCODING_SIZE,
      OGMRIP_ENCODING_BITRATE,
      OGMRIP_ENCODING_QUANTIZER
    } OGMRipEncodingMethod;

The encoding methods.

`OGMRIP_ENCODING_SIZE` | Encoding with output size
`OGMRIP_ENCODING_BITRATE` | Encoding with constant bitrate
`OGMRIP_ENCODING_QUANTIZER` | Encoding with constant quantizer

### enum OGMRipEncodingError

    typedef enum {
      OGMRIP_ENCODING_ERROR_CONTAINER,
      OGMRIP_ENCODING_ERROR_STREAMS,
      OGMRIP_ENCODING_ERROR_SIZE,
      OGMRIP_ENCODING_ERROR_TEST,
      OGMRIP_ENCODING_ERROR_IMPORT,
      OGMRIP_ENCODING_ERROR_AUDIO,
      OGMRIP_ENCODING_ERROR_SUBP,
      OGMRIP_ENCODING_ERROR_UNKNOWN,
      OGMRIP_ENCODING_ERROR_FATAL
    } OGMRipEncodingError;

Error codes returned by `ogmdvd_disc_open()`

`OGMRIP_ENCODING_ERROR_CONTAINER` | Container and codecs are not compatible
`OGMRIP_ENCODING_ERROR_STREAMS` | A stream is not compatible
`OGMRIP_ENCODING_ERROR_SIZE` | No enough disk space
`OGMRIP_ENCODING_ERROR_TEST` | Cannot perform compressibility test
`OGMRIP_ENCODING_ERROR_IMPORT` | Cannot import encoding file
`OGMRIP_ENCODING_ERROR_AUDIO` | Cannot contain multiple audio streams
`OGMRIP_ENCODING_ERROR_SUBP` | Cannot contain multiple subp streams
`OGMRIP_ENCODING_ERROR_UNKNOWN` | Unknown error
`OGMRIP_ENCODING_ERROR_FATAL` | Fatal error

### enum OGMRipTaskEvent

    typedef enum {
      OGMRIP_TASK_RUN,
      OGMRIP_TASK_PROGRESS,
      OGMRIP_TASK_COMPLETE,
      OGMRIP_TASK_SUSPEND,
      OGMRIP_TASK_RESUME
    } OGMRipTaskEvent;

The events associated with encoding tasks.

`OGMRIP_TASK_RUN` | When a task is run
`OGMRIP_TASK_PROGRESS` | When a task has progressed
`OGMRIP_TASK_COMPLETE` | When a task completes
`OGMRIP_TASK_SUSPEND` | When a task is suspended
`OGMRIP_TASK_RESUME` | When a task is resumed

### enum OGMRipTaskType

    typedef enum {
      OGMRIP_TASK_BACKUP,
      OGMRIP_TASK_ANALYZE,
      OGMRIP_TASK_CHAPTERS,
      OGMRIP_TASK_AUDIO,
      OGMRIP_TASK_SUBP,
      OGMRIP_TASK_CROP,
      OGMRIP_TASK_TEST,
      OGMRIP_TASK_VIDEO,
      OGMRIP_TASK_MERGE
    } OGMRipTaskType;

The available tasks.

`OGMRIP_TASK_BACKUP` | Backup task
`OGMRIP_TASK_ANALYZE` | Analyze task
`OGMRIP_TASK_CHAPTERS` | Chapters extraction task
`OGMRIP_TASK_AUDIO` | Audio extraction task
`OGMRIP_TASK_SUBP` | Subtitles extraction task
`OGMRIP_TASK_CROP` | Automatic cropping task
`OGMRIP_TASK_TEST` | Compressibility test task
`OGMRIP_TASK_VIDEO` | Video extraction task
`OGMRIP_TASK_MERGE` | Merge task

### enum OGMRipOptionsType

    typedef enum {
      OGMRIP_OPTIONS_NONE,
      OGMRIP_OPTIONS_AUTOMATIC,
      OGMRIP_OPTIONS_MANUAL
    } OGMRipOptionsType;

How options are set.

`OGMRIP_OPTIONS_NONE` | The option is disabled
`OGMRIP_OPTIONS_AUTOMATIC` | The option will be automatically determined
`OGMRIP_OPTIONS_MANUAL` | The option has been manually set

### OGMRipEncodingFunc ()

    gboolean            (*OGMRipEncodingFunc)               (OGMRipEncoding *encoding,
                                                             gpointer data);

Specifies the type of functions passed to `ogmrip_encoding_manager_foreach()`.

`encoding` : | An OGMRipEncoding
`data` : | The user data
Returns : | `FALSE` to stop calling the function.

### OGMRipEncodingAudioFunc ()

    void                (*OGMRipEncodingAudioFunc)          (OGMRipEncoding *encoding,
                                                             OGMDvdAudioStream *stream,
                                                             OGMRipAudioOptions *options,
                                                             gpointer data);

Specifies the type of functions passed to `ogmrip_encoding_foreach_audio_streams()`.

`encoding` : | An OGMRipEncoding
`stream` : | An OGMDvdAudioStream
`options` : | An OGMRipAudioOptions
`data` : | The user data

### OGMRipEncodingSubpFunc ()

    void                (*OGMRipEncodingSubpFunc)           (OGMRipEncoding *encoding,
                                                             OGMDvdSubpStream *stream,
                                                             OGMRipSubpOptions *options,
                                                             gpointer data);

Specifies the type of functions passed to `ogmrip_encoding_foreach_subp_streams()`.

`encoding` : | An OGMRipEncoding
`stream` : | An OGMDvdSubpStream
`options` : | An OGMRipSubpOptions
`data` : | The user data

### OGMRipEncodingFileFunc ()

    void                (*OGMRipEncodingFileFunc)           (OGMRipEncoding *encoding,
                                                             OGMRipFile *file,
                                                             gpointer data);

Specifies the type of functions passed to `ogmrip_encoding_foreach_audio_files()`. and `ogmrip_encoding_foreach_subp_files()`.

`encoding` : | An OGMRipEncoding
`file` : | An OGMRipFile
`data` : | The user data

### ogmrip_encoding_new ()

    OGMRipEncoding *    ogmrip_encoding_new                 (OGMDvdTitle *title,
                                                             const gchar *filename);

Creates a new OGMRipEncoding.

`title` : | An OGMDvdTitle
`filename` : | The output filename
Returns : | The newly created OGMRipEncoding, or NULL

### ogmrip_encoding_new_from_file ()

    OGMRipEncoding *    ogmrip_encoding_new_from_file       (const gchar *filename,
                                                             GError **error);

Creates a new OGMRipEncoding from an XML file.

`filename` : | An encoding file
`error` : | Return location for error
Returns : | The newly created OGMRipEncoding, or NULL

### ogmrip_encoding_backup ()

    gint                ogmrip_encoding_backup              (OGMRipEncoding *encoding,
                                                             GError **error);

Performs all the steps necessary to copy the DVD title on the hard drive.

`encoding` : | An OGMRipEncoding
`error` : | Error location for error
Returns : | An OGMJobResultType

### ogmrip_encoding_test ()

    gint                ogmrip_encoding_test                (OGMRipEncoding *encoding,
                                                             GError **error);

Performs a compressibility test on the DVD title.

`encoding` : | An OGMRipEncoding
`error` : | Error location for error
Returns : | An OGMJobResultType

### ogmrip_encoding_extract ()

    gint                ogmrip_encoding_extract             (OGMRipEncoding *encoding,
                                                             GError **error);

Performs all the steps necessary to encode the DVD title.

`encoding` : | An OGMRipEncoding
`error` : | Error location for error
Returns : | An OGMJobResultType

### ogmrip_encoding_cancel ()

    void                ogmrip_encoding_cancel              (OGMRipEncoding *encoding);

Cancels an encoding.

`encoding` : | An OGMRipEncoding

### ogmrip_encoding_suspend ()

    void                ogmrip_encoding_suspend             (OGMRipEncoding *encoding);

Suspends an encoding.

`encoding` : | An OGMRipEncoding

### ogmrip_encoding_resume ()

    void                ogmrip_encoding_resume              (OGMRipEncoding *encoding);

Suspends an encoding.

`encoding` : | An OGMRipEncoding

### ogmrip_encoding_cleanup ()

    void                ogmrip_encoding_cleanup             (OGMRipEncoding *encoding);

Removes any remaining temporary files.

`encoding` : | An OGMRipEncoding

### ogmrip_encoding_dump ()

    gboolean            ogmrip_encoding_dump                (OGMRipEncoding *encoding,
                                                             const gchar *filename);

Dumps `encoding` to an XML file.

`encoding` : | An OGMRipEncoding
`filename` : | The output filename
Returns : | `TRUE` on success, or `FALSE` otherwise

### ogmrip_encoding_equal ()

    gboolean            ogmrip_encoding_equal               (OGMRipEncoding *encoding1,
                                                             OGMRipEncoding *encoding2);

Compares two encodings.

`encoding1` : | An OGMRipEncoding
`encoding2` : | An OGMRipEncoding
Returns : | `TRUE` if the encodings are equal, `FALSE` otherwise

### ogmrip_encoding_check_filename ()

    gboolean            ogmrip_encoding_check_filename      (OGMRipEncoding *encoding,
                                                             GError **error);

Checks whether a file with the same name already exists.

`encoding` : | An OGMRipEncoding
`error` : | Return location for error
Returns : | `TRUE` on success, `FALSE` if an error was set

### ogmrip_encoding_set_container_type ()

    gboolean            ogmrip_encoding_set_container_type  (OGMRipEncoding *encoding,
                                                             GType type,
                                                             GError **error);

Sets the type of the container. If the container cannot contain the video, audio, and/or subtitle codecs, an error will be set.

`encoding` : | An OGMRipEncoding
`type` : | The type of a container
`error` : | Return location for error
Returns : | `TRUE` on success, `FALSE` if an error was set

### ogmrip_encoding_get_container_type ()

    GType               ogmrip_encoding_get_container_type  (OGMRipEncoding *encoding);

Gets the type of the container.

`encoding` : | An OGMRipEncoding
Returns : | the type of the container

### ogmrip_encoding_set_video_codec_type ()

    gboolean            ogmrip_encoding_set_video_codec_type
                                                            (OGMRipEncoding *encoding,
                                                             GType type,
                                                             GError **error);

Sets the type of the vide codec. If the container cannot contain the video codec, an error will be set.

`encoding` : | An OGMRipEncoding
`type` : | The type of a video codec
`error` : | Return location for error
Returns : | `TRUE` on success, `FALSE` if an error was set

### ogmrip_encoding_get_video_codec_type ()

    GType               ogmrip_encoding_get_video_codec_type
                                                            (OGMRipEncoding *encoding);

Gets the type of the video codec.

`encoding` : | An OGMRipEncoding
Returns : | the type of the video codec

### ogmrip_encoding_add_audio_stream ()

    gboolean            ogmrip_encoding_add_audio_stream    (OGMRipEncoding *encoding,
                                                             OGMDvdAudioStream *stream,
                                                             OGMRipAudioOptions *options,
                                                             GError **error);

Adds an audio stream to the encoding.

`encoding` : | An OGMRipEncoding
`stream` : | An OGMDvdAudioStream
`options` : | An OGMRipAudioOptions
`error` : | Return location for error
Returns : | `TRUE` on success, `FALSE` if an error was set

### ogmrip_encoding_get_n_audio_streams ()

    gint                ogmrip_encoding_get_n_audio_streams (OGMRipEncoding *encoding);

Gets the number of audio streams of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The number of audio streams, or -1

### ogmrip_encoding_get_nth_audio_stream ()

    OGMDvdAudioStream * ogmrip_encoding_get_nth_audio_stream
                                                            (OGMRipEncoding *encoding,
                                                             guint n);

Gets the audio stream at the given position.

`encoding` : | An OGMRipEncoding
`n` : | The position of the stream, counting from 0
Returns : | An OGMDvdAudioStream, or NULL

### ogmrip_encoding_foreach_audio_streams ()

    void                ogmrip_encoding_foreach_audio_streams
                                                            (OGMRipEncoding *encoding,
                                                             OGMRipEncodingAudioFunc func,
                                                             gpointer data);

Calls the given function for each audio streams.

`encoding` : | An OGMRipEncoding
`func` : | The function to call with each audio streams
`data` : | User data to pass to the function

### ogmrip_encoding_get_nth_audio_options ()

    gboolean            ogmrip_encoding_get_nth_audio_options
                                                            (OGMRipEncoding *encoding,
                                                             guint n,
                                                             OGMRipAudioOptions *options);

Gets the options of the audio stream at the given position.

`encoding` : | An OGMRipEncoding
`n` : | The position of the stream, counting from 0
`options` : | A location to return the options
Returns : | `TRUE` on success, `FALSE` if there is no audio stream at the given position

### ogmrip_encoding_add_subp_stream ()

    gboolean            ogmrip_encoding_add_subp_stream     (OGMRipEncoding *encoding,
                                                             OGMDvdSubpStream *stream,
                                                             OGMRipSubpOptions *options,
                                                             GError **error);

Adds a subp stream to the encoding.

`encoding` : | An OGMRipEncoding
`stream` : | An OGMDvdSubpStream
`options` : | An OGMRipSubpOptions
`error` : | Return location for error
Returns : | `TRUE` on success, `FALSE` if an error was set

### ogmrip_encoding_get_n_subp_streams ()

    gint                ogmrip_encoding_get_n_subp_streams  (OGMRipEncoding *encoding);

Gets the number of subp streams of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The number of subp streams, or -1

### ogmrip_encoding_get_nth_subp_stream ()

    OGMDvdSubpStream *  ogmrip_encoding_get_nth_subp_stream (OGMRipEncoding *encoding,
                                                             guint n);

Gets the subp stream at the given position.

`encoding` : | An OGMRipEncoding
`n` : | The position of the stream, counting from 0
Returns : | An OGMDvdSubpStream, or NULL

### ogmrip_encoding_foreach_subp_streams ()

    void                ogmrip_encoding_foreach_subp_streams
                                                            (OGMRipEncoding *encoding,
                                                             OGMRipEncodingSubpFunc func,
                                                             gpointer data);

Calls the given function for each subp streams.

`encoding` : | An OGMRipEncoding
`func` : | The function to call with each subp streams
`data` : | User data to pass to the function

### ogmrip_encoding_get_nth_subp_options ()

    gboolean            ogmrip_encoding_get_nth_subp_options
                                                            (OGMRipEncoding *encoding,
                                                             guint n,
                                                             OGMRipSubpOptions *options);

Gets the options of the subp stream at the given position.

`encoding` : | An OGMRipEncoding
`n` : | The position of the stream, counting from 0
`options` : | A location to return the options
Returns : | `TRUE` on success, `FALSE` if there is no subp stream at the given position

### ogmrip_encoding_add_audio_file ()

    gboolean            ogmrip_encoding_add_audio_file      (OGMRipEncoding *encoding,
                                                             OGMRipFile *file,
                                                             GError **error);

Adds an audio file to the encoding.

`encoding` : | An OGMRipEncoding
`file` : | An OGMRipFile
`error` : | Return location for error
Returns : | `TRUE` on success, `FALSE` if an error was set

### ogmrip_encoding_get_n_audio_files ()

    gint                ogmrip_encoding_get_n_audio_files   (OGMRipEncoding *encoding);

Gets the number of audio files of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The number of audio files, or -1

### ogmrip_encoding_get_nth_audio_file ()

    OGMRipFile *        ogmrip_encoding_get_nth_audio_file  (OGMRipEncoding *encoding,
                                                             guint n);

Gets the audio file at the given position.

`encoding` : | An OGMRipEncoding
`n` : | The position of the file, counting from 0
Returns : | An OGMRipFile, or NULL

### ogmrip_encoding_foreach_audio_files ()

    void                ogmrip_encoding_foreach_audio_files (OGMRipEncoding *encoding,
                                                             OGMRipEncodingFileFunc func,
                                                             gpointer data);

Calls the given function for each audio file.

`encoding` : | An OGMRipEncoding
`func` : | The function to call with each audio file
`data` : | User data to pass to the function

### ogmrip_encoding_add_subp_file ()

    gboolean            ogmrip_encoding_add_subp_file       (OGMRipEncoding *encoding,
                                                             OGMRipFile *file,
                                                             GError **error);

Adds an subp file to the encoding.

`encoding` : | An OGMRipEncoding
`file` : | An OGMRipFile
`error` : | Return location for error
Returns : | `TRUE` on success, `FALSE` if an error was set

### ogmrip_encoding_get_n_subp_files ()

    gint                ogmrip_encoding_get_n_subp_files    (OGMRipEncoding *encoding);

Gets the number of subp files of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The number of subp files, or -1

### ogmrip_encoding_get_nth_subp_file ()

    OGMRipFile *        ogmrip_encoding_get_nth_subp_file   (OGMRipEncoding *encoding,
                                                             guint n);

Gets the subp file at the given position.

`encoding` : | An OGMRipEncoding
`n` : | The position of the stream, counting from 0
Returns : | An OGMRipFile, or NULL

### ogmrip_encoding_foreach_subp_files ()

    void                ogmrip_encoding_foreach_subp_files  (OGMRipEncoding *encoding,
                                                             OGMRipEncodingFileFunc func,
                                                             gpointer data);

Calls the given function for each subp file.

`encoding` : | An OGMRipEncoding
`func` : | The function to call with each subp file
`data` : | User data to pass to the function

### ogmrip_encoding_get_angle ()

    gint                ogmrip_encoding_get_angle           (OGMRipEncoding *encoding);

Gets the angle to encoding.

`encoding` : | An OGMRipEncoding
Returns : | The angle, or -1

### ogmrip_encoding_get_aspect_ratio ()

    void                ogmrip_encoding_get_aspect_ratio    (OGMRipEncoding *encoding,
                                                             guint *numerator,
                                                             guint *denominator);

Gets the aspect ratio of the encoding.

`encoding` : | An OGMRipEncoding
`numerator` : | A location to return the numerator of the aspect ratio
`denominator` : | A location to resturn the denominator of the aspect ratio

### ogmrip_encoding_get_auto_subp ()

    gboolean            ogmrip_encoding_get_auto_subp       (OGMRipEncoding *encoding);

Gets whether to automatically hardcode the first subtitle stream having the same language as the first audio track.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to hardcode a subtitle track, `FALSE` otherwise

### ogmrip_encoding_get_bitrate ()

    gint                ogmrip_encoding_get_bitrate         (OGMRipEncoding *encoding);

Gets the average bitrate in bits/seconds for the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The bitrate, or -1

### ogmrip_encoding_get_bits_per_pixel ()

    gdouble             ogmrip_encoding_get_bits_per_pixel  (OGMRipEncoding *encoding);

Gets the number of bits per pixel of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The number of bits per pixel, or -1

### ogmrip_encoding_get_can_crop ()

    gboolean            ogmrip_encoding_get_can_crop        (OGMRipEncoding *encoding);

Gets whether the video should be cropped.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` if the video can be cropped, `FALSE` otherwise

### ogmrip_encoding_get_can_scale ()

    gboolean            ogmrip_encoding_get_can_scale       (OGMRipEncoding *encoding);

Gets whether the video should be scaled.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` if the video can be scaled, `FALSE` otherwise

### ogmrip_encoding_get_cartoon ()

    gboolean            ogmrip_encoding_get_cartoon         (OGMRipEncoding *encoding);

Gets whether to optimize the encoding for cartoons.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` for cartoon mode, `FALSE` otherwise

### ogmrip_encoding_get_chapter_label ()

    const gchar *       ogmrip_encoding_get_chapter_label   (OGMRipEncoding *encoding,
                                                             guint nr);

Gets the name of the chapter.

`encoding` : | An OGMRipEncoding
`nr` : | A chapter number, counting from 0
Returns : | The name of the chapter, or NULL

### ogmrip_encoding_get_chapters ()

    void                ogmrip_encoding_get_chapters        (OGMRipEncoding *encoding,
                                                             guint *start_chap,
                                                             gint *end_chap);

Gets the first and last chapters of the encoding.

`encoding` : | An OGMRipEncoding
`start_chap` : | A location to return the first chapter
`end_chap` : | A location to return the last chapter

### ogmrip_encoding_get_chapters_language ()

    gint                ogmrip_encoding_get_chapters_language
                                                            (OGMRipEncoding *encoding);

Gets the language of the name of the chapters.

`encoding` : | An OGMRipEncoding
Returns : | A language code, or -1

### ogmrip_encoding_get_copy_dvd ()

    gboolean            ogmrip_encoding_get_copy_dvd        (OGMRipEncoding *encoding);

Gets whether the title should be copied on the hard drive.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` if the title will be copied, `FALSE` otherwise

### ogmrip_encoding_get_crop ()

    gint                ogmrip_encoding_get_crop            (OGMRipEncoding *encoding,
                                                             guint *x,
                                                             guint *y,
                                                             guint *w,
                                                             guint *h);

Gets the cropping parameters of the encoding.

`encoding` : | An OGMRipEncoding:
`x` : | A location to return the cropped horizontal position
`y` : | A location to return the cropped vertical position
`w` : | A location to return the cropped width
`h` : | A location to return the cropped height
Returns : | An OGMRipOptionsType, or -1

### ogmrip_encoding_get_deblock ()

    gboolean            ogmrip_encoding_get_deblock         (OGMRipEncoding *encoding);

Gets whether a deblocking filter should be applied.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to deblock, `FALSE` otherwise

### ogmrip_encoding_get_deinterlacer ()

    gint                ogmrip_encoding_get_deinterlacer    (OGMRipEncoding *encoding);

Gets the deinterlacer.

`encoding` : | An OGMRipEncoding
Returns : | An OGMRipDeintType, or -1

### ogmrip_encoding_get_denoise ()

    gboolean            ogmrip_encoding_get_denoise         (OGMRipEncoding *encoding);

Gets whether a noise reducing filter should be applied.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to denoise, `FALSE` otherwise

### ogmrip_encoding_get_dering ()

    gboolean            ogmrip_encoding_get_dering          (OGMRipEncoding *encoding);

Gets whether a deringing filter should be applied.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to dering, `FALSE` otherwise

### ogmrip_encoding_get_ensure_sync ()

    gboolean            ogmrip_encoding_get_ensure_sync     (OGMRipEncoding *encoding);

Gets whether to ensure audio/video synchronization.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to ensure A/V sync, `FALSE` otherwise

### ogmrip_encoding_get_filename ()

    const gchar *       ogmrip_encoding_get_filename        (OGMRipEncoding *encoding);

Gets the output file name.

`encoding` : | An OGMRipEncoding
Returns : | The output filename, or NULL

### ogmrip_encoding_get_flags ()

    guint32             ogmrip_encoding_get_flags           (OGMRipEncoding *encoding);

Gets the flags of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The flags, or 0

### ogmrip_encoding_get_fourcc ()

    const gchar *       ogmrip_encoding_get_fourcc          (OGMRipEncoding *encoding);

Gets the FOUR character code for the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The FourCC, or NULL

### ogmrip_encoding_get_id ()

    const gchar *       ogmrip_encoding_get_id              (OGMRipEncoding *encoding);

Gets the id of the DVD source.

`encoding` : | An OGMRipEncoding
Returns : | The id, or NULL

### ogmrip_encoding_get_keep_tmp_files ()

    gboolean            ogmrip_encoding_get_keep_tmp_files  (OGMRipEncoding *encoding);

Gets whether to keep the temporary files.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to keep the temporary files, `FALSE` otherwise

### ogmrip_encoding_get_label ()

    const gchar *       ogmrip_encoding_get_label           (OGMRipEncoding *encoding);

Gets the name of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The name of the encoding, or NULL

### ogmrip_encoding_get_logfile ()

    const gchar *       ogmrip_encoding_get_logfile         (OGMRipEncoding *encoding);

Gets the log filename.

`encoding` : | An OGMRipEncoding
Returns : | The log filename, or NULL

### ogmrip_encoding_get_max_size ()

    void                ogmrip_encoding_get_max_size        (OGMRipEncoding *encoding,
                                                             guint *width,
                                                             guint *height,
                                                             gboolean *expand);

Gets the maximum size of the image and whether the image should be expanded to this size.

`encoding` : | An OGMRipEncoding
`width` : | A location to return the max width
`height` : | A location to return the max height
`expand` : | A location to return whether to expand the image

### ogmrip_encoding_get_method ()

    gint                ogmrip_encoding_get_method          (OGMRipEncoding *encoding);

Gets the method of encoding.

`encoding` : | An OGMRipEncoding
Returns : | An OGMRipEncodingMethod, or -1

### ogmrip_encoding_get_min_size ()

    void                ogmrip_encoding_get_min_size        (OGMRipEncoding *encoding,
                                                             guint *width,
                                                             guint *height);

Gets the minimum size of the image.

`encoding` : | An OGMRipEncoding
`width` : | A location to return the min width
`height` : | A location to return the min height

### ogmrip_encoding_get_passes ()

    gint                ogmrip_encoding_get_passes          (OGMRipEncoding *encoding);

Gets the number of passes of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | the number of passes, or -1

### ogmrip_encoding_get_preset ()

    gint                ogmrip_encoding_get_preset          (OGMRipEncoding *encoding);

Gets the preset of the video options.

`encoding` : | An OGMRipEncoding
Returns : | An OGMRipVideoPreset, or -1

### ogmrip_encoding_get_profile ()

    const gchar *       ogmrip_encoding_get_profile         (OGMRipEncoding *encoding);

Gets the profile' section of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The profile' section, or NULL

### ogmrip_encoding_get_qpel ()

    gboolean            ogmrip_encoding_get_qpel            (OGMRipEncoding *encoding);

Gets whether to use quarter pel motion compensation.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to use qpel, `FALSE` otherwise

### ogmrip_encoding_get_quantizer ()

    gdouble             ogmrip_encoding_get_quantizer       (OGMRipEncoding *encoding);

Gets the quantizer of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The quantizer, or -1

### ogmrip_encoding_get_relative ()

    gboolean            ogmrip_encoding_get_relative        (OGMRipEncoding *encoding);

Gets whether the bitrate is computed relatively to the full length of the title, or to the length of the selected chapters only.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` for relative, `FALSE` otherwise

### ogmrip_encoding_get_scale ()

    gint                ogmrip_encoding_get_scale           (OGMRipEncoding *encoding,
                                                             guint *w,
                                                             guint *h);

Gets the scaling parameters of the encoding.

`encoding` : | An OGMRipEncoding
`w` : | A location to return the scaled width
`h` : | A location to resturn the scaled height
Returns : | An OGMRipOptionsType, or -1

### ogmrip_encoding_get_scaler ()

    gint                ogmrip_encoding_get_scaler          (OGMRipEncoding *encoding);

Gets the software scaler of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | An OGMRipScalerType, or -1

### ogmrip_encoding_get_target_number ()

    gint                ogmrip_encoding_get_target_number   (OGMRipEncoding *encoding);

Gets the number of targets of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The number of targets, or -1

### ogmrip_encoding_get_target_size ()

    gint                ogmrip_encoding_get_target_size     (OGMRipEncoding *encoding);

Gets the size of each target of the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The size of the targets, or -1

### ogmrip_encoding_get_test ()

    gboolean            ogmrip_encoding_get_test            (OGMRipEncoding *encoding);

Gets whether to automatically perform a compressibility test.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to perform a compressibility test, `FALSE` otherwise

### ogmrip_encoding_get_threads ()

    gint                ogmrip_encoding_get_threads         (OGMRipEncoding *encoding);

Gets the number of threads to use for the encoding.

`encoding` : | An OGMRipEncoding
Returns : | The number of thread, or -1

### ogmrip_encoding_get_title ()

    OGMDvdTitle *       ogmrip_encoding_get_title           (OGMRipEncoding *encoding);

Gets the DVD title.

`encoding` : | An OGMRipEncoding
Returns : | An OGMDvdTitle, or NULL

### ogmrip_encoding_get_trellis ()

    gboolean            ogmrip_encoding_get_trellis         (OGMRipEncoding *encoding);

Gets whether to enable trellis searched quantization.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to enable trellis, `FALSE` otherwise

### ogmrip_encoding_get_turbo ()

    gboolean            ogmrip_encoding_get_turbo           (OGMRipEncoding *encoding);

Gets whether to speed up first pass of multi-pass encodings.

`encoding` : | An OGMRipEncoding
Returns : | `TRUE` to enable turbo, `FALSE`, otherwise

### ogmrip_encoding_set_angle ()

    void                ogmrip_encoding_set_angle           (OGMRipEncoding *encoding,
                                                             guint angle);

Sets the angle to encode.

`encoding` : | An OGMRipEncoding
`angle` : | An angle

### ogmrip_encoding_set_aspect_ratio ()

    void                ogmrip_encoding_set_aspect_ratio    (OGMRipEncoding *encoding,
                                                             guint numerator,
                                                             guint denominator);

Sets the aspect ratio for the encoding.

`encoding` : | An OGMRipEncoding
`numerator` : | The numerator of the aspect ratio
`denominator` : | The denominator of the aspect ratio

### ogmrip_encoding_set_auto_subp ()

    void                ogmrip_encoding_set_auto_subp       (OGMRipEncoding *encoding,
                                                             gboolean auto_subp);

Sets whether to automatically hardcode the first subtitle stream having the same language as the first audio track.

`encoding` : | An OGMRipEncoding
`auto_subp` : | `TRUE` to hardcode a subtitle track

### ogmrip_encoding_set_bitrate ()

    void                ogmrip_encoding_set_bitrate         (OGMRipEncoding *encoding,
                                                             guint bitrate);

Sets the average bitrate in bits/second for the encoding. The bitrate will be used only if the method of encoding is `OGMRIP_ENCODING_BITRATE`.

`encoding` : | An OGMRipEncoding
`bitrate` : | The bitrate

### ogmrip_encoding_set_bits_per_pixel ()

    void                ogmrip_encoding_set_bits_per_pixel  (OGMRipEncoding *encoding,
                                                             gdouble bpp);

Sets the number of bits per pixel for the encoding.

`encoding` : | An OGMRipEncoding
`bpp` : | The number of bits per pixel

### ogmrip_encoding_set_can_crop ()

    void                ogmrip_encoding_set_can_crop        (OGMRipEncoding *encoding,
                                                             gboolean can_crop);

Sets whether the video should be cropped.

`encoding` : | An OGMRipEncoding
`can_crop` : | `TRUE` to crop the video

### ogmrip_encoding_set_can_scale ()

    void                ogmrip_encoding_set_can_scale       (OGMRipEncoding *encoding,
                                                             gboolean can_scale);

Sets whether the video should be scaled.

`encoding` : | An OGMRipEncoding
`can_scale` : | `TRUE` to scale the video

### ogmrip_encoding_set_cartoon ()

    void                ogmrip_encoding_set_cartoon         (OGMRipEncoding *encoding,
                                                             gboolean cartoon);

Sets whether to optimiza the encoding for cartoons.

`encoding` : | An OGMRipEncoding
`cartoon` : | `TRUE` for cartoon mode

### ogmrip_encoding_set_chapter_label ()

    void                ogmrip_encoding_set_chapter_label   (OGMRipEncoding *encoding,
                                                             guint nr,
                                                             const gchar *label);

Sets the name of the chapter.

`encoding` : | An OGMRipEncoding
`nr` : | A chapter number, counting from 0
`label` : | The name of the encoding

### ogmrip_encoding_set_chapters ()

    void                ogmrip_encoding_set_chapters        (OGMRipEncoding *encoding,
                                                             guint start_chap,
                                                             gint end_chap);

Sets the first and last chapters of the encoding.

`encoding` : | An OGMRipEncoding
`start_chap` : | The first chapter
`end_chap` : | The last chapter

### ogmrip_encoding_set_chapters_language ()

    void                ogmrip_encoding_set_chapters_language
                                                            (OGMRipEncoding *encoding,
                                                             guint language);

Sets the language of the name of the chapters.

`encoding` : | An OGMRipEncoding
`language` : | A language code

### ogmrip_encoding_set_copy_dvd ()

    void                ogmrip_encoding_set_copy_dvd        (OGMRipEncoding *encoding,
                                                             gboolean copy_dvd);

Sets whether to copy the title on the hard drive.

`encoding` : | An OGMRipEncoding
`copy_dvd` : | Whether to copy the title

### ogmrip_encoding_set_crop ()

    void                ogmrip_encoding_set_crop            (OGMRipEncoding *encoding,
                                                             OGMRipOptionsType type,
                                                             guint x,
                                                             guint y,
                                                             guint w,
                                                             guint h);

Sets the cropping parameters for the encoding.

`encoding` : | An OGMRipEncoding
`type` : | An OGMRipOptionsType
`x` : | The cropped horizontal position
`y` : | The cropped vertical position
`w` : | The cropped width
`h` : | The cropped height

### ogmrip_encoding_set_deblock ()

    void                ogmrip_encoding_set_deblock         (OGMRipEncoding *encoding,
                                                             gboolean deblock);

Sets whether a deblocking filter should be applied.

`encoding` : | An OGMRipEncoding
`deblock` : | `TRUE` to deblock

### ogmrip_encoding_set_deinterlacer ()

    void                ogmrip_encoding_set_deinterlacer    (OGMRipEncoding *encoding,
                                                             OGMRipDeintType deint);

Sets the deinterlacer.

`encoding` : | An OGMRipEncoding
`deint` : | An OGMRipDeintType

### ogmrip_encoding_set_denoise ()

    void                ogmrip_encoding_set_denoise         (OGMRipEncoding *encoding,
                                                             gboolean denoise);

Sets whether a noise reducing filter should be applied.

`encoding` : | An OGMRipEncoding
`denoise` : | `TRUE` to denoise

### ogmrip_encoding_set_dering ()

    void                ogmrip_encoding_set_dering          (OGMRipEncoding *encoding,
                                                             gboolean dering);

Sets whether a deringing filter should be applied.

`encoding` : | An OGMRipEncoding
`dering` : | `TRUE` to dering

### ogmrip_encoding_set_ensure_sync ()

    void                ogmrip_encoding_set_ensure_sync     (OGMRipEncoding *encoding,
                                                             gboolean ensure_sync);

Sets whether to ensure audio/video synchronization.

`encoding` : | An OGMRipEncoding
`ensure_sync` : | Whether to ensure A/V sync

### ogmrip_encoding_set_filename ()

    void                ogmrip_encoding_set_filename        (OGMRipEncoding *encoding,
                                                             const gchar *filename);

Sets the output filename.

`encoding` : | An OGMRipEncoding
`filename` : | A filename

### ogmrip_encoding_set_fourcc ()

    void                ogmrip_encoding_set_fourcc          (OGMRipEncoding *encoding,
                                                             const gchar *fourcc);

Sets the FOUR character code for the encoding.

`encoding` : | An OGMRipEncoding
`fourcc` : | A FourCC

### ogmrip_encoding_set_keep_tmp_files ()

    void                ogmrip_encoding_set_keep_tmp_files  (OGMRipEncoding *encoding,
                                                             gboolean keep_tmp_files);

Sets whether to keep the temporary files.

`encoding` : | An OGMRipEncoding
`keep_tmp_files` : | Whether to keep the temporary files

### ogmrip_encoding_set_label ()

    void                ogmrip_encoding_set_label           (OGMRipEncoding *encoding,
                                                             const gchar *label);

Sets the name of the encoding.

`encoding` : | An OGMRipEncoding
`label` : | The name of the encoding

### ogmrip_encoding_set_max_size ()

    void                ogmrip_encoding_set_max_size        (OGMRipEncoding *encoding,
                                                             guint width,
                                                             guint height,
                                                             gboolean expand);

Sets the maximum size of the image and whether the image should be expanded to this size.

`encoding` : | An OGMRipEncoding
`width` : | The max width
`height` : | The max height
`expand` : | `TRUE` to expand the image

### ogmrip_encoding_set_method ()

    void                ogmrip_encoding_set_method          (OGMRipEncoding *encoding,
                                                             OGMRipEncodingMethod method);

Sets the method of encoding.

`encoding` : | An OGMRipEncoding
`method` : | An OGMRipEncodingMethod

### ogmrip_encoding_set_min_size ()

    void                ogmrip_encoding_set_min_size        (OGMRipEncoding *encoding,
                                                             guint width,
                                                             guint height);

Sets the minimum size of the image.

`encoding` : | An OGMRipEncoding
`width` : | The min width
`height` : | The min height

### ogmrip_encoding_set_nth_audio_options ()

    gboolean            ogmrip_encoding_set_nth_audio_options
                                                            (OGMRipEncoding *encoding,
                                                             guint n,
                                                             OGMRipAudioOptions *options,
                                                             GError **error);

Sets the options of the audio stream at the given position.

`encoding` : | An OGMRipEncoding
`n` : | The position of the stream, counting from 0
`options` : | An OGMRipAudioOptions
`error` : | Return location for error
Returns : | `TRUE` on success, `FALSE` if there is no audio stream at the given position

### ogmrip_encoding_set_nth_subp_options ()

    gboolean            ogmrip_encoding_set_nth_subp_options
                                                            (OGMRipEncoding *encoding,
                                                             guint n,
                                                             OGMRipSubpOptions *options,
                                                             GError **error);

Sets the options of the subp stream at the given position.

`encoding` : | An OGMRipEncoding
`n` : | The position of the stream, counting from 0
`options` : | An OGMRipSubpOptions
`error` : | Return location for error
Returns : | `TRUE` on success, `FALSE` if there is no subp stream at the given position

### ogmrip_encoding_set_passes ()

    void                ogmrip_encoding_set_passes          (OGMRipEncoding *encoding,
                                                             guint passes);

Sets the number of passes of the encoding.

`encoding` : | An OGMRipEncoding
`passes` : | The number of passes

### ogmrip_encoding_set_preset ()

    void                ogmrip_encoding_set_preset          (OGMRipEncoding *encoding,
                                                             OGMRipVideoPreset preset);

Sets the preset of the video options.

`encoding` : | An OGMRipEncoding
`preset` : | An OGMRipVideoPreset

### ogmrip_encoding_set_profile ()

    void                ogmrip_encoding_set_profile         (OGMRipEncoding *encoding,
                                                             const gchar *profile);

Sets the profile' section of the profile

`encoding` : | An OGMRipEncoding
`profile` : | A profile' section

### ogmrip_encoding_set_qpel ()

    void                ogmrip_encoding_set_qpel            (OGMRipEncoding *encoding,
                                                             gboolean qpel);

Sets whether to use quarter pel motion compensation.

`encoding` : | An OGMRipEncoding
`qpel` : | `TRUE` to use qpel

### ogmrip_encoding_set_quantizer ()

    void                ogmrip_encoding_set_quantizer       (OGMRipEncoding *encoding,
                                                             gdouble quantizer);

Sets the quantizer of the encoding. The quantizer will be used only if the method of encoding is `OGMRIP_ENCODING_QUANTIZER`.

`encoding` : | An OGMRipEncoding
`quantizer` : | The quantizer

### ogmrip_encoding_set_relative ()

    void                ogmrip_encoding_set_relative        (OGMRipEncoding *encoding,
                                                             gboolean relative);

Sets whether the bitrate is computed relatively to the full length of the title, or to the length of the selected chapters only.

`encoding` : | An OGMRipEncoding
`relative` : | `TRUE` for relative

### ogmrip_encoding_set_scale ()

    void                ogmrip_encoding_set_scale           (OGMRipEncoding *encoding,
                                                             OGMRipOptionsType type,
                                                             guint w,
                                                             guint h);

Sets the scaling parameters for the encoding.

`encoding` : | An OGMRipEncoding
`type` : | An OGMRipOptionsType
`w` : | The scaled width
`h` : | The scaled height

### ogmrip_encoding_set_scaler ()

    void                ogmrip_encoding_set_scaler          (OGMRipEncoding *encoding,
                                                             OGMRipScalerType scaler);

Sets the software scaler for the encoding.

`encoding` : | An OGMRipEncoding
`scaler` : | An OGMRipScalerType

### ogmrip_encoding_set_target_number ()

    void                ogmrip_encoding_set_target_number   (OGMRipEncoding *encoding,
                                                             guint target_number);

Sets the number of targets of the encoding. This value will be used only if the method of encoding is `OGMRIP_ENCODING_SIZE`.

`encoding` : | An OGMRipEncoding
`target_number` : | The number of targets

### ogmrip_encoding_set_target_size ()

    void                ogmrip_encoding_set_target_size     (OGMRipEncoding *encoding,
                                                             guint target_size);

Sets the size of each target of an encoding. This value will be used only if the method of encoding is `OGMRIP_ENCODING_SIZE`..

`encoding` : | An OGMRipEncoding
`target_size` : | The size of the targets

### ogmrip_encoding_set_test ()

    void                ogmrip_encoding_set_test            (OGMRipEncoding *encoding,
                                                             gboolean test);

Sets whether to automatically perform a compressibility test.

`encoding` : | An OGMRipEncoding
`test` : | `TRUE` to perform a compressibility test

### ogmrip_encoding_set_threads ()

    void                ogmrip_encoding_set_threads         (OGMRipEncoding *encoding,
                                                             guint threads);

Sets the number of threads to use for the encoding.

`encoding` : | An OGMRipEncoding
`threads` : | The number of threads

### ogmrip_encoding_set_trellis ()

    void                ogmrip_encoding_set_trellis         (OGMRipEncoding *encoding,
                                                             gboolean trellis);

Sets whether to enable trellis searched quantization.

`encoding` : | An OGMRipEncoding
`trellis` : | `TRUE` to enable trellis

### ogmrip_encoding_set_turbo ()

    void                ogmrip_encoding_set_turbo           (OGMRipEncoding *encoding,
                                                             gboolean turbo);

Sets whether to speed up first pass of multi-pass encodings.

`encoding` : | An OGMRipEncoding
`turbo` : | `TRUE` to enable turbo

## Property Details

### The `"aspect-denom"` property

      "aspect-denom"             guint                 : Read / Write

Set the aspect denominator.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"aspect-num"` property

      "aspect-num"               guint                 : Read / Write

Set the aspect numerator.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"auto-subp"` property

      "auto-subp"                gboolean              : Read / Write

Whether to automatically hardcode subtitles.

Default value: TRUE

### 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 `"can-crop"` property

      "can-crop"                 gboolean              : Read / Write

Whether to crop the input.

Default value: TRUE

### The `"can-scale"` property

      "can-scale"                gboolean              : Read / Write

Whether to scale the input.

Default value: TRUE

### The `"cartoon"` property

      "cartoon"                  gboolean              : Read / Write

Whether to optimize for cartoons.

Default value: FALSE

### The `"chapters-lang"` property

      "chapters-lang"            guint                 : Read / Write

Set the language of the chapter's label.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"container-type"` property

      "container-type"           GType*                : Read / Write

Set the type of the container.

Allowed values: OGMRipContainer

### The `"copy-dvd"` property

      "copy-dvd"                 gboolean              : Read / Write

Whether to copy the DVD on the hard drive.

Default value: TRUE

### The `"crop-height"` property

      "crop-height"              guint                 : Read / Write

Set the crop height.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"crop-type"` property

      "crop-type"                guint                 : Read / Write

Set the crop type.

Allowed values: <= 2

Default value: 1

### The `"crop-width"` property

      "crop-width"               guint                 : Read / Write

Set the crop width.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"crop-x"` property

      "crop-x"                   guint                 : Read / Write

Set the crop horizontal position.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"crop-y"` property

      "crop-y"                   guint                 : Read / Write

Set the crop vertical position.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"deblock"` property

      "deblock"                  gboolean              : Read / Write

Whether to deblock the input.

Default value: FALSE

### The `"deinterlacer"` property

      "deinterlacer"             guint                 : Read / Write

Set the deinterlacer.

Allowed values: <= 8

Default value: 0

### The `"denoise"` property

      "denoise"                  gboolean              : Read / Write

Whether to denoise the input.

Default value: TRUE

### The `"dering"` property

      "dering"                   gboolean              : Read / Write

Whether to dering the input.

Default value: FALSE

### The `"end-chapter"` property

      "end-chapter"              gint                  : Read / Write

Set end chapter.

Allowed values: >= -1

Default value: -1

### The `"ensure-sync"` property

      "ensure-sync"              gboolean              : Read / Write

Whether to ensure A/V sync.

Default value: TRUE

### The `"expand"` property

      "expand"                   gboolean              : Read / Write

Whether to expand to max size.

Default value: TRUE

### The `"filename"` property

      "filename"                 gchar*                : Read / Write

Set the filename.

Default value: NULL

### The `"fourcc"` property

      "fourcc"                   gchar*                : Read / Write

Set the fourCC.

Default value: NULL

### The `"keep-tmp-files"` property

      "keep-tmp-files"           gboolean              : Read / Write

Whether to keep temporary files.

Default value: FALSE

### The `"label"` property

      "label"                    gchar*                : Read / Write

Set the label.

Default value: NULL

### The `"max-height"` property

      "max-height"               guint                 : Read / Write

Set max height.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"max-width"` property

      "max-width"                guint                 : Read / Write

Set max width.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"method"` property

      "method"                   guint                 : Read / Write

Set method.

Allowed values: <= 2

Default value: 0

### The `"min-height"` property

      "min-height"               guint                 : Read / Write

Set min height.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"min-width"` property

      "min-width"                guint                 : Read / Write

Set min width.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"passes"` property

      "passes"                   guint                 : Read / Write

Set the number of passes.

Allowed values: >= 1

Default value: 1

### The `"preset"` property

      "preset"                   guint                 : Read / Write

Set the preset.

Allowed values: <= 3

Default value: 0

### The `"profile"` property

      "profile"                  gchar*                : Read / Write

Set the profile.

Default value: NULL

### The `"qpel"` property

      "qpel"                     gboolean              : Read / Write

Whether to use quarter pel motion compensation.

Default value: FALSE

### The `"quantizer"` property

      "quantizer"                gdouble               : Read / Write

Set quantizer.

Allowed values: [-1,31]

Default value: -1

### The `"relative"` property

      "relative"                 gboolean              : Read / Write

Whether to compute the bitrate relatively to the length of the title.

Default value: FALSE

### The `"scale-height"` property

      "scale-height"             guint                 : Read / Write

Set the scale height.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"scale-type"` property

      "scale-type"               guint                 : Read / Write

Set the scale type.

Allowed values: <= 2

Default value: 1

### The `"scale-width"` property

      "scale-width"              guint                 : Read / Write

Set the scale width.

Allowed values: <= G_MAXLONG

Default value: 0

### The `"scaler"` property

      "scaler"                   guint                 : Read / Write

Set the software scaler.

Allowed values: <= 10

Default value: 7

### The `"start-chapter"` property

      "start-chapter"            gint                  : Read / Write

Set start chapter.

Allowed values: >= 0

Default value: 0

### The `"target-number"` property

      "target-number"            guint                 : Read / Write

Set target number.

Default value: 1

### The `"target-size"` property

      "target-size"              guint                 : Read / Write

Set target size.

Default value: 0

### The `"test"` property

      "test"                     gboolean              : Read / Write

Whether to perform a compressibility test.

Default value: TRUE

### The `"threads"` property

      "threads"                  guint                 : Read / Write

Set the number of threads.

Default value: 0

### The `"trellis"` property

      "trellis"                  gboolean              : Read / Write

Whether to use trellis searched quantization.

Default value: TRUE

### The `"turbo"` property

      "turbo"                    gboolean              : Read / Write

Whether to use turbo on first pass.

Default value: TRUE

### The `"video-codec-type"` property

      "video-codec-type"         GType*                : Read / Write

Set the type of the video codec.

Allowed values: OGMRipVideoCodec

## Signal Details

### The `"complete"` signal

    void                user_function                      (OGMRipEncoding *encoding,
                                                            gint            result,
                                                            gpointer        user_data)      : No Hooks

Emitted each time an encoding completes.

`encoding` : | An OGMRipEncoding
`result` : | An OGMJobResultType
`user_data` : | user data set when the signal handler was connected.

### The `"run"` signal

    void                user_function                      (OGMRipEncoding *encoding,
                                                            gpointer        user_data)      : No Hooks

Emitted each time an encoding starts.

`encoding` : | An OGMRipEncoding
`user_data` : | user data set when the signal handler was connected.

### The `"task"` signal

    void                user_function                      (OGMRipEncoding *encoding,
                                                            gpointer        task,
                                                            gpointer        user_data)      : No Hooks

Emitted each time a task of `encoding` starts, completeѕ, progresses, is suspended, or is resumed.

`encoding` : | An OGMRipEncoding
`task` : | An OGMRipEncodingTask
`user_data` : | user data set when the signal handler was connected.