/* * Copyright © 2018 Benjamin Otte * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see . * * Authors: Benjamin Otte */ #include "config.h" #include "gtkmediastream.h" #include "gtkintl.h" /** * SECTION:gtkmediastream * @Short_description: Display media in GTK * @Title: GtkMediaStream * @See_also: #GdkPaintable, #GtkMediaFile * * #GtkMediaStream is the integration point for media playback inside GTK. * * GTK provides an implementation of the #GtkMediaStream interface that * is called #GtkMediaFile. * * Apart from application-facing API for stream playback, #GtkMediaStream * has a number of APIs that are only useful for implementations and should * not be used in applications: * gtk_media_stream_prepared(), * gtk_media_stream_unprepared(), * gtk_media_stream_update(), * gtk_media_stream_ended(), * gtk_media_stream_seek_success(), * gtk_media_stream_seek_failed(), * gtk_media_stream_gerror(), * gtk_media_stream_error(), * gtk_media_stream_error_valist(). */ typedef struct _GtkMediaStreamPrivate GtkMediaStreamPrivate; struct _GtkMediaStreamPrivate { gint64 timestamp; gint64 duration; GError *error; double volume; guint has_audio : 1; guint has_video : 1; guint playing : 1; guint ended : 1; guint seekable : 1; guint seeking : 1; guint loop : 1; guint prepared : 1; guint muted : 1; }; enum { PROP_0, PROP_PREPARED, PROP_ERROR, PROP_HAS_AUDIO, PROP_HAS_VIDEO, PROP_PLAYING, PROP_ENDED, PROP_TIMESTAMP, PROP_DURATION, PROP_SEEKABLE, PROP_SEEKING, PROP_LOOP, PROP_MUTED, PROP_VOLUME, N_PROPS, }; static GParamSpec *properties[N_PROPS] = { NULL, }; static void gtk_media_stream_paintable_snapshot (GdkPaintable *paintable, GdkSnapshot *snapshot, double width, double height) { } static void gtk_media_stream_paintable_init (GdkPaintableInterface *iface) { /* We implement the behavior for "no video stream" here */ iface->snapshot = gtk_media_stream_paintable_snapshot; } G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkMediaStream, gtk_media_stream, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE, gtk_media_stream_paintable_init) G_ADD_PRIVATE (GtkMediaStream)) #define GTK_MEDIA_STREAM_WARN_NOT_IMPLEMENTED_METHOD(obj,method) \ g_critical ("Media stream of type '%s' does not implement GtkMediaStream::" # method, G_OBJECT_TYPE_NAME (obj)) static gboolean gtk_media_stream_default_play (GtkMediaStream *self) { GTK_MEDIA_STREAM_WARN_NOT_IMPLEMENTED_METHOD (self, play); return FALSE; } static void gtk_media_stream_default_pause (GtkMediaStream *self) { GTK_MEDIA_STREAM_WARN_NOT_IMPLEMENTED_METHOD (self, pause); } static void gtk_media_stream_default_seek (GtkMediaStream *self, gint64 timestamp) { gtk_media_stream_seek_failed (self); } static void gtk_media_stream_default_update_audio (GtkMediaStream *self, gboolean muted, double volume) { } static void gtk_media_stream_default_realize (GtkMediaStream *self, GdkSurface *surface) { } static void gtk_media_stream_default_unrealize (GtkMediaStream *self, GdkSurface *surface) { } static void gtk_media_stream_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkMediaStream *self = GTK_MEDIA_STREAM (object); switch (prop_id) { case PROP_PLAYING: gtk_media_stream_set_playing (self, g_value_get_boolean (value)); break; case PROP_LOOP: gtk_media_stream_set_loop (self, g_value_get_boolean (value)); break; case PROP_MUTED: gtk_media_stream_set_muted (self, g_value_get_boolean (value)); break; case PROP_VOLUME: gtk_media_stream_set_volume (self, g_value_get_double (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gtk_media_stream_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GtkMediaStream *self = GTK_MEDIA_STREAM (object); GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); switch (prop_id) { case PROP_PREPARED: g_value_set_boolean (value, priv->prepared); break; case PROP_ERROR: g_value_set_boxed (value, priv->error); break; case PROP_HAS_AUDIO: g_value_set_boolean (value, priv->has_audio); break; case PROP_HAS_VIDEO: g_value_set_boolean (value, priv->has_video); break; case PROP_PLAYING: g_value_set_boolean (value, priv->playing); break; case PROP_ENDED: g_value_set_boolean (value, priv->ended); break; case PROP_TIMESTAMP: g_value_set_int64 (value, priv->timestamp); break; case PROP_DURATION: g_value_set_int64 (value, priv->duration); break; case PROP_SEEKABLE: g_value_set_boolean (value, priv->seekable); break; case PROP_SEEKING: g_value_set_boolean (value, priv->seeking); break; case PROP_LOOP: g_value_set_boolean (value, priv->loop); break; case PROP_MUTED: g_value_set_boolean (value, priv->muted); break; case PROP_VOLUME: g_value_set_double (value, priv->volume); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gtk_media_stream_dispose (GObject *object) { GtkMediaStream *self = GTK_MEDIA_STREAM (object); GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_clear_error (&priv->error); G_OBJECT_CLASS (gtk_media_stream_parent_class)->dispose (object); } static void gtk_media_stream_finalize (GObject *object) { #if 0 GtkMediaStream *self = GTK_MEDIA_STREAM (object); GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); #endif G_OBJECT_CLASS (gtk_media_stream_parent_class)->finalize (object); } static void gtk_media_stream_class_init (GtkMediaStreamClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS (class); class->play = gtk_media_stream_default_play; class->pause = gtk_media_stream_default_pause; class->seek = gtk_media_stream_default_seek; class->update_audio = gtk_media_stream_default_update_audio; class->realize = gtk_media_stream_default_realize; class->unrealize = gtk_media_stream_default_unrealize; gobject_class->set_property = gtk_media_stream_set_property; gobject_class->get_property = gtk_media_stream_get_property; gobject_class->finalize = gtk_media_stream_finalize; gobject_class->dispose = gtk_media_stream_dispose; /** * GtkMediaStream:prepared: * * Whether the stream has finished initializing and existence of * audio and video is known. */ properties[PROP_PREPARED] = g_param_spec_boolean ("prepared", P_("Prepared"), P_("Whether the stream has finished initializing"), FALSE, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:error: * * %NULL for a properly working stream or the #GError that the stream is in. */ properties[PROP_ERROR] = g_param_spec_boxed ("error", P_("Error"), P_("Error the stream is in"), G_TYPE_ERROR, G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:has-audio: * * Whether the stream contains audio */ properties[PROP_HAS_AUDIO] = g_param_spec_boolean ("has-audio", P_("Has audio"), P_("Whether the stream contains audio"), FALSE, G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:has-video: * * Whether the stream contains video */ properties[PROP_HAS_VIDEO] = g_param_spec_boolean ("has-video", P_("Has video"), P_("Whether the stream contains video"), FALSE, G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:playing: * * Whether the stream is currently playing. */ properties[PROP_PLAYING] = g_param_spec_boolean ("playing", P_("Playing"), P_("Whether the stream is playing"), FALSE, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:ended: * * Set when playback has finished. */ properties[PROP_ENDED] = g_param_spec_boolean ("ended", P_("Ended"), P_("Set when playback has finished"), FALSE, G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:timestamp: * * The current presentation timestamp in microseconds. */ properties[PROP_TIMESTAMP] = g_param_spec_int64 ("timestamp", P_("Timestamp"), P_("Timestamp in microseconds"), 0, G_MAXINT64, 0, G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:duration: * * The stream's duration in microseconds or 0 if unknown. */ properties[PROP_DURATION] = g_param_spec_int64 ("duration", P_("Duration"), P_("Timestamp in microseconds"), 0, G_MAXINT64, 0, G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:seekable: * * Set unless the stream is known to not support seeking. */ properties[PROP_SEEKABLE] = g_param_spec_boolean ("seekable", P_("Seekable"), P_("Set unless seeking is not supported"), TRUE, G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:seeking: * * Set while a seek is in progress. */ properties[PROP_SEEKING] = g_param_spec_boolean ("seeking", P_("Seeking"), P_("Set while a seek is in progress"), FALSE, G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:loop: * * Try to restart the media from the beginning once it ended. */ properties[PROP_LOOP] = g_param_spec_boolean ("loop", P_("Loop"), P_("Try to restart the media from the beginning once it ended."), FALSE, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:muted: * * Whether the audio stream should be muted. */ properties[PROP_MUTED] = g_param_spec_boolean ("muted", P_("Muted"), P_("Whether the audio stream should be muted."), FALSE, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); /** * GtkMediaStream:volume: * * Volume of the audio stream. */ properties[PROP_VOLUME] = g_param_spec_double ("volume", P_("Volume"), P_("Volume of the audio stream."), 0.0, 1.0, 1.0, G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS); g_object_class_install_properties (gobject_class, N_PROPS, properties); } static void gtk_media_stream_init (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); priv->volume = 1.0; } /** * gtk_media_stream_is_prepared: * @self: a #GtkMediaStream * * Returns whether the stream has finished initializing and existence of * audio and video is known. * * Returns: %TRUE if the stream is prepared */ gboolean gtk_media_stream_is_prepared (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->prepared; } /** * gtk_media_stream_has_audio: * @self: a #GtkMediaStream * * Returns whether the stream has audio. * * Returns: %TRUE if the stream has audio */ gboolean gtk_media_stream_has_audio (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->has_audio; } /** * gtk_media_stream_has_video: * @self: a #GtkMediaStream * * Returns whether the stream has video. * * Returns: %TRUE if the stream has video */ gboolean gtk_media_stream_has_video (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->has_video; } /** * gtk_media_stream_play: * @self: a #GtkMediaStream * * Starts playing the stream. If the stream * is in error or already playing, do nothing. */ void gtk_media_stream_play (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); if (priv->error) return; if (priv->playing) return; if (GTK_MEDIA_STREAM_GET_CLASS (self)->play (self)) { g_object_freeze_notify (G_OBJECT (self)); priv->playing = TRUE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PLAYING]); if (priv->ended) { priv->ended = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ENDED]); } g_object_thaw_notify (G_OBJECT (self)); } } /** * gtk_media_stream_pause: * @self: a #GtkMediaStream * * Pauses playback of the stream. If the stream * is not playing, do nothing. */ void gtk_media_stream_pause (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); /* Don't check for error here because we call this function right * after setting the error to pause the stream */ if (!priv->playing) return; GTK_MEDIA_STREAM_GET_CLASS (self)->pause (self); priv->playing = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PLAYING]); } /** * gtk_media_stream_get_playing: * @self: a #GtkMediaStream * * Return whether the stream is currently playing. * * Returns: %TRUE if the stream is playing */ gboolean gtk_media_stream_get_playing (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->playing; } /** * gtk_media_stream_set_playing: * @self: a #GtkMediaStream * @playing: whether to start or pause playback * * Starts or pauses playback of the stream. */ void gtk_media_stream_set_playing (GtkMediaStream *self, gboolean playing) { g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); if (playing) gtk_media_stream_play (self); else gtk_media_stream_pause (self); } /** * gtk_media_stream_get_ended: * @self: a #GtkMediaStream * * Returns whether the streams playback is finished. * * Returns: %TRUE if playback is finished */ gboolean gtk_media_stream_get_ended (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->ended; } /** * gtk_media_stream_get_timestamp: * @self: a #GtkMediaStream * * Returns the current presentation timestamp in microseconds. * * Returns: the timestamp in microseconds */ gint64 gtk_media_stream_get_timestamp (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->timestamp; } /** * gtk_media_stream_get_duration: * @self: a #GtkMediaStream * * Gets the duration of the stream. If the duration is not known, * 0 will be returned. * * Returns: the duration of the stream or 0 if not known. **/ gint64 gtk_media_stream_get_duration (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->duration; } /** * gtk_media_stream_is_seekable: * @self: a #GtkMediaStream * * Checks if a stream may be seekable. * * This is meant to be a hint. Streams may not allow seeking even if * this function returns %TRUE. However, if this function returns * %FALSE, streams are guaranteed to not be seekable and user interfaces * may hide controls that allow seeking. * * It is allowed to call gtk_media_stream_seek() on a non-seekable * stream, though it will not do anything. * * Returns: %TRUE if the stream may support seeking **/ gboolean gtk_media_stream_is_seekable (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->seekable; } /** * gtk_media_stream_is_seeking: * @self: a #GtkMediaStream * * Checks if there is currently a seek operation going on. * * Returns: %TRUE if a seek operation is ongoing. **/ gboolean gtk_media_stream_is_seeking (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->seeking; } /** * gtk_media_stream_get_error: * @self: a #GtkMediaStream * * If the stream is in an error state, returns the #GError explaining that state. * Any type of error can be reported here depending on the implementation of the * media stream. * * A media stream in an error cannot be operated on, calls like * gtk_media_stream_play() or gtk_media_stream_seek() will not have any effect. * * #GtkMediaStream itself does not provide a way to unset an error, but * implementations may provide options. For example, a #GtkMediaFile will unset * errors when a new source is set with ie gtk_media_file_set_file(). * * Returns: (nullable) (transfer none): %NULL if not in an error state or * the #GError of the stream **/ const GError * gtk_media_stream_get_error (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->error; } /** * gtk_media_stream_seek: * @self: a #GtkMediaStream * @timestamp: timestamp to seek to. * * Start a seek operation on @self to @timestamp. If @timestamp is out of range, * it will be clamped. * * Seek operations may not finish instantly. While a seek operation is * in process, the GtkMediaStream:seeking property will be set. * * When calling gtk_media_stream_seek() during an ongoing seek operation, * the new seek will override any pending seek. **/ void gtk_media_stream_seek (GtkMediaStream *self, gint64 timestamp) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); gboolean was_seeking; g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (timestamp >= 0); if (priv->error) return; if (!priv->seekable) return; g_object_freeze_notify (G_OBJECT (self)); was_seeking = priv->seeking; priv->seeking = TRUE; GTK_MEDIA_STREAM_GET_CLASS (self)->seek (self, timestamp); if (was_seeking != priv->seeking) g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SEEKING]); g_object_thaw_notify (G_OBJECT (self)); } /** * gtk_media_stream_get_loop: * @self: a #GtkMediaStream * * Returns whether the stream is set to loop. See * gtk_media_stream_set_loop() for details. * * Returns: %TRUE if the stream should loop **/ gboolean gtk_media_stream_get_loop (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->loop; } /** * gtk_media_stream_set_loop: * @self: a #GtkMediaStream * @loop: %TRUE if the stream should loop * * Sets whether the stream should loop, ie restart playback from * the beginning instead of stopping at the end. * * Not all streams may support looping, in particular non-seekable * streams. Those streams will ignore the loop setting and just end. **/ void gtk_media_stream_set_loop (GtkMediaStream *self, gboolean loop) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); if (priv->loop == loop) return; priv->loop = loop; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_LOOP]); } /** * gtk_media_stream_get_muted: * @self: a #GtkMediaStream * * Returns whether the audio for the stream is muted. * See gtk_media_stream_set_muted() for details. * * Returns: %TRUE if the stream is muted **/ gboolean gtk_media_stream_get_muted (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->muted; } /** * gtk_media_stream_set_muted: * @self: a #GtkMediaStream * @muted: %TRUE if the stream should be muted * * Sets whether the audio stream should be muted. Muting a stream will * cause no audio to be played, but it does not modify the volume. * This means that muting and then unmuting the stream will restore * the volume settings. * * If the stream has no audio, calling this function will still work * but it will not have an audible effect. **/ void gtk_media_stream_set_muted (GtkMediaStream *self, gboolean muted) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); if (priv->muted == muted) return; priv->muted = muted; GTK_MEDIA_STREAM_GET_CLASS (self)->update_audio (self, priv->muted, priv->volume); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_MUTED]); } /** * gtk_media_stream_get_volume: * @self: a #GtkMediaStream * * Returns the volume of the audio for the stream. * See gtk_media_stream_set_volume() for details. * * Returns: volume of the stream from 0.0 to 1.0 **/ double gtk_media_stream_get_volume (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_val_if_fail (GTK_IS_MEDIA_STREAM (self), FALSE); return priv->volume; } /** * gtk_media_stream_set_volume: * @self: a #GtkMediaStream * @volume: New volume of the stream from 0.0 to 1.0 * * Sets the volume of the audio stream. This function call will work even if * the stream is muted. * * The given @volume should range from 0.0 for silence to 1.0 for as loud as * possible. Values outside of this range will be clamped to the nearest * value. * * If the stream has no audio or is muted, calling this function will still * work but it will not have an immediate audible effect. When the stream is * unmuted, the new volume setting will take effect. **/ void gtk_media_stream_set_volume (GtkMediaStream *self, double volume) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); volume = CLAMP (volume, 0.0, 1.0); if (priv->volume == volume) return; priv->volume = volume; GTK_MEDIA_STREAM_GET_CLASS (self)->update_audio (self, priv->muted, priv->volume); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_VOLUME]); } /** * gtk_media_stream_realize: * @self: a #GtkMediaStream * @surface: a #GdkSurface * * Called by users to attach the media stream to a #GdkSurface they manage. * The stream can then access the resources of @surface for its rendering * purposes. In particular, media streams might want to create * #GdkGLContexts or sync to the #GdkFrameClock. * * Whoever calls this function is responsible for calling * gtk_media_stream_unrealize() before either the stream or @surface get * destroyed. * * Multiple calls to this function may happen from different users of the * video, even with the same @surface. Each of these calls must be followed * by its own call to gtk_media_stream_unrealize(). * * It is not required to call this function to make a media stream work. **/ void gtk_media_stream_realize (GtkMediaStream *self, GdkSurface *surface) { g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (GDK_IS_SURFACE (surface)); g_object_ref (self); g_object_ref (surface); GTK_MEDIA_STREAM_GET_CLASS (self)->realize (self, surface); } /** * gtk_media_stream_unrealize: * @self: a #GtkMediaStream previously realized * @surface: the #GdkSurface the stream was realized with * * Undoes a previous call to gtk_media_stream_realize() and causes * the stream to release all resources it had allocated from @surface. **/ void gtk_media_stream_unrealize (GtkMediaStream *self, GdkSurface *surface) { g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (GDK_IS_SURFACE (surface)); GTK_MEDIA_STREAM_GET_CLASS (self)->unrealize (self, surface); g_object_unref (surface); g_object_unref (self); } /** * gtk_media_stream_prepared: * @self: a #GtkMediaStream * @has_audio: %TRUE if the stream should advertise audio support * @has_video: %TRUE if the stream should advertise video support * @seekable: %TRUE if the stream should advertise seekability * @duration: The duration of the stream or 0 if unknown * * Called by #GtkMediaStream implementations to advertise the stream * being ready to play and providing details about the stream. * * Note that the arguments are hints. If the stream implementation * cannot determine the correct values, it is better to err on the * side of caution and return %TRUE. User interfaces will use those * values to determine what controls to show. * * This function may not be called again until the stream has been * reset via gtk_media_stream_unprepared(). **/ void gtk_media_stream_prepared (GtkMediaStream *self, gboolean has_audio, gboolean has_video, gboolean seekable, gint64 duration) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (!gtk_media_stream_is_prepared (self)); g_object_freeze_notify (G_OBJECT (self)); if (priv->has_audio != has_audio) { priv->has_audio = has_audio; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_HAS_AUDIO]); } if (priv->has_video != has_video) { priv->has_video = has_video; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_HAS_VIDEO]); } if (priv->seekable != seekable) { priv->seekable = seekable; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SEEKABLE]); } if (priv->duration != duration) { priv->duration = duration; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DURATION]); } priv->prepared = TRUE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PREPARED]); g_object_thaw_notify (G_OBJECT (self)); } /** * gtk_media_stream_unprepared: * @self: a #GtkMediaStream * * Resets a given media stream implementation. gtk_media_stream_prepared() * can now be called again. * * This function will also reset any error state the stream was in. **/ void gtk_media_stream_unprepared (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (gtk_media_stream_is_prepared (self)); g_object_freeze_notify (G_OBJECT (self)); gtk_media_stream_pause (self); if (priv->has_audio) { priv->has_audio = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_HAS_AUDIO]); } if (priv->has_video) { priv->has_video = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_HAS_VIDEO]); } if (priv->seekable) { priv->seekable = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SEEKABLE]); } if (priv->seeking) { priv->seeking = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SEEKING]); } if (priv->duration != 0) { priv->duration = 0; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DURATION]); } if (priv->timestamp != 0) { priv->timestamp = 0; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TIMESTAMP]); } if (priv->error) { g_clear_error (&priv->error); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ERROR]); } priv->prepared = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PREPARED]); g_object_thaw_notify (G_OBJECT (self)); } /** * gtk_media_stream_gerror: * @self: a #GtkMediaStream * @error: (transfer full): the #GError to set * * Sets @self into an error state. This will pause the stream * (you can check for an error via gtk_media_stream_get_error() in * your GtkMediaStream.pause() implementation), abort pending seeks * and mark the stream as prepared. * * if the stream is already in an error state, this call will be ignored * and the existing error will be retained. * FIXME: Or do we want to set the new error? * * To unset an error, the stream must be reset via a call to * gtk_media_stream_unprepared(). **/ void gtk_media_stream_gerror (GtkMediaStream *self, GError *error) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (error != NULL); if (priv->error) { g_error_free (error); return; } g_object_freeze_notify (G_OBJECT (self)); priv->error = error; gtk_media_stream_pause (self); if (!priv->prepared) { priv->prepared = TRUE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PREPARED]); } if (priv->seeking) gtk_media_stream_seek_failed (self); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ERROR]); g_object_thaw_notify (G_OBJECT (self)); } /** * gtk_media_stream_error: * @self: a #GtkMediaStream * @domain: error domain * @code: error code * @format: printf()-style format for error message * @...: parameters for message format * * Sets @self into an error state using a printf()-style format string. * * This is a utility function that calls gtk_media_stream_gerror(). See * that function for details. **/ void gtk_media_stream_error (GtkMediaStream *self, GQuark domain, int code, const char *format, ...) { GError *error; va_list args; g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (domain != 0); g_return_if_fail (format != NULL); va_start (args, format); error = g_error_new_valist (domain, code, format, args); va_end (args); gtk_media_stream_gerror (self, error); } /** * gtk_media_stream_error_valist: * @self: a #GtkMediaStream * @domain: error domain * @code: error code * @format: printf()-style format for error message * @args: #va_list of parameters for the message format * * Sets @self into an error state using a printf()-style format string. * * This is a utility function that calls gtk_media_stream_gerror(). See * that function for details. */ void gtk_media_stream_error_valist (GtkMediaStream *self, GQuark domain, int code, const char *format, va_list args) { GError *error; g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (domain != 0); g_return_if_fail (format != NULL); error = g_error_new_valist (domain, code, format, args); gtk_media_stream_gerror (self, error); } /** * gtk_media_stream_update: * @self: a #GtkMediaStream * @timestamp: the new timestamp * * Media stream implementations should regularly call this function to * update the timestamp reported by the stream. It is up to * implementations to call this at the frequency they deem appropriate. **/ void gtk_media_stream_update (GtkMediaStream *self, gint64 timestamp) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_object_freeze_notify (G_OBJECT (self)); /* Timestamp before duration is important here. * This way the duration notify will be emitted first which will * make GtkMediaControls update adjustment->upper so that the * timestamp notify will cause the timestamp to not be clamped. */ if (priv->timestamp != timestamp) { priv->timestamp = timestamp; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TIMESTAMP]); } if (priv->duration > 0 && timestamp > priv->duration) { priv->duration = priv->timestamp; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DURATION]); } g_object_thaw_notify (G_OBJECT (self)); } /** * gtk_media_stream_ended: * @self: a #GtkMediaStream * * Pauses the media stream and marks it as ended. This is a hint only, calls * to GtkMediaStream.play() may still happen. **/ void gtk_media_stream_ended (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (!gtk_media_stream_get_ended (self)); g_object_freeze_notify (G_OBJECT (self)); gtk_media_stream_pause (self); priv->ended = TRUE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ENDED]); g_object_thaw_notify (G_OBJECT (self)); } /** * gtk_media_stream_seek_success: * @self: a #GtkMediaStream * * Ends a seek operation started via GtkMediaStream.seek() successfully. * This function will unset the GtkMediaStream:ended property if it was * set. * * See gtk_media_stream_seek_failed() for the other way of * ending a seek. **/ void gtk_media_stream_seek_success (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (gtk_media_stream_is_seeking (self)); g_object_freeze_notify (G_OBJECT (self)); priv->seeking = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SEEKING]); if (priv->ended) { priv->ended = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ENDED]); } g_object_thaw_notify (G_OBJECT (self)); } /** * gtk_media_stream_seek_failed: * @self: a #GtkMediaStream * * Ends a seek operation started via GtkMediaStream.seek() as a failure. * This will not cause an error on the stream and will assume that * playback continues as if no seek had happened. * * See gtk_media_stream_seek_success() for the other way of * ending a seek. **/ void gtk_media_stream_seek_failed (GtkMediaStream *self) { GtkMediaStreamPrivate *priv = gtk_media_stream_get_instance_private (self); g_return_if_fail (GTK_IS_MEDIA_STREAM (self)); g_return_if_fail (gtk_media_stream_is_seeking (self)); priv->seeking = FALSE; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SEEKING]); }