gstreamer/subprojects/gst-plugins-bad/gst-libs/gst/mse/gstmediasource.c

/* GStreamer
 *
 * SPDX-License-Identifier: LGPL-2.1
 *
 * Copyright (C) 2013 Google Inc. All rights reserved.
 * Copyright (C) 2013 Orange
 * Copyright (C) 2013-2017 Apple Inc. All rights reserved.
 * Copyright (C) 2014 Sebastian Dröge <sebastian@centricular.com>
 * Copyright (C) 2015, 2016 Igalia, S.L
 * Copyright (C) 2015, 2016 Metrological Group B.V.
 * Copyright (C) 2022, 2023 Collabora Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

/**
 * SECTION:gstmediasource
 * @title: GstMediaSource
 * @short_description: Media Source
 * @symbols:
 * - GstMediaSource
 *
 * #GstMediaSource is the entry point into the W3C Media Source API. It offers
 * functionality similar to #GstAppSrc for client-side web or JavaScript
 * applications decoupling the source of media from its processing and playback.
 *
 * To interact with a Media Source, connect it to a #GstMseSrc that is in some
 * #GstPipeline using gst_media_source_attach(). Then create at least one
 * #GstSourceBuffer using gst_media_source_add_source_buffer(). Finally, feed
 * some media data to the Source Buffer(s) using
 * gst_source_buffer_append_buffer() and play the pipeline.
 *
 * Since: 1.24
 */

/**
 * GstMediaSource:
 * Since: 1.24
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <gst/mse/mse-enumtypes.h>
#include "gstmediasource.h"
#include "gstmediasource-private.h"

#include "gstmselogging-private.h"
#include "gstmsemediatype-private.h"
#include "gstsourcebuffer-private.h"
#include "gstsourcebufferlist-private.h"

#include "gstmsesrc.h"
#include "gstmsesrc-private.h"

G_DEFINE_TYPE (GstMediaSource, gst_media_source, GST_TYPE_OBJECT);
G_DEFINE_QUARK (gst_media_source_error_quark, gst_media_source_error);

enum
{
  PROP_0,

  PROP_SOURCE_BUFFERS,
  PROP_ACTIVE_SOURCE_BUFFERS,
  PROP_READY_STATE,
  PROP_POSITION,
  PROP_DURATION,

  N_PROPS,
};

typedef enum
{
  ON_SOURCE_OPEN,
  ON_SOURCE_ENDED,
  ON_SOURCE_CLOSE,

  N_SIGNALS,
} MediaSourceEvent;

typedef struct
{
  GstDataQueueItem item;
  MediaSourceEvent event;
} MediaSourceEventItem;

static GParamSpec *properties[N_PROPS];
static guint signals[N_SIGNALS];

#define DEFAULT_READY_STATE GST_MEDIA_SOURCE_READY_STATE_CLOSED
#define DEFAULT_POSITION    GST_CLOCK_TIME_NONE
#define DEFAULT_DURATION    GST_CLOCK_TIME_NONE

static void rebuild_active_source_buffers (GstMediaSource * self);

/**
 * gst_media_source_is_type_supported:
 * @type: (transfer none): A MIME type value
 *
 * Determines whether the current Media Source configuration can process media
 * of the supplied @type.
 *
 * Returns: `TRUE` when supported, `FALSE` otherwise
 *
 * Since: 1.24
 */
gboolean
gst_media_source_is_type_supported (const gchar * type)
{
  gst_mse_init_logging ();
  g_return_val_if_fail (type != NULL, FALSE);

  if (g_strcmp0 (type, "") == 0) {
    return FALSE;
  }

  GstMediaSourceMediaType media_type = GST_MEDIA_SOURCE_MEDIA_TYPE_INIT;
  if (!gst_media_source_media_type_parse (&media_type, type)) {
    return FALSE;
  }

  gboolean supported = gst_media_source_media_type_is_supported (&media_type);

  gst_media_source_media_type_reset (&media_type);

  return supported;
}

/**
 * gst_media_source_new:
 *
 * Creates a new #GstMediaSource instance. The instance is in the
 * %GST_MEDIA_SOURCE_READY_STATE_CLOSED state and is not associated with any
 * media player.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-constructor)
 *
 * Returns: (transfer full): a new #GstMediaSource instance
 * Since: 1.24
 */
GstMediaSource *
gst_media_source_new (void)
{
  gst_mse_init_logging ();
  return g_object_ref_sink (g_object_new (GST_TYPE_MEDIA_SOURCE, NULL));
}

static inline void
empty_buffers (GstMediaSource * self)
{
  for (guint i = 0;; i++) {
    GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i);
    if (buf == NULL) {
      break;
    }
    gst_object_unparent (GST_OBJECT_CAST (buf));
    gst_object_unref (buf);
  }
  gst_source_buffer_list_remove_all (self->buffers);
}

static void
gst_media_source_dispose (GObject * object)
{
  GstMediaSource *self = (GstMediaSource *) object;

  gst_media_source_detach (self);

  g_clear_object (&self->active_buffers);

  if (self->buffers) {
    empty_buffers (self);
  }
  gst_clear_object (&self->buffers);

  gst_clear_object (&self->event_queue);

  G_OBJECT_CLASS (gst_media_source_parent_class)->dispose (object);
}

static void
gst_media_source_get_property (GObject * object, guint prop_id, GValue * value,
    GParamSpec * pspec)
{
  GstMediaSource *self = GST_MEDIA_SOURCE (object);

  switch (prop_id) {
    case PROP_SOURCE_BUFFERS:
      g_value_take_object (value, gst_media_source_get_source_buffers (self));
      break;
    case PROP_ACTIVE_SOURCE_BUFFERS:
      g_value_take_object (value,
          gst_media_source_get_active_source_buffers (self));
      break;
    case PROP_READY_STATE:
      g_value_set_enum (value, gst_media_source_get_ready_state (self));
      break;
    case PROP_POSITION:
      g_value_set_uint64 (value, gst_media_source_get_position (self));
      break;
    case PROP_DURATION:
      g_value_set_uint64 (value, gst_media_source_get_duration (self));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  }
}

static void
gst_media_source_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstMediaSource *self = GST_MEDIA_SOURCE (object);

  switch (prop_id) {
    case PROP_DURATION:{
      GstClockTime duration = (GstClockTime) g_value_get_uint64 (value);
      gst_media_source_set_duration (self, duration, NULL);
      break;
    }
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  }
}

static void
gst_media_source_class_init (GstMediaSourceClass * klass)
{
  GObjectClass *oclass = G_OBJECT_CLASS (klass);

  oclass->dispose = GST_DEBUG_FUNCPTR (gst_media_source_dispose);
  oclass->get_property = GST_DEBUG_FUNCPTR (gst_media_source_get_property);
  oclass->set_property = GST_DEBUG_FUNCPTR (gst_media_source_set_property);

  /**
   * GstMediaSource:source-buffers:
   *
   * A #GstSourceBufferList of every #GstSourceBuffer in this Media Source
   *
   * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-sourcebuffers)
   *
   * Since: 1.24
   */
  properties[PROP_SOURCE_BUFFERS] = g_param_spec_object ("source-buffers",
      "Source Buffers",
      "A SourceBufferList of all SourceBuffers in this Media Source",
      GST_TYPE_SOURCE_BUFFER_LIST, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

  /**
   * GstMediaSource:active-source-buffers:
   *
   * A #GstSourceBufferList of every #GstSourceBuffer in this Media Source that
   * is considered active
   *
   * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-activesourcebuffers)
   *
   * Since: 1.24
   */
  properties[PROP_ACTIVE_SOURCE_BUFFERS] =
      g_param_spec_object ("active-source-buffers", "Active Source Buffers",
      "A SourceBufferList of all SourceBuffers that are active in this Media Source",
      GST_TYPE_SOURCE_BUFFER_LIST, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

  /**
   * GstMediaSource:ready-state:
   *
   * The Ready State of the Media Source
   *
   * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-readystate)
   *
   * Since: 1.24
   */
  properties[PROP_READY_STATE] = g_param_spec_enum ("ready-state",
      "Ready State",
      "The Ready State of the Media Source",
      GST_TYPE_MEDIA_SOURCE_READY_STATE, DEFAULT_READY_STATE, G_PARAM_READABLE |
      G_PARAM_STATIC_STRINGS);

  /**
   * GstMediaSource:position:
   *
   * The position of the player consuming from the Media Source
   *
   * Since: 1.24
   */
  properties[PROP_POSITION] = g_param_spec_uint64 ("position",
      "Position",
      "The Position of the Media Source as a GstClockTime",
      GST_CLOCK_TIME_NONE, G_MAXUINT64, DEFAULT_DURATION, G_PARAM_READWRITE |
      G_PARAM_STATIC_STRINGS);

  /**
   * GstMediaSource:duration:
   *
   * The Duration of the Media Source as a #GstClockTime
   *
   * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-duration)
   *
   * Since: 1.24
   */
  properties[PROP_DURATION] = g_param_spec_uint64 ("duration",
      "Duration",
      "The Duration of the Media Source as a GstClockTime",
      GST_CLOCK_TIME_NONE, G_MAXUINT64, DEFAULT_DURATION, G_PARAM_READWRITE |
      G_PARAM_STATIC_STRINGS);

  g_object_class_install_properties (oclass, N_PROPS, properties);

  /**
   * GstMediaSource::on-source-open:
   * @self: The #GstMediaSource that has just opened
   *
   * Emitted when @self has been opened.
   *
   * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-onsourceopen)
   *
   * Since: 1.24
   */
  signals[ON_SOURCE_OPEN] = g_signal_new ("on-source-open",
      G_TYPE_FROM_CLASS (klass),
      G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);

  /**
   * GstMediaSource::on-source-ended:
   * @self: The #GstMediaSource that has just ended
   *
   * Emitted when @self has ended, normally through
   * gst_media_source_end_of_stream().
   *
   * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-onsourceended)
   *
   * Since: 1.24
   */
  signals[ON_SOURCE_ENDED] = g_signal_new ("on-source-ended",
      G_TYPE_FROM_CLASS (klass),
      G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);

  /**
   * GstMediaSource::on-source-closed:
   * @self: The #GstMediaSource that has just closed
   *
   * Emitted when @self has closed, normally when detached from a #GstMseSrc.
   *
   * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-onsourceclose)
   *
   * Since: 1.24
   */
  signals[ON_SOURCE_CLOSE] = g_signal_new ("on-source-close",
      G_TYPE_FROM_CLASS (klass),
      G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);

}

static inline void
reset_live_seekable_range (GstMediaSource * self)
{
  self->live_seekable_range.start = 0;
  self->live_seekable_range.end = 0;
}

static inline gboolean
is_updating (GstMediaSource * self)
{
  for (guint i = 0;; i++) {
    GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i);
    if (buf == NULL)
      break;
    gboolean updating = gst_source_buffer_get_updating (buf);
    gst_object_unref (buf);
    if (updating) {
      return TRUE;
    }
  }
  return FALSE;
}

static inline gboolean
is_attached (GstMediaSource * self)
{
  return GST_IS_MSE_SRC (self->element);
}

static inline void
network_error (GstMediaSource * self)
{
  if (is_attached (self)) {
    gst_mse_src_network_error (self->element);
  }
}

static inline void
decode_error (GstMediaSource * self)
{
  if (is_attached (self)) {
    gst_mse_src_decode_error (self->element);
  }
}

static inline void
update_duration (GstMediaSource * self)
{
  if (is_attached (self)) {
    gst_mse_src_set_duration (self->element, self->duration);
  }
}

static void
schedule_event (GstMediaSource * self, MediaSourceEvent event)
{
  MediaSourceEventItem item = {
    .item = {.destroy = g_free,.visible = TRUE,.size = 1,.object = NULL},
    .event = event,
  };

  gst_mse_event_queue_push (self->event_queue, g_memdup2 (&item,
          sizeof (MediaSourceEventItem)));
}

static void
dispatch_event (MediaSourceEventItem * item, GstMediaSource * self)
{
  g_signal_emit (self, signals[item->event], 0);
}

static void
gst_media_source_init (GstMediaSource * self)
{
  self->buffers = gst_source_buffer_list_new ();
  self->active_buffers = gst_source_buffer_list_new ();
  self->ready_state = DEFAULT_READY_STATE;
  self->duration = DEFAULT_DURATION;
  reset_live_seekable_range (self);
  self->element = NULL;
  self->event_queue =
      gst_mse_event_queue_new ((GstMseEventQueueCallback) dispatch_event, self);
}

/**
 * gst_media_source_attach:
 * @self: #GstMediaSource instance
 * @element: (transfer none): #GstMseSrc source Element
 *
 * Associates @self with @element.
 * Normally, the Element will be part of a #GstPipeline that plays back the data
 * submitted to the Media Source's Source Buffers.
 *
 * #GstMseSrc is a special source element that is designed to consume media from
 * a #GstMediaSource.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dfn-attaching-to-a-media-element)
 *
 * Since: 1.24
 */
void
gst_media_source_attach (GstMediaSource * self, GstMseSrc * element)
{
  g_return_if_fail (GST_IS_MEDIA_SOURCE (self));
  g_return_if_fail (GST_IS_MSE_SRC (element));

  if (is_attached (self))
    gst_media_source_detach (self);

  self->element = gst_object_ref_sink (element);
  gst_mse_src_attach (element, self);

  self->ready_state = GST_MEDIA_SOURCE_READY_STATE_OPEN;
  schedule_event (self, ON_SOURCE_OPEN);
}

/**
 * gst_media_source_detach:
 * @self: #GstMediaSource instance
 *
 * Detaches @self from any #GstMseSrc element that it may be associated with.
 *
 * Since: 1.24
 */
void
gst_media_source_detach (GstMediaSource * self)
{
  g_return_if_fail (GST_IS_MEDIA_SOURCE (self));

  self->ready_state = GST_MEDIA_SOURCE_READY_STATE_CLOSED;
  gst_media_source_set_duration (self, GST_CLOCK_TIME_NONE, NULL);

  gst_source_buffer_list_remove_all (self->active_buffers);
  empty_buffers (self);

  if (is_attached (self)) {
    gst_mse_src_detach (self->element);
    gst_clear_object (&self->element);
  }

  schedule_event (self, ON_SOURCE_CLOSE);
}

/**
 * gst_media_source_get_source_element:
 * @self: #GstMediaSource instance
 *
 * Gets the #GstMseSrc currently attached to @self or `NULL` if there is none.
 *
 * Returns: (transfer full) (nullable): a #GstMseSrc instance or `NULL`
 */
GstMseSrc *
gst_media_source_get_source_element (GstMediaSource * self)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), NULL);
  GST_OBJECT_LOCK (self);
  GstMseSrc *element = self->element == NULL ? NULL
      : gst_object_ref (self->element);
  GST_OBJECT_UNLOCK (self);
  return element;
}

void
gst_media_source_open (GstMediaSource * self)
{
  g_return_if_fail (GST_IS_MEDIA_SOURCE (self));
  if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) {
    self->ready_state = GST_MEDIA_SOURCE_READY_STATE_OPEN;
    schedule_event (self, ON_SOURCE_OPEN);
  }
}

/**
 * gst_media_source_get_source_buffers:
 * @self: #GstMediaSource instance
 *
 * Gets a #GstSourceBufferList containing all the Source Buffers currently
 * associated with this Media Source. This object will reflect any future
 * changes to the parent Media Source as well.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-sourcebuffers)
 *
 * Returns: (transfer full): a #GstSourceBufferList instance
 * Since: 1.24
 */
GstSourceBufferList *
gst_media_source_get_source_buffers (GstMediaSource * self)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), NULL);
  return g_object_ref (self->buffers);
}

/**
 * gst_media_source_get_active_source_buffers:
 * @self: #GstMediaSource instance
 *
 * Gets a #GstSourceBufferList containing all the Source Buffers currently
 * associated with this Media Source that are considered "active."
 * For a Source Buffer to be considered active, either its video track is
 * selected, its audio track is enabled, or its text track is visible or hidden.
 * This object will reflect any future changes to the parent Media Source as
 * well.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-activesourcebuffers)
 *
 * Returns: (transfer full): a new #GstSourceBufferList instance
 * Since: 1.24
 */
GstSourceBufferList *
gst_media_source_get_active_source_buffers (GstMediaSource * self)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), NULL);
  return g_object_ref (self->active_buffers);
}

/**
 * gst_media_source_get_ready_state:
 * @self: #GstMediaSource instance
 *
 * Gets the current Ready State of the Media Source.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-readystate)
 *
 * Returns: the current #GstMediaSourceReadyState value
 * Since: 1.24
 */
GstMediaSourceReadyState
gst_media_source_get_ready_state (GstMediaSource * self)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), DEFAULT_READY_STATE);
  return self->ready_state;
}

/**
 * gst_media_source_get_position:
 * @self: #GstMediaSource instance
 *
 * Gets the current playback position of the Media Source.
 *
 * Returns: the current playback position as a #GstClockTime
 * Since: 1.24
 */
GstClockTime
gst_media_source_get_position (GstMediaSource * self)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), DEFAULT_POSITION);
  if (is_attached (self))
    return gst_mse_src_get_position (self->element);
  return DEFAULT_POSITION;
}

/**
 * gst_media_source_get_duration:
 * @self: #GstMediaSource instance
 *
 * Gets the current duration of @self.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-duration)
 *
 * Returns: the current duration as a #GstClockTime
 * Since: 1.24
 */
GstClockTime
gst_media_source_get_duration (GstMediaSource * self)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), DEFAULT_DURATION);
  if (self->ready_state == GST_MEDIA_SOURCE_READY_STATE_CLOSED)
    return GST_CLOCK_TIME_NONE;
  return self->duration;
}

/**
 * gst_media_source_set_duration:
 * @self: #GstMediaSource instance
 * @duration: The new duration to apply to @self.
 * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL`
 *
 * Sets the duration of @self.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-duration)
 *
 * Returns: `TRUE` on success, `FALSE` otherwise
 * Since: 1.24
 */
gboolean
gst_media_source_set_duration (GstMediaSource * self, GstClockTime duration,
    GError ** error)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE);
  self->duration = duration;
  update_duration (self);
  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DURATION]);
  return TRUE;
}

static void
on_received_init_segment (G_GNUC_UNUSED GstSourceBuffer * source_buffer,
    gpointer user_data)
{
  GstMediaSource *self = GST_MEDIA_SOURCE (user_data);
  if (!is_attached (self)) {
    GST_DEBUG_OBJECT (self, "received init segment while detached, ignoring");
    return;
  }

  GPtrArray *all_tracks = g_ptr_array_new ();

  for (guint i = 0;; i++) {
    GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i);
    if (buf == NULL) {
      break;
    }
    GPtrArray *tracks = gst_source_buffer_get_all_tracks (buf);
    g_ptr_array_extend (all_tracks, tracks, NULL, NULL);
    g_ptr_array_unref (tracks);
    gst_object_unref (buf);
  }

  gst_mse_src_emit_streams (self->element,
      (GstMediaSourceTrack **) all_tracks->pdata, all_tracks->len);

  g_ptr_array_unref (all_tracks);
}

static void
on_duration_changed (G_GNUC_UNUSED GstSourceBuffer * source_buffer,
    gpointer user_data)
{
  GstMediaSource *self = GST_MEDIA_SOURCE (user_data);
  GstClockTime current = self->duration;
  GstClockTime max = 0;
  for (guint i = 0;; i++) {
    GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i);
    if (buf == NULL) {
      break;
    }
    GstClockTime duration = gst_source_buffer_get_duration (buf);
    if (GST_CLOCK_TIME_IS_VALID (duration)) {
      max = MAX (max, duration);
    }
    gst_object_unref (buf);
  }
  if (current == max) {
    return;
  }
  GST_DEBUG_OBJECT (self, "updating %" GST_TIMEP_FORMAT "=>%" GST_TIMEP_FORMAT,
      &current, &max);
  gst_media_source_set_duration (self, max, NULL);
}

static GHashTable *
source_buffer_list_as_set (GstSourceBufferList * list)
{
  GHashTable *buffers = g_hash_table_new_full (g_direct_hash, g_direct_equal,
      gst_object_unref, NULL);
  for (guint i = 0;; i++) {
    GstSourceBuffer *buf = gst_source_buffer_list_index (list, i);
    if (buf == NULL) {
      break;
    }
    g_hash_table_add (buffers, buf);
  }
  return buffers;
}

static void
rebuild_active_source_buffers (GstMediaSource * self)
{
  // TODO: Lock the source buffer lists
  GST_DEBUG_OBJECT (self, "rebuilding active source buffers");
  GHashTable *previously_active =
      source_buffer_list_as_set (self->active_buffers);

  gst_source_buffer_list_notify_freeze (self->active_buffers);
  gst_source_buffer_list_remove_all (self->active_buffers);

  gboolean added = FALSE;
  gboolean removed = FALSE;

  for (guint i = 0;; i++) {
    GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i);
    if (buf == NULL) {
      break;
    }
    if (gst_source_buffer_get_active (buf)) {
      gst_source_buffer_list_append (self->active_buffers, buf);
      added |= !g_hash_table_contains (previously_active, buf);
    } else {
      gst_source_buffer_list_append (self->active_buffers, buf);
      removed |= g_hash_table_contains (previously_active, buf);
    }
    gst_object_unref (buf);
  }
  g_hash_table_unref (previously_active);

  gst_source_buffer_list_notify_cancel (self->active_buffers);
  gst_source_buffer_list_notify_thaw (self->active_buffers);

  if (added) {
    GST_DEBUG_OBJECT (self, "notifying active source buffer added");
    gst_source_buffer_list_notify_added (self->active_buffers);
  }
  if (removed) {
    GST_DEBUG_OBJECT (self, "notifying active source buffer removed");
    gst_source_buffer_list_notify_removed (self->active_buffers);
  }
}

static void
on_active_state_changed (GstSourceBuffer * source_buffer, gpointer user_data)
{
  GstMediaSource *self = GST_MEDIA_SOURCE (user_data);
  rebuild_active_source_buffers (self);
}

/**
 * gst_media_source_add_source_buffer:
 * @self: #GstMediaSource instance
 * @type: (transfer none): A MIME type describing the format of the incoming media
 * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL`
 *
 * Add a #GstSourceBuffer to this #GstMediaSource of the specified media type.
 * The Media Source must be in the #GstMediaSourceReadyState %GST_MEDIA_SOURCE_READY_STATE_OPEN.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-addsourcebuffer)
 *
 * Returns: (transfer full): a new #GstSourceBuffer instance on success, otherwise `NULL`
 * Since: 1.24
 */
GstSourceBuffer *
gst_media_source_add_source_buffer (GstMediaSource * self, const gchar * type,
    GError ** error)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), NULL);
  g_return_val_if_fail (type != NULL, NULL);

  if (g_strcmp0 (type, "") == 0) {
    g_set_error (error,
        GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE,
        "supplied content type is empty");
    return NULL;
  }

  if (!gst_media_source_is_type_supported (type)) {
    g_set_error (error,
        GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED,
        "unsupported content type");
    return NULL;
  }

  if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) {
    g_set_error (error,
        GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE,
        "media source is not open");
    return NULL;
  }

  GstSourceBufferCallbacks callbacks = {
    .duration_changed = on_duration_changed,
    .received_init_segment = on_received_init_segment,
    .active_state_changed = on_active_state_changed,
  };

  GError *source_buffer_error = NULL;
  GstSourceBuffer *buf = gst_source_buffer_new_with_callbacks (type,
      GST_OBJECT (self), &callbacks, self, &source_buffer_error);
  if (source_buffer_error) {
    g_propagate_prefixed_error (error, source_buffer_error,
        "failed to create source buffer");
    gst_clear_object (&buf);
    return NULL;
  }

  gst_source_buffer_list_append (self->buffers, buf);

  return buf;
}

/**
 * gst_media_source_remove_source_buffer:
 * @self: #GstMediaSource instance
 * @buffer: (transfer none): #GstSourceBuffer instance
 * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL`
 *
 * Remove @buffer from @self.
 *
 * @buffer must have been created as a child of @self and @self must be in the
 * #GstMediaSourceReadyState %GST_MEDIA_SOURCE_READY_STATE_OPEN.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-removesourcebuffer)
 *
 * Returns: `TRUE` on success, `FALSE` otherwise
 * Since: 1.24
 */
gboolean
gst_media_source_remove_source_buffer (GstMediaSource * self,
    GstSourceBuffer * buffer, GError ** error)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE);
  g_return_val_if_fail (GST_IS_SOURCE_BUFFER (buffer), FALSE);

  if (!gst_source_buffer_list_contains (self->buffers, buffer)) {
    g_set_error (error,
        GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_NOT_FOUND,
        "the supplied source buffer was not found in this media source");
    return FALSE;
  }

  if (gst_source_buffer_get_updating (buffer))
    gst_source_buffer_teardown (buffer);

  gst_source_buffer_list_remove (self->active_buffers, buffer);

  gst_object_unparent (GST_OBJECT (buffer));
  gst_source_buffer_list_remove (self->buffers, buffer);

  return TRUE;
}

static void
abort_all_source_buffers (GstMediaSource * self)
{
  for (guint i = 0;; i++) {
    GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i);
    if (buf == NULL) {
      return;
    }
    GST_LOG_OBJECT (self, "shutting down %" GST_PTR_FORMAT, buf);
    gst_source_buffer_abort (buf, NULL);
    gst_object_unref (buf);
  }
}

/**
 * gst_media_source_end_of_stream:
 * @self: #GstMediaSource instance
 * @eos_error: The error type, if any
 * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL`
 *
 * Mark @self as reaching the end of stream, disallowing new data inputs.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-endofstream)
 *
 * Returns: `TRUE` on success, `FALSE` otherwise
 * Since: 1.24
 */
gboolean
gst_media_source_end_of_stream (GstMediaSource * self,
    GstMediaSourceEOSError eos_error, GError ** error)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE);

  if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) {
    g_set_error (error,
        GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE,
        "media source is not open");
    return FALSE;
  }

  if (is_updating (self)) {
    g_set_error (error,
        GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE,
        "some buffers are still updating");
    return FALSE;
  }

  self->ready_state = GST_MEDIA_SOURCE_READY_STATE_ENDED;
  schedule_event (self, ON_SOURCE_ENDED);

  switch (eos_error) {
    case GST_MEDIA_SOURCE_EOS_ERROR_NETWORK:
      network_error (self);
      break;
    case GST_MEDIA_SOURCE_EOS_ERROR_DECODE:
      decode_error (self);
      break;
    default:
      update_duration (self);
      abort_all_source_buffers (self);
      break;
  }

  return TRUE;
}

/**
 * gst_media_source_set_live_seekable_range:
 * @self: #GstMediaSource instance
 * @start: The earliest point in the stream considered seekable
 * @end: The latest point in the stream considered seekable
 * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL`
 *
 * Set the live seekable range for @self. This range informs the component
 * playing this Media Source what it can allow the user to seek through.
 *
 * If the ready state is not %GST_MEDIA_SOURCE_READY_STATE_OPEN, or the supplied
 * @start time is later than @end it will fail and set an error.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-setliveseekablerange)
 *
 * Returns: `TRUE` on success, `FALSE` otherwise
 * Since: 1.24
 */
gboolean
gst_media_source_set_live_seekable_range (GstMediaSource * self,
    GstClockTime start, GstClockTime end, GError ** error)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE);
  if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) {
    g_set_error (error,
        GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE,
        "media source is not open");
    return FALSE;
  }

  if (start > end) {
    g_set_error (error,
        GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE,
        "bad time range: start must be earlier than end");
    return FALSE;
  }

  self->live_seekable_range.start = start;
  self->live_seekable_range.end = end;

  return TRUE;
}

/**
 * gst_media_source_clear_live_seekable_range:
 * @self: #GstMediaSource instance
 * @error: (out) (optional) (nullable) (transfer full): the resulting error or `NULL`
 *
 * Clear the live seekable range for @self. This will inform the component
 * playing this Media Source that there is no seekable time range.
 *
 * If the ready state is not %GST_MEDIA_SOURCE_READY_STATE_OPEN, it will fail
 * and set an error.
 *
 * [Specification](https://www.w3.org/TR/media-source-2/#dom-mediasource-clearliveseekablerange)
 *
 * Returns: `TRUE` on success, `FALSE` otherwise
 * Since: 1.24
 */
gboolean
gst_media_source_clear_live_seekable_range (GstMediaSource * self,
    GError ** error)
{
  g_return_val_if_fail (GST_IS_MEDIA_SOURCE (self), FALSE);

  if (self->ready_state != GST_MEDIA_SOURCE_READY_STATE_OPEN) {
    g_set_error (error,
        GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_INVALID_STATE,
        "media source is not open");
    return FALSE;
  }

  reset_live_seekable_range (self);

  return TRUE;
}

/**
 * gst_media_source_get_live_seekable_range:
 * @self: #GstMediaSource instance
 * @range: (out) (transfer none): time range
 *
 * Get the live seekable range of @self. Will fill in the supplied @range with
 * the current live seekable range.
 *
 * Since: 1.24
 */
void
gst_media_source_get_live_seekable_range (GstMediaSource * self,
    GstMediaSourceRange * range)
{
  g_return_if_fail (GST_IS_MEDIA_SOURCE (self));
  g_return_if_fail (range != NULL);

  range->start = self->live_seekable_range.start;
  range->end = self->live_seekable_range.end;
}

void
gst_media_source_seek (GstMediaSource * self, GstClockTime time)
{
  g_return_if_fail (GST_IS_MEDIA_SOURCE (self));
  for (guint i = 0;; i++) {
    GstSourceBuffer *buf = gst_source_buffer_list_index (self->buffers, i);
    if (buf == NULL) {
      return;
    }
    gst_source_buffer_seek (buf, time);
    gst_object_unref (buf);
  }
}