OGMRipVideo

OGMRipVideo — Base class for video codecs

Synopsis


#include <ogmrip-video.h>


                    OGMRipVideo;
gboolean            ogmrip_video_autocrop               (OGMRipVideo *video,
                                                         guint nframes);
void                ogmrip_video_autoscale              (OGMRipVideo *video);
void                ogmrip_video_autobitrate            (OGMRipVideo *video,
                                                         guint64 nonvideo_size,
                                                         guint64 overhead_size,
                                                         guint64 total_size);
gboolean            ogmrip_video_get_4mv                (OGMRipVideo *video);
void                ogmrip_video_set_4mv                (OGMRipVideo *video,
                                                         gboolean v4mv);
gint                ogmrip_video_get_angle              (OGMRipVideo *video);
void                ogmrip_video_set_angle              (OGMRipVideo *video,
                                                         guint angle);
gint                ogmrip_video_get_bitrate            (OGMRipVideo *video);
void                ogmrip_video_set_bitrate            (OGMRipVideo *video,
                                                         guint bitrate);
gdouble             ogmrip_video_get_bits_per_pixel     (OGMRipVideo *video);
void                ogmrip_video_set_bits_per_pixel     (OGMRipVideo *video,
                                                         gdouble bpp);
gboolean            ogmrip_video_get_cartoon            (OGMRipVideo *video);
void                ogmrip_video_set_cartoon            (OGMRipVideo *video,
                                                         gboolean cartoon);
gboolean            ogmrip_video_get_crop_size          (OGMRipVideo *video,
                                                         guint *x,
                                                         guint *y,
                                                         guint *width,
                                                         guint *height);
void                ogmrip_video_set_crop_size          (OGMRipVideo *video,
                                                         guint x,
                                                         guint y,
                                                         guint width,
                                                         guint height);
gboolean            ogmrip_video_get_deblock            (OGMRipVideo *video);
void                ogmrip_video_set_deblock            (OGMRipVideo *video,
                                                         gboolean deblock);
gint                ogmrip_video_get_deinterlacer       (OGMRipVideo *video);
void                ogmrip_video_set_deinterlacer       (OGMRipVideo *video,
                                                         OGMRipDeintType deint);
gboolean            ogmrip_video_get_denoise            (OGMRipVideo *video);
void                ogmrip_video_set_denoise            (OGMRipVideo *video,
                                                         gboolean denoise);
gboolean            ogmrip_video_get_dering             (OGMRipVideo *video);
void                ogmrip_video_set_dering             (OGMRipVideo *video,
                                                         gboolean dering);
OGMDvdAudioStream*  ogmrip_video_get_ensure_sync        (OGMRipVideo *video);
void                ogmrip_video_set_ensure_sync        (OGMRipVideo *video,
                                                         OGMDvdAudioStream *stream);
gboolean            ogmrip_video_get_grayscale          (OGMRipVideo *video);
void                ogmrip_video_set_grayscale          (OGMRipVideo *video,
                                                         gboolean grayscale);
gchar*              ogmrip_video_get_log                (OGMRipVideo *video);
void                ogmrip_video_set_log                (OGMRipVideo *video,
                                                         const gchar *log);
gint                ogmrip_video_get_max_b_frames       (OGMRipVideo *video);
void                ogmrip_video_set_max_b_frames       (OGMRipVideo *video,
                                                         guint max_b_frames);
gint                ogmrip_video_get_pass               (OGMRipVideo *video);
void                ogmrip_video_set_pass               (OGMRipVideo *video,
                                                         guint pass);
gboolean            ogmrip_video_get_pullup             (OGMRipVideo *video);
void                ogmrip_video_set_pullup             (OGMRipVideo *video,
                                                         gboolean pullup);
gboolean            ogmrip_video_get_qpel               (OGMRipVideo *video);
void                ogmrip_video_set_qpel               (OGMRipVideo *video,
                                                         gboolean qpel);
gint                ogmrip_video_get_quality            (OGMRipVideo *video);
void                ogmrip_video_set_quality            (OGMRipVideo *video,
                                                         OGMRipQualityType quality);
gdouble             ogmrip_video_get_quantizer          (OGMRipVideo *video);
void                ogmrip_video_set_quantizer          (OGMRipVideo *video,
                                                         gdouble quantizer);
void                ogmrip_video_get_raw_size           (OGMRipVideo *video,
                                                         guint *width,
                                                         guint *height);
gboolean            ogmrip_video_get_scale_size         (OGMRipVideo *video,
                                                         guint *width,
                                                         guint *height);
void                ogmrip_video_set_scale_size         (OGMRipVideo *video,
                                                         guint width,
                                                         guint height);
gint                ogmrip_video_get_scaler             (OGMRipVideo *video);
void                ogmrip_video_set_scaler             (OGMRipVideo *video,
                                                         OGMRipScalerType scaler);
gint                ogmrip_video_get_threads            (OGMRipVideo *video);
void                ogmrip_video_set_threads            (OGMRipVideo *video,
                                                         guint threads);
gboolean            ogmrip_video_get_trellis            (OGMRipVideo *video);
void                ogmrip_video_set_trellis            (OGMRipVideo *video,
                                                         gboolean trellis);
gboolean            ogmrip_video_get_turbo              (OGMRipVideo *video);
void                ogmrip_video_set_turbo              (OGMRipVideo *video,
                                                         gboolean turbo);

Object Hierarchy


  GObject
   +----OGMJobSpawn
         +----OGMJobContainer
               +----OGMJobBin
                     +----OGMRipCodec
                           +----OGMRipVideo

Description

Details

OGMRipVideo

typedef struct _OGMRipVideo OGMRipVideo;


ogmrip_video_autocrop ()

gboolean            ogmrip_video_autocrop               (OGMRipVideo *video,
                                                         guint nframes);

Autodetects the cropping parameters.

video : an OGMRipVideo
nframes : the number of frames
Returns : FALSE, on error or cancel

ogmrip_video_autoscale ()

void                ogmrip_video_autoscale              (OGMRipVideo *video);

Autodetects the scaling parameters.

video : an OGMRipVideo

ogmrip_video_autobitrate ()

void                ogmrip_video_autobitrate            (OGMRipVideo *video,
                                                         guint64 nonvideo_size,
                                                         guint64 overhead_size,
                                                         guint64 total_size);

Autodetects the video bitrate.

video : an OGMRipVideo
nonvideo_size : the size of the non video streams
overhead_size : the size of the overhead
total_size : the total targetted size

ogmrip_video_get_4mv ()

gboolean            ogmrip_video_get_4mv                (OGMRipVideo *video);

Gets whether 4 motion vectors per macroblock are allowed.

video : an OGMRipVideo
Returns : TRUE if 4 motion vectors per macroblock are allowed

ogmrip_video_set_4mv ()

void                ogmrip_video_set_4mv                (OGMRipVideo *video,
                                                         gboolean v4mv);

Sets whether to allow 4 motion vectors per macroblock.

video : an OGMRipVideo
v4mv : TRUE to allow 4 motion vectors per macroblock

ogmrip_video_get_angle ()

gint                ogmrip_video_get_angle              (OGMRipVideo *video);

Gets the current angle.

video : an OGMRipVideo
Returns : the angle, or -1

ogmrip_video_set_angle ()

void                ogmrip_video_set_angle              (OGMRipVideo *video,
                                                         guint angle);

Sets the angle to encode.

video : an OGMRipVideo
angle : the angle

ogmrip_video_get_bitrate ()

gint                ogmrip_video_get_bitrate            (OGMRipVideo *video);

Gets the video bitrate in bits/second.

video : an OGMRipVideo
Returns : the video bitrate, or -1

ogmrip_video_set_bitrate ()

void                ogmrip_video_set_bitrate            (OGMRipVideo *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 OGMRipVideo
bitrate : the video bitrate

ogmrip_video_get_bits_per_pixel ()

gdouble             ogmrip_video_get_bits_per_pixel     (OGMRipVideo *video);

Gets the number of bits per pixel.

video : an OGMRipVideo
Returns : the number of bits per pixel, or -1

ogmrip_video_set_bits_per_pixel ()

void                ogmrip_video_set_bits_per_pixel     (OGMRipVideo *video,
                                                         gdouble bpp);

Sets the number of bits per pixel to be used.

video : an OGMRipVideo
bpp : the number of bits per pixel

ogmrip_video_get_cartoon ()

gboolean            ogmrip_video_get_cartoon            (OGMRipVideo *video);

Gets whether the movie is a cartoon.

video : an OGMRipVideo
Returns : TRUE if movie is a cartoon

ogmrip_video_set_cartoon ()

void                ogmrip_video_set_cartoon            (OGMRipVideo *video,
                                                         gboolean cartoon);

Sets whether the movie is a cartoon.

video : an OGMRipVideo
cartoon : TRUE if movie is a cartoon

ogmrip_video_get_crop_size ()

gboolean            ogmrip_video_get_crop_size          (OGMRipVideo *video,
                                                         guint *x,
                                                         guint *y,
                                                         guint *width,
                                                         guint *height);

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

video : an OGMRipVideo
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_set_crop_size ()

void                ogmrip_video_set_crop_size          (OGMRipVideo *video,
                                                         guint x,
                                                         guint y,
                                                         guint width,
                                                         guint height);

Sets the crop size of the movie.

video : an OGMRipVideo
x : the cropped x position
y : the cropped y position
width : the cropped width
height : the cropped height

ogmrip_video_get_deblock ()

gboolean            ogmrip_video_get_deblock            (OGMRipVideo *video);

Gets whether a deblocking filter will be applied.

video : an OGMRipVideo
Returns : TRUE if a deblocking filter will be applied

ogmrip_video_set_deblock ()

void                ogmrip_video_set_deblock            (OGMRipVideo *video,
                                                         gboolean deblock);

Sets whether to apply a deblocking filter.

video : an OGMRipVideo
deblock : TRUE to apply a deblocking filter

ogmrip_video_get_deinterlacer ()

gint                ogmrip_video_get_deinterlacer       (OGMRipVideo *video);

Gets the currnet deinterlacer.

video : an OGMRipVideo
Returns : the deinterlacer, or -1

ogmrip_video_set_deinterlacer ()

void                ogmrip_video_set_deinterlacer       (OGMRipVideo *video,
                                                         OGMRipDeintType deint);

Sets the deinterlacer to be used.

video : an OGMRipVideo
deint : an OGMRipDeintType

ogmrip_video_get_denoise ()

gboolean            ogmrip_video_get_denoise            (OGMRipVideo *video);

Gets whether to reduce image noise.

video : an OGMRipVideo
Returns : TRUE to reduce image noise

ogmrip_video_set_denoise ()

void                ogmrip_video_set_denoise            (OGMRipVideo *video,
                                                         gboolean denoise);

Sets whether to reduce image noise.

video : an OGMRipVideo
denoise : TRUE to reduce image noise

ogmrip_video_get_dering ()

gboolean            ogmrip_video_get_dering             (OGMRipVideo *video);

Gets whether a deringing filter will be applied.

video : an OGMRipVideo
Returns : TRUE if a deringing filter will be applied

ogmrip_video_set_dering ()

void                ogmrip_video_set_dering             (OGMRipVideo *video,
                                                         gboolean dering);

Sets whether to apply a deringing filter.

video : an OGMRipVideo
dering : TRUE to apply a deringing filter

ogmrip_video_get_ensure_sync ()

OGMDvdAudioStream*  ogmrip_video_get_ensure_sync        (OGMRipVideo *video);

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

video : an OGMRipVideo
Returns : the OGMDvdAudioStream, or NULL

ogmrip_video_set_ensure_sync ()

void                ogmrip_video_set_ensure_sync        (OGMRipVideo *video,
                                                         OGMDvdAudioStream *stream);

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

video : an OGMRipVideo
stream : an OGMDvdAudioStream

ogmrip_video_get_grayscale ()

gboolean            ogmrip_video_get_grayscale          (OGMRipVideo *video);

Gets whether the movie is grayscale.

video : an OGMRipVideo
Returns : TRUE if movie is grayscale

ogmrip_video_set_grayscale ()

void                ogmrip_video_set_grayscale          (OGMRipVideo *video,
                                                         gboolean grayscale);

Sets whether the movie is grayscale.

video : an OGMRipVideo
grayscale : TRUE if movie is grayscale

ogmrip_video_get_log ()

gchar*              ogmrip_video_get_log                (OGMRipVideo *video);

Gets the name of the file in which to dump first path information.

video : an OGMRipVideo
Returns : the filename, or NULL

ogmrip_video_set_log ()

void                ogmrip_video_set_log                (OGMRipVideo *video,
                                                         const gchar *log);

Sets the name of the file in which to dump first path information.

video : an OGMRipVideo
log : the name of the log file

ogmrip_video_get_max_b_frames ()

gint                ogmrip_video_get_max_b_frames       (OGMRipVideo *video);

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

video : an OGMRipVideo
Returns : the maximum number of B-frames, or -1

ogmrip_video_set_max_b_frames ()

void                ogmrip_video_set_max_b_frames       (OGMRipVideo *video,
                                                         guint max_b_frames);

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

video : an OGMRipVideo
max_b_frames : the maximum number of B-frames

ogmrip_video_get_pass ()

gint                ogmrip_video_get_pass               (OGMRipVideo *video);

Gets the current pass number.

video : an OGMRipVideo
Returns : the pass number, or -1

ogmrip_video_set_pass ()

void                ogmrip_video_set_pass               (OGMRipVideo *video,
                                                         guint pass);

Sets the pass number of the encoding.

video : an OGMRipVideo
pass : the pass number

ogmrip_video_get_pullup ()

gboolean            ogmrip_video_get_pullup             (OGMRipVideo *video);

Gets whether an inverse telecine filter will be applied

video : an OGMRipVideo
Returns : TRUE if inverse telecine

ogmrip_video_set_pullup ()

void                ogmrip_video_set_pullup             (OGMRipVideo *video,
                                                         gboolean pullup);

Sets whether an inverse telecine filter will be applied

video : an OGMRipVideo
pullup : TRUE to inverse telecine

ogmrip_video_get_qpel ()

gboolean            ogmrip_video_get_qpel               (OGMRipVideo *video);

Sets whether quarter pel motion compensation is used.

video : an OGMRipVideo
Returns : TRUE if quarter pel motion compensation is used

ogmrip_video_set_qpel ()

void                ogmrip_video_set_qpel               (OGMRipVideo *video,
                                                         gboolean qpel);

Sets whether to use quarter pel motion compensation.

video : an OGMRipVideo
qpel : TRUE to use quarter pel motion compensation

ogmrip_video_get_quality ()

gint                ogmrip_video_get_quality            (OGMRipVideo *video);

Gets the quality of the encoding.

video : an OGMRipVideo
Returns : the OGMRipQualityType, or -1

ogmrip_video_set_quality ()

void                ogmrip_video_set_quality            (OGMRipVideo *video,
                                                         OGMRipQualityType quality);

Sets the quality of the encoding.

video : an OGMRipVideo
quality : the OGMRipQualityType

ogmrip_video_get_quantizer ()

gdouble             ogmrip_video_get_quantizer          (OGMRipVideo *video);

Gets the video quantizer.

video : an OGMRipVideo
Returns : the video quantizer, or -1

ogmrip_video_set_quantizer ()

void                ogmrip_video_set_quantizer          (OGMRipVideo *video,
                                                         gdouble quantizer);

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

video : an OGMRipVideo
quantizer : the video quantizer

ogmrip_video_get_raw_size ()

void                ogmrip_video_get_raw_size           (OGMRipVideo *video,
                                                         guint *width,
                                                         guint *height);

Gets the raw size of the video.

video : an OGMRipVideo
width : a pointer to store the width
height : a pointer to store the height

ogmrip_video_get_scale_size ()

gboolean            ogmrip_video_get_scale_size         (OGMRipVideo *video,
                                                         guint *width,
                                                         guint *height);

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

video : an OGMRipVideo
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_set_scale_size ()

void                ogmrip_video_set_scale_size         (OGMRipVideo *video,
                                                         guint width,
                                                         guint height);

Sets the scaled size of the movie.

video : an OGMRipVideo
width : the scaled width
height : the scaled height

ogmrip_video_get_scaler ()

gint                ogmrip_video_get_scaler             (OGMRipVideo *video);

Gets the current software scaler.

video : an OGMRipVideo
Returns : the software scaler, or -1

ogmrip_video_set_scaler ()

void                ogmrip_video_set_scaler             (OGMRipVideo *video,
                                                         OGMRipScalerType scaler);

Sets the software scaler to be used.

video : an OGMRipVideo
scaler : an OGMRipScalerType

ogmrip_video_get_threads ()

gint                ogmrip_video_get_threads            (OGMRipVideo *video);

Gets the number of threads.

video : an OGMRipVideo
Returns : the number of threads, or -1

ogmrip_video_set_threads ()

void                ogmrip_video_set_threads            (OGMRipVideo *video,
                                                         guint threads);

Sets the number of threads to be used.

video : an OGMRipVideo
threads : the number of threads

ogmrip_video_get_trellis ()

gboolean            ogmrip_video_get_trellis            (OGMRipVideo *video);

Gets whether trellis quantization is enabled.

video : an OGMRipVideo
Returns : TRUE if trellis quantization is enabled

ogmrip_video_set_trellis ()

void                ogmrip_video_set_trellis            (OGMRipVideo *video,
                                                         gboolean trellis);

Sets whether trellis quantization will be enabled.

video : an OGMRipVideo
trellis : TRUE to enable trellis quantization

ogmrip_video_get_turbo ()

gboolean            ogmrip_video_get_turbo              (OGMRipVideo *video);

Gets whether turbo is enabled.

video : an OGMRipVideo
Returns : TRUE if turbo is enabled

ogmrip_video_set_turbo ()

void                ogmrip_video_set_turbo              (OGMRipVideo *video,
                                                         gboolean turbo);

Sets whether to enable turbo.

video : an OGMRipVideo
turbo : TRUE to enable turbo