BaconVideoWidget

## BaconVideoWidget BaconVideoWidget — video playing widget and abstraction |

## Stability Level

Unstable, unless otherwise indicated

## Synopsis

    #include <bacon-video-widget.h>

                        BaconVideoWidget;
                        BaconVideoWidgetClass;
    enum                BvwAspectRatio;
    enum                BvwAudioOutType;
    enum                BvwDVDEvent;
    enum                BvwMetadataType;
    enum                BvwVisualsQuality;
    enum                BvwVideoProperty;
    enum                BvwError;
    enum                BvwUseType;
    GtkWidget *         bacon_video_widget_new              (int width,
                                                             int height,
                                                             BvwUseType type,
                                                             GError **error);
    void                bacon_video_widget_init_backend     (int *argc,
                                                             char ***argv);
    gboolean            bacon_video_widget_open             (BaconVideoWidget *bvw,
                                                             const char *mrl,
                                                             const char *subtitle_uri,
                                                             GError **error);
    gboolean            bacon_video_widget_play             (BaconVideoWidget *bvw,
                                                             GError **error);
    void                bacon_video_widget_pause            (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_seek             (BaconVideoWidget *bvw,
                                                             double position,
                                                             GError **error);
    gboolean            bacon_video_widget_seek_time        (BaconVideoWidget *bvw,
                                                             gint64 _time,
                                                             gboolean accurate,
                                                             GError **error);
    void                bacon_video_widget_stop             (BaconVideoWidget *bvw);
    void                bacon_video_widget_close            (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_can_direct_seek  (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_can_get_frames   (BaconVideoWidget *bvw,
                                                             GError **error);
    gboolean            bacon_video_widget_can_set_volume   (BaconVideoWidget *bvw);
    void                bacon_video_widget_dvd_event        (BaconVideoWidget *bvw,
                                                             BvwDVDEvent type);
    gboolean            bacon_video_widget_has_menus        (BaconVideoWidget *bvw);
    BvwAspectRatio      bacon_video_widget_get_aspect_ratio (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_aspect_ratio (BaconVideoWidget *bvw,
                                                             BvwAspectRatio ratio);
    BvwAudioOutType     bacon_video_widget_get_audio_out_type
                                                            (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_set_audio_out_type
                                                            (BaconVideoWidget *bvw,
                                                             BvwAudioOutType type);
    gboolean            bacon_video_widget_get_auto_resize  (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_auto_resize  (BaconVideoWidget *bvw,
                                                             gboolean auto_resize);
    char *              bacon_video_widget_get_backend_name (BaconVideoWidget *bvw);
    int                 bacon_video_widget_get_connection_speed
                                                            (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_connection_speed
                                                            (BaconVideoWidget *bvw,
                                                             int speed);
    GdkPixbuf *         bacon_video_widget_get_current_frame
                                                            (BaconVideoWidget *bvw);
    gint64              bacon_video_widget_get_current_time (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_get_deinterlacing
                                                            (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_deinterlacing
                                                            (BaconVideoWidget *bvw,
                                                             gboolean deinterlace);
    void                bacon_video_widget_set_fullscreen   (BaconVideoWidget *bvw,
                                                             gboolean fullscreen);
    GList *             bacon_video_widget_get_languages    (BaconVideoWidget *bvw);
    int                 bacon_video_widget_get_language     (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_language     (BaconVideoWidget *bvw,
                                                             int language);
    void                bacon_video_widget_set_logo         (BaconVideoWidget *bvw,
                                                             const char *name);
    gboolean            bacon_video_widget_get_logo_mode    (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_logo_mode    (BaconVideoWidget *bvw,
                                                             gboolean logo_mode);
    void                bacon_video_widget_get_metadata     (BaconVideoWidget *bvw,
                                                             BvwMetadataType type,
                                                             GValue *value);
    gchar **            bacon_video_widget_get_mrls         (BaconVideoWidget *bvw,
                                                             TotemDiscMediaType type,
                                                             const char *device,
                                                             GError **error);
    GOptionGroup*       bacon_video_widget_get_option_group (void);
    double              bacon_video_widget_get_position     (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_referrer     (BaconVideoWidget *bvw,
                                                             const char *referrer);
    void                bacon_video_widget_set_scale_ratio  (BaconVideoWidget *bvw,
                                                             float ratio);
    gboolean            bacon_video_widget_get_show_cursor  (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_show_cursor  (BaconVideoWidget *bvw,
                                                             gboolean show_cursor);
    void                bacon_video_widget_set_show_visuals (BaconVideoWidget *bvw,
                                                             gboolean show_visuals);
    gint64              bacon_video_widget_get_stream_length
                                                            (BaconVideoWidget *bvw);
    GList *             bacon_video_widget_get_subtitles    (BaconVideoWidget *bvw);
    int                 bacon_video_widget_get_subtitle     (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_subtitle     (BaconVideoWidget *bvw,
                                                             int subtitle);
    void                bacon_video_widget_set_subtitle_encoding
                                                            (BaconVideoWidget *bvw,
                                                             const char *encoding);
    void                bacon_video_widget_set_subtitle_font
                                                            (BaconVideoWidget *bvw,
                                                             const char *font);
    void                bacon_video_widget_set_user_agent   (BaconVideoWidget *bvw,
                                                             const char *user_agent);
    int                 bacon_video_widget_get_video_property
                                                            (BaconVideoWidget *bvw,
                                                             BvwVideoProperty type);
    void                bacon_video_widget_set_video_property
                                                            (BaconVideoWidget *bvw,
                                                             BvwVideoProperty type,
                                                             int value);
    GList *             bacon_video_widget_get_visuals_list (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_set_visuals      (BaconVideoWidget *bvw,
                                                             const char *name);
    void                bacon_video_widget_set_visuals_quality
                                                            (BaconVideoWidget *bvw,
                                                             BvwVisualsQuality quality);
    double              bacon_video_widget_get_volume       (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_volume       (BaconVideoWidget *bvw,
                                                             double volume);
    double              bacon_video_widget_get_zoom         (BaconVideoWidget *bvw);
    void                bacon_video_widget_set_zoom         (BaconVideoWidget *bvw,
                                                             double zoom);
    gboolean            bacon_video_widget_has_next_track   (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_has_previous_track
                                                            (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_is_playing       (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_is_seekable      (BaconVideoWidget *bvw);
    gboolean            bacon_video_widget_step             (BaconVideoWidget *bvw,
                                                             gboolean forward,
                                                             GError **error);

## Object Hierarchy

      GObject
       +----GInitiallyUnowned
             +----GtkObject
                   +----GtkWidget
                         +----GtkContainer
                               +----GtkBin
                                     +----GtkEventBox
                                           +----BaconVideoWidget

## Implemented Interfaces

BaconVideoWidget implements AtkImplementorIface and GtkBuildable.

## Properties

      "download-filename"        gchar*                : Read / Write
      "logo-mode"                gboolean              : Read / Write
      "playing"                  gboolean              : Read
      "position"                 gdouble               : Read
      "referrer"                 gchar*                : Read / Write
      "seekable"                 gboolean              : Read
      "show-cursor"              gboolean              : Read / Write
      "show-visuals"             gboolean              : Write
      "stream-length"            gint64                : Read
      "user-agent"               gchar*                : Read / Write
      "volume"                   gdouble               : Read / Write

## Signals

      "buffering"                                      : Run Last
      "channels-change"                                : Run Last
      "download-buffering"                             : Run Last
      "eos"                                            : Run Last
      "error"                                          : Run Last
      "got-metadata"                                   : Run Last
      "got-redirect"                                   : Run Last
      "missing-plugins"                                : Run Last
      "tick"                                           : Run Last

## Description

BaconVideoWidget is a widget to play audio or video streams, with support for visualisations for audio-only streams. It has a GStreamer backend, and abstracts away the differences to provide a simple interface to the functionality required by Totem. It handles all the low-level audio and video work for Totem (or passes the work off to the backend).

## Details

### BaconVideoWidget

    typedef struct _BaconVideoWidget BaconVideoWidget;

All the fields in the BaconVideoWidget structure are private and should never be accessed directly.

### BaconVideoWidgetClass

    typedef struct {
    } BaconVideoWidgetClass;

All the fields in the BaconVideoWidgetClass structure are private and should never be accessed directly.

### enum BvwAspectRatio

    typedef enum {
    	BVW_RATIO_AUTO = 0,
    	BVW_RATIO_SQUARE = 1,
    	BVW_RATIO_FOURBYTHREE = 2,
    	BVW_RATIO_ANAMORPHIC = 3,
    	BVW_RATIO_DVB = 4
    } BvwAspectRatio;

The pixel aspect ratios available in which to display videos using @`bacon_video_widget_set_aspect_ratio()`.

`BVW_RATIO_AUTO` | automatic
`BVW_RATIO_SQUARE` | square (1:1)
`BVW_RATIO_FOURBYTHREE` | four-by-three (4:3)
`BVW_RATIO_ANAMORPHIC` | anamorphic (16:9)
`BVW_RATIO_DVB` | DVB (20:9)

### enum BvwAudioOutType

    typedef enum {
    	BVW_AUDIO_SOUND_STEREO,
    	BVW_AUDIO_SOUND_4CHANNEL,
    	BVW_AUDIO_SOUND_41CHANNEL,
    	BVW_AUDIO_SOUND_5CHANNEL,
    	BVW_AUDIO_SOUND_51CHANNEL,
    	BVW_AUDIO_SOUND_AC3PASSTHRU
    } BvwAudioOutType;

The audio output types available for use with `bacon_video_widget_set_audio_out_type()`.

`BVW_AUDIO_SOUND_STEREO` | stereo output
`BVW_AUDIO_SOUND_4CHANNEL` | 4-channel output
`BVW_AUDIO_SOUND_41CHANNEL` | 4.1-channel output
`BVW_AUDIO_SOUND_5CHANNEL` | 5-channel output
`BVW_AUDIO_SOUND_51CHANNEL` | 5.1-channel output
`BVW_AUDIO_SOUND_AC3PASSTHRU` | AC3 passthrough output

### enum BvwDVDEvent

    typedef enum {
    	BVW_DVD_ROOT_MENU,
    	BVW_DVD_TITLE_MENU,
    	BVW_DVD_SUBPICTURE_MENU,
    	BVW_DVD_AUDIO_MENU,
    	BVW_DVD_ANGLE_MENU,
    	BVW_DVD_CHAPTER_MENU,
    	BVW_DVD_NEXT_CHAPTER,
    	BVW_DVD_PREV_CHAPTER,
    	BVW_DVD_NEXT_TITLE,
    	BVW_DVD_PREV_TITLE,
    	BVW_DVD_NEXT_ANGLE,
    	BVW_DVD_PREV_ANGLE,
    	BVW_DVD_ROOT_MENU_UP,
    	BVW_DVD_ROOT_MENU_DOWN,
    	BVW_DVD_ROOT_MENU_LEFT,
    	BVW_DVD_ROOT_MENU_RIGHT,
    	BVW_DVD_ROOT_MENU_SELECT
    } BvwDVDEvent;

The DVD navigation actions available to fire as DVD events to the BaconVideoWidget.

`BVW_DVD_ROOT_MENU` | root menu
`BVW_DVD_TITLE_MENU` | title menu
`BVW_DVD_SUBPICTURE_MENU` | subpicture menu (if available)
`BVW_DVD_AUDIO_MENU` | audio menu (if available)
`BVW_DVD_ANGLE_MENU` | angle menu (if available)
`BVW_DVD_CHAPTER_MENU` | chapter menu
`BVW_DVD_NEXT_CHAPTER` | the next chapter
`BVW_DVD_PREV_CHAPTER` | the previous chapter
`BVW_DVD_NEXT_TITLE` | the next title in the current chapter
`BVW_DVD_PREV_TITLE` | the previous title in the current chapter
`BVW_DVD_NEXT_ANGLE` | the next angle
`BVW_DVD_PREV_ANGLE` | the previous angle
`BVW_DVD_ROOT_MENU_UP` | go up in the menu
`BVW_DVD_ROOT_MENU_DOWN` | go down in the menu
`BVW_DVD_ROOT_MENU_LEFT` | go left in the menu
`BVW_DVD_ROOT_MENU_RIGHT` | go right in the menu
`BVW_DVD_ROOT_MENU_SELECT` | select the current menu entry

### enum BvwMetadataType

    typedef enum {
    	BVW_INFO_TITLE,
    	BVW_INFO_ARTIST,
    	BVW_INFO_YEAR,
    	BVW_INFO_COMMENT,
    	BVW_INFO_ALBUM,
    	BVW_INFO_DURATION,
    	BVW_INFO_TRACK_NUMBER,
    	BVW_INFO_COVER,
    	/* Video */
    	BVW_INFO_HAS_VIDEO,
    	BVW_INFO_DIMENSION_X,
    	BVW_INFO_DIMENSION_Y,
    	BVW_INFO_VIDEO_BITRATE,
    	BVW_INFO_VIDEO_CODEC,
    	BVW_INFO_FPS,
    	/* Audio */
    	BVW_INFO_HAS_AUDIO,
    	BVW_INFO_AUDIO_BITRATE,
    	BVW_INFO_AUDIO_CODEC,
    	BVW_INFO_AUDIO_SAMPLE_RATE,
    	BVW_INFO_AUDIO_CHANNELS
    } BvwMetadataType;

The different metadata available for querying from a BaconVideoWidget stream with `bacon_video_widget_get_metadata()`.

`BVW_INFO_TITLE` | the stream's title
`BVW_INFO_ARTIST` | the artist who created the work
`BVW_INFO_YEAR` | the year in which the work was created
`BVW_INFO_COMMENT` | a comment attached to the stream
`BVW_INFO_ALBUM` | the album in which the work was released
`BVW_INFO_DURATION` | the stream's duration, in seconds
`BVW_INFO_TRACK_NUMBER` | the track number of the work on the album
`BVW_INFO_COVER` | a GdkPixbuf of the cover artwork
`BVW_INFO_HAS_VIDEO` | whether the stream has video
`BVW_INFO_DIMENSION_X` | the video's width, in pixels
`BVW_INFO_DIMENSION_Y` | the video's height, in pixels
`BVW_INFO_VIDEO_BITRATE` | the video's bitrate, in kilobits per second
`BVW_INFO_VIDEO_CODEC` | the video's codec
`BVW_INFO_FPS` | the number of frames per second in the video
`BVW_INFO_HAS_AUDIO` | whether the stream has audio
`BVW_INFO_AUDIO_BITRATE` | the audio's bitrate, in kilobits per second
`BVW_INFO_AUDIO_CODEC` | the audio's codec
`BVW_INFO_AUDIO_SAMPLE_RATE` | the audio sample rate, in bits per second
`BVW_INFO_AUDIO_CHANNELS` | a string describing the number of audio channels in the stream

### enum BvwVisualsQuality

    typedef enum {
    	VISUAL_SMALL = 0,
    	VISUAL_NORMAL,
    	VISUAL_LARGE,
    	VISUAL_EXTRA_LARGE,
    	NUM_VISUAL_QUALITIES
    } BvwVisualsQuality;

The different visualisation sizes or qualities available for use with `bacon_video_widget_set_visuals_quality()`.

`VISUAL_SMALL` | small size (240×15)
`VISUAL_NORMAL` | normal size (320×25)
`VISUAL_LARGE` | large size (480×25)
`VISUAL_EXTRA_LARGE` | extra large size (600×30)
`NUM_VISUAL_QUALITIES` | the number of visual qualities available

### enum BvwVideoProperty

    typedef enum {
    	BVW_VIDEO_BRIGHTNESS,
    	BVW_VIDEO_CONTRAST,
    	BVW_VIDEO_SATURATION,
    	BVW_VIDEO_HUE
    } BvwVideoProperty;

The video properties queryable with `bacon_video_widget_get_video_property()`, and settable with `bacon_video_widget_set_video_property()`.

`BVW_VIDEO_BRIGHTNESS` | the video brightness
`BVW_VIDEO_CONTRAST` | the video contrast
`BVW_VIDEO_SATURATION` | the video saturation
`BVW_VIDEO_HUE` | the video hue

### enum BvwError

    typedef enum {
    	/* Plugins */
    	BVW_ERROR_AUDIO_PLUGIN,
    	BVW_ERROR_NO_PLUGIN_FOR_FILE,
    	BVW_ERROR_VIDEO_PLUGIN,
    	BVW_ERROR_AUDIO_BUSY,
    	/* File */
    	BVW_ERROR_BROKEN_FILE,
    	BVW_ERROR_FILE_GENERIC,
    	BVW_ERROR_FILE_PERMISSION,
    	BVW_ERROR_FILE_ENCRYPTED,
    	BVW_ERROR_FILE_NOT_FOUND,
    	/* Devices */
    	BVW_ERROR_DVD_ENCRYPTED,
    	BVW_ERROR_INVALID_DEVICE,
    	BVW_ERROR_DEVICE_BUSY,
    	/* Network */
    	BVW_ERROR_UNKNOWN_HOST,
    	BVW_ERROR_NETWORK_UNREACHABLE,
    	BVW_ERROR_CONNECTION_REFUSED,
    	/* Generic */
    	BVW_ERROR_INVALID_LOCATION,
    	BVW_ERROR_GENERIC,
    	BVW_ERROR_CODEC_NOT_HANDLED,
    	BVW_ERROR_AUDIO_ONLY,
    	BVW_ERROR_CANNOT_CAPTURE,
    	BVW_ERROR_READ_ERROR,
    	BVW_ERROR_PLUGIN_LOAD,
    	BVW_ERROR_EMPTY_FILE
    } BvwError;

Error codes for BaconVideoWidget operations.

`BVW_ERROR_AUDIO_PLUGIN` | Error loading audio output plugin or device.
`BVW_ERROR_NO_PLUGIN_FOR_FILE` | A required GStreamer plugin or xine feature is missing.
`BVW_ERROR_VIDEO_PLUGIN` | Error loading video output plugin or device.
`BVW_ERROR_AUDIO_BUSY` | Audio output device is busy.
`BVW_ERROR_BROKEN_FILE` | The movie file is broken and cannot be decoded.
`BVW_ERROR_FILE_GENERIC` | A generic error for problems with movie files.
`BVW_ERROR_FILE_PERMISSION` | Permission was refused to access the stream, or authentication was required.
`BVW_ERROR_FILE_ENCRYPTED` | The stream is encrypted and cannot be played.
`BVW_ERROR_FILE_NOT_FOUND` | The stream cannot be found.
`BVW_ERROR_DVD_ENCRYPTED` | The DVD is encrypted and libdvdcss is not installed.
`BVW_ERROR_INVALID_DEVICE` | The device given in an MRL (e.g. DVD drive or DVB tuner) did not exist.
`BVW_ERROR_DEVICE_BUSY` | The device was busy.
`BVW_ERROR_UNKNOWN_HOST` | The host for a given stream could not be resolved.
`BVW_ERROR_NETWORK_UNREACHABLE` | The host for a given stream could not be reached.
`BVW_ERROR_CONNECTION_REFUSED` | The server for a given stream refused the connection.
`BVW_ERROR_INVALID_LOCATION` | An MRL was malformed, or CDDB playback was attempted (which is now unsupported).
`BVW_ERROR_GENERIC` | A generic error occurred.
`BVW_ERROR_CODEC_NOT_HANDLED` | The audio or video codec required by the stream is not supported.
`BVW_ERROR_AUDIO_ONLY` | An audio-only stream could not be played due to missing audio output support.
`BVW_ERROR_CANNOT_CAPTURE` | Error determining frame capture support for a video with `bacon_video_widget_can_get_frames()`.
`BVW_ERROR_READ_ERROR` | A generic error for problems reading streams.
`BVW_ERROR_PLUGIN_LOAD` | A library or plugin could not be loaded.
`BVW_ERROR_EMPTY_FILE` | A movie file was empty.

### enum BvwUseType

    typedef enum {
    	BVW_USE_TYPE_VIDEO,
    	BVW_USE_TYPE_AUDIO,
    	BVW_USE_TYPE_CAPTURE,
    	BVW_USE_TYPE_METADATA
    } BvwUseType;

The purpose for which a BaconVideoWidget will be used, as specified to `bacon_video_widget_new()`. This determines which features will be enabled in the created widget.

`BVW_USE_TYPE_VIDEO` | fully-featured with video, audio, capture and metadata support
`BVW_USE_TYPE_AUDIO` | audio and metadata support
`BVW_USE_TYPE_CAPTURE` | capture support only
`BVW_USE_TYPE_METADATA` | metadata support only

### bacon_video_widget_new ()

    GtkWidget *         bacon_video_widget_new              (int width,
                                                             int height,
                                                             BvwUseType type,
                                                             GError **error);

Creates a new BaconVideoWidget for the purpose specified in `type`.

If `type` is `BVW_USE_TYPE_VIDEO`, the BaconVideoWidget will be fully-featured; other values of `type` will enable less functionality on the widget, which will come with corresponding decreases in the size of its memory footprint.

`width` and `height` give the initial or expected video height. Set them to `-1` if the video size is unknown. For small videos, BaconVideoWidget will be configured differently.

A BvwError will be returned on error.

`width` : | initial or expected video width, in pixels, or `-1`
`height` : | initial or expected video height, in pixels, or `-1`
`type` : | the widget's use type
`error` : | a GError, or `NULL`
Returns : | a new BaconVideoWidget, or `NULL`; destroy with `gtk_widget_destroy()`

### bacon_video_widget_init_backend ()

    void                bacon_video_widget_init_backend     (int *argc,
                                                             char ***argv);

Initialises BaconVideoWidget's GStreamer backend. If this fails for the GStreamer backend, your application will be terminated.

Applications must call either this or `bacon_video_widget_get_option_group()` exactly once; but not both.

`argc` : | pointer to application's argc
`argv` : | pointer to application's argv

### bacon_video_widget_open ()

    gboolean            bacon_video_widget_open             (BaconVideoWidget *bvw,
                                                             const char *mrl,
                                                             const char *subtitle_uri,
                                                             GError **error);

Opens the given `mrl` in `bvw` for playing. If `subtitle_uri` is not `NULL`, the given subtitle file is also loaded. Alternatively, the subtitle URI can be passed in `mrl` by adding it after `subtitle:`. For example: `http://example.com/video.mpgsubtitle:/home/user/subtitle.ass`.

If there was a filesystem error, a `BVW_ERROR_GENERIC` error will be returned. Otherwise, more specific BvwError errors will be returned.

On success, the MRL is loaded and waiting to be played with `bacon_video_widget_play()`.

`bvw` : | a BaconVideoWidget
`mrl` : | an MRL
`subtitle_uri` : | the URI of a subtitle file, or `NULL`
`error` : | a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` otherwise

### bacon_video_widget_play ()

    gboolean            bacon_video_widget_play             (BaconVideoWidget *bvw,
                                                             GError **error);

Plays the currently-loaded video in `bvw`.

Errors from the GStreamer backend will be returned asynchronously via the "error" signal, even if this function returns `TRUE`.

`bvw` : | a BaconVideoWidget
`error` : | a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` otherwise

### bacon_video_widget_pause ()

    void                bacon_video_widget_pause            (BaconVideoWidget *bvw);

Pauses the current stream in the video widget.

If a live stream is being played, playback is stopped entirely.

`bvw` : | a BaconVideoWidget

### bacon_video_widget_seek ()

    gboolean            bacon_video_widget_seek             (BaconVideoWidget *bvw,
                                                             double position,
                                                             GError **error);

Seeks the currently-playing stream to `position` as a percentage of the total stream length.

`bvw` : | a BaconVideoWidget
`position` : | the percentage of the way through the stream to which to seek
`error` : | a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` otherwise

### bacon_video_widget_seek_time ()

    gboolean            bacon_video_widget_seek_time        (BaconVideoWidget *bvw,
                                                             gint64 _time,
                                                             gboolean accurate,
                                                             GError **error);

Seeks the currently-playing stream to the absolute position `time`, in milliseconds.

`bvw` : | a BaconVideoWidget
`_time` : | the time to which to seek, in milliseconds
`accurate` : | whether to use accurate seek, an accurate seek might be slower for some formats (see GStreamer docs)
`error` : | a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` otherwise

### bacon_video_widget_stop ()

    void                bacon_video_widget_stop             (BaconVideoWidget *bvw);

Stops playing the current stream and resets to the first position in the stream.

`bvw` : | a BaconVideoWidget

### bacon_video_widget_close ()

    void                bacon_video_widget_close            (BaconVideoWidget *bvw);

Closes the current stream and frees the resources associated with it.

`bvw` : | a BaconVideoWidget

### bacon_video_widget_can_direct_seek ()

    gboolean            bacon_video_widget_can_direct_seek  (BaconVideoWidget *bvw);

Determines whether direct seeking is possible for the current stream.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if direct seeking is possible, `FALSE` otherwise

### bacon_video_widget_can_get_frames ()

    gboolean            bacon_video_widget_can_get_frames   (BaconVideoWidget *bvw,
                                                             GError **error);

Determines whether individual frames from the current stream can be returned using `bacon_video_widget_get_current_frame()`.

Frames cannot be returned for audio-only streams, unless visualisations are enabled.

`bvw` : | a BaconVideoWidget
`error` : | a GError, or `NULL`
Returns : | `TRUE` if frames can be captured, `FALSE` otherwise

### bacon_video_widget_can_set_volume ()

    gboolean            bacon_video_widget_can_set_volume   (BaconVideoWidget *bvw);

Returns whether the volume level can be set, given the current settings.

The volume cannot be set if the audio output type is set to `BVW_AUDIO_SOUND_AC3PASSTHRU`.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if the volume can be set, `FALSE` otherwise

### bacon_video_widget_dvd_event ()

    void                bacon_video_widget_dvd_event        (BaconVideoWidget *bvw,
                                                             BvwDVDEvent type);

Issues a DVD navigation event to the video widget, such as one to skip to the next chapter, or navigate to the DVD title menu.

This is a no-op if the current stream is not navigable.

`bvw` : | a BaconVideoWidget
`type` : | the type of DVD event to issue

### bacon_video_widget_has_menus ()

    gboolean            bacon_video_widget_has_menus        (BaconVideoWidget *bvw);

Returns whether the widget is currently displaying a menu, such as a DVD menu.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if a menu is displyed, `FALSE` otherwise

### bacon_video_widget_get_aspect_ratio ()

    BvwAspectRatio      bacon_video_widget_get_aspect_ratio (BaconVideoWidget *bvw);

Returns the current aspect ratio used by the widget, from BaconVideoWidgetAspectRatio.

`bvw` : | a BaconVideoWidget
Returns : | the aspect ratio

### bacon_video_widget_set_aspect_ratio ()

    void                bacon_video_widget_set_aspect_ratio (BaconVideoWidget *bvw,
                                                             BvwAspectRatio ratio);

Sets the aspect ratio used by the widget, from BaconVideoWidgetAspectRatio.

Changes to this take effect immediately.

`bvw` : | a BaconVideoWidget
`ratio` : | the new aspect ratio

### bacon_video_widget_get_audio_out_type ()

    BvwAudioOutType     bacon_video_widget_get_audio_out_type
                                                            (BaconVideoWidget *bvw);

Returns the current audio output type (e.g. how many speaker channels) from BaconVideoWidgetAudioOutType.

`bvw` : | a BaconVideoWidget
Returns : | the audio output type, or `-1`

### bacon_video_widget_set_audio_out_type ()

    gboolean            bacon_video_widget_set_audio_out_type
                                                            (BaconVideoWidget *bvw,
                                                             BvwAudioOutType type);

Sets the audio output type (number of speaker channels) in the video widget, and stores it in GConf.

`bvw` : | a BaconVideoWidget
`type` : | the new audio output type
Returns : | `TRUE` on success, `FALSE` otherwise

### bacon_video_widget_get_auto_resize ()

    gboolean            bacon_video_widget_get_auto_resize  (BaconVideoWidget *bvw);

Returns whether the widget will automatically resize to fit videos.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if the widget will resize, `FALSE` otherwise

### bacon_video_widget_set_auto_resize ()

    void                bacon_video_widget_set_auto_resize  (BaconVideoWidget *bvw,
                                                             gboolean auto_resize);

Sets whether the widget should automatically resize to fit to new videos when they are loaded. Changes to this will take effect when the next media file is loaded.

`bvw` : | a BaconVideoWidget
`auto_resize` : | `TRUE` to automatically resize for new videos, `FALSE` otherwise

### bacon_video_widget_get_backend_name ()

    char *              bacon_video_widget_get_backend_name (BaconVideoWidget *bvw);

Returns the name string for `bvw`. For the GStreamer backend, it is the output of `gst_version_string()`. *

`bvw` : | a BaconVideoWidget
Returns : | the backend's name; free with `g_free()`

### bacon_video_widget_get_connection_speed ()

    int                 bacon_video_widget_get_connection_speed
                                                            (BaconVideoWidget *bvw);

Returns the current connection speed, where `0` is the lowest speed and `11` is the highest.

`bvw` : | a BaconVideoWidget
Returns : | the connection speed index

### bacon_video_widget_set_connection_speed ()

    void                bacon_video_widget_set_connection_speed
                                                            (BaconVideoWidget *bvw,
                                                             int speed);

Sets the connection speed from the given `speed` index, where `0` is the lowest speed and `11` is the highest.

`bvw` : | a BaconVideoWidget
`speed` : | the connection speed index

### bacon_video_widget_get_current_frame ()

    GdkPixbuf *         bacon_video_widget_get_current_frame
                                                            (BaconVideoWidget *bvw);

Returns a GdkPixbuf containing the current frame from the playing stream. This will wait for any pending seeks to complete before capturing the frame.

`bvw` : | a BaconVideoWidget
Returns : | the current frame, or `NULL`; unref with `g_object_unref()`

### bacon_video_widget_get_current_time ()

    gint64              bacon_video_widget_get_current_time (BaconVideoWidget *bvw);

Returns the current position in the stream, as the time (in milliseconds) since the beginning of the stream.

`bvw` : | a BaconVideoWidget
Returns : | time since the beginning of the stream, in milliseconds, or `-1`

### bacon_video_widget_get_deinterlacing ()

    gboolean            bacon_video_widget_get_deinterlacing
                                                            (BaconVideoWidget *bvw);

Returns whether deinterlacing of videos is enabled for this widget.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if automatic deinterlacing is enabled, `FALSE` otherwise

### bacon_video_widget_set_deinterlacing ()

    void                bacon_video_widget_set_deinterlacing
                                                            (BaconVideoWidget *bvw,
                                                             gboolean deinterlace);

Sets whether the widget should deinterlace videos.

`bvw` : | a BaconVideoWidget
`deinterlace` : | `TRUE` if videos should be automatically deinterlaced, `FALSE` otherwise

### bacon_video_widget_set_fullscreen ()

    void                bacon_video_widget_set_fullscreen   (BaconVideoWidget *bvw,
                                                             gboolean fullscreen);

Sets whether the widget renders the stream in fullscreen mode.

Fullscreen rendering is done only when possible, as xvidmode is required.

`bvw` : | a BaconVideoWidget
`fullscreen` : | `TRUE` to go fullscreen, `FALSE` otherwise

### bacon_video_widget_get_languages ()

    GList *             bacon_video_widget_get_languages    (BaconVideoWidget *bvw);

Returns a list of audio language tags, each in the form `AUDIO `x``, where `x` is the language index.

`bvw` : | a BaconVideoWidget
Returns : | a GList of audio language tags, or `NULL`; free each element with `g_free()` and the list with `g_list_free()`

### bacon_video_widget_get_language ()

    int                 bacon_video_widget_get_language     (BaconVideoWidget *bvw);

Returns the index of the current audio language.

If the widget is not playing, or the default language is in use, `-1` will be returned.

`bvw` : | a BaconVideoWidget
Returns : | the audio language index

### bacon_video_widget_set_language ()

    void                bacon_video_widget_set_language     (BaconVideoWidget *bvw,
                                                             int language);

Sets the audio language index for `bvw`. If `language` is `-1`, the default language will be used.

`bvw` : | a BaconVideoWidget
`language` : | an audio language index

### bacon_video_widget_set_logo ()

    void                bacon_video_widget_set_logo         (BaconVideoWidget *bvw,
                                                             const char *name);

Sets the logo displayed on the video widget when no stream is loaded.

`bvw` : | a BaconVideoWidget
`name` : | the icon name of the logo

### bacon_video_widget_get_logo_mode ()

    gboolean            bacon_video_widget_get_logo_mode    (BaconVideoWidget *bvw);

Gets whether the logo is displayed when no stream is loaded.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if the logo is displayed, `FALSE` otherwise

### bacon_video_widget_set_logo_mode ()

    void                bacon_video_widget_set_logo_mode    (BaconVideoWidget *bvw,
                                                             gboolean logo_mode);

Sets whether to display a logo set with `bacon_video_widget_set_logo` when no stream is loaded. If `logo_mode` is `FALSE`, nothing will be displayed and the video widget will take up no space. Otherwise, the logo will be displayed and will requisition a corresponding amount of space.

`bvw` : | a BaconVideoWidget
`logo_mode` : | `TRUE` to display the logo, `FALSE` otherwise

### bacon_video_widget_get_metadata ()

    void                bacon_video_widget_get_metadata     (BaconVideoWidget *bvw,
                                                             BvwMetadataType type,
                                                             GValue *value);

Provides metadata of the given `type` about the current stream in `value`.

Free the GValue with `g_value_unset()`.

`bvw` : | a BaconVideoWidget
`type` : | the type of metadata to return
`value` : | a GValue

### bacon_video_widget_get_mrls ()

    gchar **            bacon_video_widget_get_mrls         (BaconVideoWidget *bvw,
                                                             TotemDiscMediaType type,
                                                             const char *device,
                                                             GError **error);

Returns an array of MRLs available for the given `device` and media `type`.

`device` should typically be the number of the device (e.g. `0` for the first DVD drive.

`type` can be any value from TotemDiscMediaType, but a `BVW_ERROR_INVALID_LOCATION` error will be returned if `type` is `MEDIA_TYPE_CDDA`, as CDDA support has been removed from Totem (and hence BaconVideoWidget).

A `BVW_ERROR_NO_PLUGIN_FOR_FILE` error will be returned if the required GStreamer elements do not exist for the given `type` (for the GStreamer backend). * If `device` does not exist, a `BVW_ERROR_INVALID_DEVICE` error will be returned.

`bvw` : | a BaconVideoWidget
`type` : | the media type
`device` : | the device name
`error` : | a GError, or `NULL`
Returns : | a `NULL`-terminated array of MRLs, or `NULL`; free with `g_strfreev()`

### bacon_video_widget_get_option_group ()

    GOptionGroup*       bacon_video_widget_get_option_group (void);

Returns the GOptionGroup containing command-line options for BaconVideoWidget.

Applications must call either this or `bacon_video_widget_init_backend()` exactly once; but not both.

Returns : | a GOptionGroup giving command-line options for BaconVideoWidget

### bacon_video_widget_get_position ()

    double              bacon_video_widget_get_position     (BaconVideoWidget *bvw);

Returns the current position in the stream, as a value between `0` and `1`.

`bvw` : | a BaconVideoWidget
Returns : | the current position, or `-1`

### bacon_video_widget_set_referrer ()

    void                bacon_video_widget_set_referrer     (BaconVideoWidget *bvw,
                                                             const char *referrer);

Sets the HTTP referrer URI to use when fetching HTTP ressources.

`bvw` : | a BaconVideoWidget
`referrer` : | a HTTP referrer URI, or `NULL`

### bacon_video_widget_set_scale_ratio ()

    void                bacon_video_widget_set_scale_ratio  (BaconVideoWidget *bvw,
                                                             float ratio);

Sets the ratio by which the widget will scale videos when they are displayed. If `ratio` is set to `0`, the highest ratio possible will be chosen.

`bvw` : | a BaconVideoWidget
`ratio` : | the new scale ratio

### bacon_video_widget_get_show_cursor ()

    gboolean            bacon_video_widget_get_show_cursor  (BaconVideoWidget *bvw);

Returns whether the cursor is shown when it is over the video widget.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if the cursor is shown, `FALSE` otherwise

### bacon_video_widget_set_show_cursor ()

    void                bacon_video_widget_set_show_cursor  (BaconVideoWidget *bvw,
                                                             gboolean show_cursor);

Sets whether the cursor should be shown when it is over the video widget. If `show_cursor` is `FALSE`, the cursor will be invisible when it is moved over the video widget.

`bvw` : | a BaconVideoWidget
`show_cursor` : | `TRUE` to show the cursor, `FALSE` otherwise

### bacon_video_widget_set_show_visuals ()

    void                bacon_video_widget_set_show_visuals (BaconVideoWidget *bvw,
                                                             gboolean show_visuals);

Sets whether to show visualisations when playing audio-only streams.

`bvw` : | a BaconVideoWidget
`show_visuals` : | `TRUE` to show visualisations, `FALSE` otherwise

### bacon_video_widget_get_stream_length ()

    gint64              bacon_video_widget_get_stream_length
                                                            (BaconVideoWidget *bvw);

Returns the total length of the stream, in milliseconds.

`bvw` : | a BaconVideoWidget
Returns : | the stream length, in milliseconds, or `-1`

### bacon_video_widget_get_subtitles ()

    GList *             bacon_video_widget_get_subtitles    (BaconVideoWidget *bvw);

Returns a list of subtitle tags, each in the form `TEXT `x``, where `x` is the subtitle index.

`bvw` : | a BaconVideoWidget
Returns : | a GList of subtitle tags, or `NULL`; free each element with `g_free()` and the list with `g_list_free()`

### bacon_video_widget_get_subtitle ()

    int                 bacon_video_widget_get_subtitle     (BaconVideoWidget *bvw);

Returns the index of the current subtitles.

If the widget is not playing, `-2` will be returned. If no subtitles are being used, `-1` is returned.

`bvw` : | a BaconVideoWidget
Returns : | the subtitle index

### bacon_video_widget_set_subtitle ()

    void                bacon_video_widget_set_subtitle     (BaconVideoWidget *bvw,
                                                             int subtitle);

Sets the subtitle index for `bvw`. If `subtitle` is `-1`, no subtitles will be used.

`bvw` : | a BaconVideoWidget
`subtitle` : | a subtitle index

### bacon_video_widget_set_subtitle_encoding ()

    void                bacon_video_widget_set_subtitle_encoding
                                                            (BaconVideoWidget *bvw,
                                                             const char *encoding);

Sets the encoding system for the subtitles, so that they can be decoded properly.

`bvw` : | a BaconVideoWidget
`encoding` : | an encoding system

### bacon_video_widget_set_subtitle_font ()

    void                bacon_video_widget_set_subtitle_font
                                                            (BaconVideoWidget *bvw,
                                                             const char *font);

Sets the font size and style in which to display subtitles.

`font` is a Pango font description string, as understood by `pango_font_description_from_string()`.

`bvw` : | a BaconVideoWidget
`font` : | a font description string

### bacon_video_widget_set_user_agent ()

    void                bacon_video_widget_set_user_agent   (BaconVideoWidget *bvw,
                                                             const char *user_agent);

Sets the HTTP user agent string to use when fetching HTTP ressources.

`bvw` : | a BaconVideoWidget
`user_agent` : | a HTTP user agent string, or `NULL` to use the default

### bacon_video_widget_get_video_property ()

    int                 bacon_video_widget_get_video_property
                                                            (BaconVideoWidget *bvw,
                                                             BvwVideoProperty type);

Returns the given property of the video, such as its brightness or saturation.

It is returned as a percentage in the full range of integer values; from `0` to `G_MAXINT`, where `G_MAXINT`/2 is the default.

`bvw` : | a BaconVideoWidget
`type` : | the type of property
Returns : | the property's value, in the range `0` to `G_MAXINT`

### bacon_video_widget_set_video_property ()

    void                bacon_video_widget_set_video_property
                                                            (BaconVideoWidget *bvw,
                                                             BvwVideoProperty type,
                                                             int value);

Sets the given property of the video, such as its brightness or saturation.

It should be given as a percentage in the full range of integer values; from `0` to `G_MAXINT`, where `G_MAXINT`/2 is the default.

`bvw` : | a BaconVideoWidget
`type` : | the type of property
`value` : | the property's value, in the range `0` to `G_MAXINT`

### bacon_video_widget_get_visuals_list ()

    GList *             bacon_video_widget_get_visuals_list (BaconVideoWidget *bvw);

Returns a list of the visualisations available when playing audio-only streams.

`bvw` : | a BaconVideoWidget
Returns : | a GList of visualisation names; owned by `bvw`

### bacon_video_widget_set_visuals ()

    gboolean            bacon_video_widget_set_visuals      (BaconVideoWidget *bvw,
                                                             const char *name);

Sets the visualisation to display when playing audio-only streams.

If `name` is `NULL`, visualisations will be disabled. Otherwise, `name` should be from the list returned by `bacon_video_widget_get_visuals_list()`.

`bvw` : | a BaconVideoWidget
`name` : | the visualisation's name, or `NULL`
Returns : | `TRUE` on success, `FALSE` otherwise

### bacon_video_widget_set_visuals_quality ()

    void                bacon_video_widget_set_visuals_quality
                                                            (BaconVideoWidget *bvw,
                                                             BvwVisualsQuality quality);

Sets the quality/size of displayed visualisations.

`bvw` : | a BaconVideoWidget
`quality` : | the visualisation quality

### bacon_video_widget_get_volume ()

    double              bacon_video_widget_get_volume       (BaconVideoWidget *bvw);

Returns the current volume level, as a percentage between `0` and `1`.

`bvw` : | a BaconVideoWidget
Returns : | the volume as a percentage between `0` and `1`

### bacon_video_widget_set_volume ()

    void                bacon_video_widget_set_volume       (BaconVideoWidget *bvw,
                                                             double volume);

Sets the volume level of the stream as a percentage between `0` and `1`.

If `bacon_video_widget_can_set_volume()` returns `FALSE`, this is a no-op.

`bvw` : | a BaconVideoWidget
`volume` : | the new volume level, as a percentage between `0` and `1`

### bacon_video_widget_get_zoom ()

    double              bacon_video_widget_get_zoom         (BaconVideoWidget *bvw);

Returns the zoom factor applied to videos displayed by the widget, as an integeric percentage between `0` and `1` (e.g. `1` means no zooming at all).

`bvw` : | a BaconVideoWidget
Returns : | the zoom factor

### bacon_video_widget_set_zoom ()

    void                bacon_video_widget_set_zoom         (BaconVideoWidget *bvw,
                                                             double zoom);

Sets the zoom factor applied to the video when it is displayed, as an integeric percentage between `0` and `1` (e.g. set `zoom` to `1` to not zoom at all).

`bvw` : | a BaconVideoWidget
`zoom` : | a percentage zoom factor

### bacon_video_widget_has_next_track ()

    gboolean            bacon_video_widget_has_next_track   (BaconVideoWidget *bvw);

Determines whether there is another track after the current one, typically as a chapter on a DVD.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if there is another track, `FALSE` otherwise

### bacon_video_widget_has_previous_track ()

    gboolean            bacon_video_widget_has_previous_track
                                                            (BaconVideoWidget *bvw);

Determines whether there is another track before the current one, typically as a chapter on a DVD.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if there is another track, `FALSE` otherwise

### bacon_video_widget_is_playing ()

    gboolean            bacon_video_widget_is_playing       (BaconVideoWidget *bvw);

Returns whether the widget is currently playing a stream.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if a stream is playing, `FALSE` otherwise

### bacon_video_widget_is_seekable ()

    gboolean            bacon_video_widget_is_seekable      (BaconVideoWidget *bvw);

Returns whether seeking is possible in the current stream.

If no stream is loaded, `FALSE` is returned.

`bvw` : | a BaconVideoWidget
Returns : | `TRUE` if the stream is seekable, `FALSE` otherwise

### bacon_video_widget_step ()

    gboolean            bacon_video_widget_step             (BaconVideoWidget *bvw,
                                                             gboolean forward,
                                                             GError **error);

Step one frame forward, if `forward` is `TRUE`, or backwards, if `forward` is `FALSE`

`bvw` : | a BaconVideoWidget
`forward` : | the direction of the frame step
`error` : | a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` otherwise

## Property Details

### The `"download-filename"` property

      "download-filename"        gchar*                : Read / Write

The filename of the fully downloaded stream when using download buffering.

Default value: NULL

### The `"logo-mode"` property

      "logo-mode"                gboolean              : Read / Write

Whether the logo should be displayed when no stream is loaded, or the widget should take up no space.

Default value: FALSE

### The `"playing"` property

      "playing"                  gboolean              : Read

Whether a stream is currently playing.

Default value: FALSE

### The `"position"` property

      "position"                 gdouble               : Read

The current position in the stream, as a percentage between `0` and `1`.

Allowed values: [0,1]

Default value: 0

### The `"referrer"` property

      "referrer"                 gchar*                : Read / Write

The HTTP referrer URI.

Default value: NULL

### The `"seekable"` property

      "seekable"                 gboolean              : Read

Whether the current stream can be seeked.

Default value: FALSE

### The `"show-cursor"` property

      "show-cursor"              gboolean              : Read / Write

Whether the cursor should be shown, or should be invisible, when it is over the video widget.

Default value: FALSE

### The `"show-visuals"` property

      "show-visuals"             gboolean              : Write

Whether visualisations should be shown for audio-only streams.

Default value: FALSE

### The `"stream-length"` property

      "stream-length"            gint64                : Read

The length of the current stream, in milliseconds.

Allowed values: >= 0

Default value: 0

### The `"user-agent"` property

      "user-agent"               gchar*                : Read / Write

The HTTP user agent string to use.

Default value: NULL

### The `"volume"` property

      "volume"                   gdouble               : Read / Write

The current volume level, as a percentage between `0` and `1`.

Allowed values: [0,1]

Default value: 0

## Signal Details

### The `"buffering"` signal

    void                user_function                      (BaconVideoWidget *percentage,
                                                            gint              arg1,
                                                            gpointer          user_data)       : Run Last

Emitted regularly when a network stream is being buffered, to provide status updates on the buffering progress.

`percentage` : | the percentage of buffering completed, between `0` and `1`
`user_data` : | user data set when the signal handler was connected.

### The `"channels-change"` signal

    void                user_function                      (BaconVideoWidget *arg0,
                                                            gpointer          user_data)      : Run Last

Emitted when the number of audio languages available changes, or when the selected audio language is changed.

Query the new list of audio languages with `bacon_video_widget_get_languages()`.

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

### The `"download-buffering"` signal

    void                user_function                      (BaconVideoWidget *percentage,
                                                            gdouble           arg1,
                                                            gpointer          user_data)       : Run Last

Emitted regularly when a network stream is being cached on disk, to provide status updates on the buffering level of the stream.

`percentage` : | the percentage of download buffering completed, between `0` and `1`
`user_data` : | user data set when the signal handler was connected.

### The `"eos"` signal

    void                user_function                      (BaconVideoWidget *arg0,
                                                            gpointer          user_data)      : Run Last

Emitted when the end of the current stream is reached.

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

### The `"error"` signal

    void                user_function                      (BaconVideoWidget *message,
                                                            gchar            *playback_stopped,
                                                            gboolean          fatal,
                                                            gboolean          arg3,
                                                            gpointer          user_data)             : Run Last

Emitted when the backend wishes to asynchronously report an error. If `fatal` is `TRUE`, playback of this stream cannot be restarted.

`message` : | the error message
`playback_stopped` : | `TRUE` if playback has stopped due to the error, `FALSE` otherwise
`fatal` : | `TRUE` if the error was fatal to playback, `FALSE` otherwise
`user_data` : | user data set when the signal handler was connected.

### The `"got-metadata"` signal

    void                user_function                      (BaconVideoWidget *arg0,
                                                            gpointer          user_data)      : Run Last

Emitted when the widget has updated the metadata of the current stream. This will typically happen just after opening a stream.

Call `bacon_video_widget_get_metadata()` to query the updated metadata.

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

### The `"got-redirect"` signal

    void                user_function                      (BaconVideoWidget *new_mrl,
                                                            gchar            *arg1,
                                                            gpointer          user_data)      : Run Last

Emitted when a redirect response is received from a stream's server.

`new_mrl` : | the new MRL
`user_data` : | user data set when the signal handler was connected.

### The `"missing-plugins"` signal

    gboolean            user_function                      (BaconVideoWidget *details,
                                                            GStrv            *descriptions,
                                                            GStrv            *playing,
                                                            gboolean          Returns,
                                                            gpointer          user_data)         : Run Last

Emitted when plugins required to play the current stream are not found. This allows the application to request the user install them before proceeding to try and play the stream again.

Note that this signal is only available for the GStreamer backend.

`details` : | a `NULL`-terminated array of missing plugin details for use when installing the plugins with libgimme-codec
`descriptions` : | a `NULL`-terminated array of missing plugin descriptions for display to the user
`playing` : | `TRUE` if the stream could be played even without these plugins, `FALSE` otherwise
`user_data` : | user data set when the signal handler was connected.
Returns : | `TRUE` if the signal was handled and some action was taken, `FALSE` otherwise

### The `"tick"` signal

    void                user_function                      (BaconVideoWidget *current_time,
                                                            gint64            stream_length,
                                                            gint64            current_position,
                                                            gdouble           seekable,
                                                            gboolean          arg4,
                                                            gpointer          user_data)             : Run Last

Emitted every time an important time event happens, or at regular intervals when playing a stream.

`current_time` : | the current position in the stream, in milliseconds since the beginning of the stream
`stream_length` : | the length of the stream, in milliseconds
`current_position` : | the current position in the stream, as a percentage between `0` and `1`
`seekable` : | `TRUE` if the stream can be seeked, `FALSE` otherwise
`user_data` : | user data set when the signal handler was connected.