/* OGG muxer plugin for GStreamer

 * Copyright (C) 2004 Wim Taymans <wim@fluendo.com>

 * Copyright (C) 2006 Thomas Vander Stichele <thomas at apestaart dot org>

 *

 * 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:element-oggmux

 * @title: oggmux

 * @see_also: <link linkend="gst-plugins-base-plugins-oggdemux">oggdemux</link>

 *

 * This element merges streams (audio and video) into ogg files.

 *

 * ## Example pipelines

 * |[

 * gst-launch-1.0 v4l2src num-buffers=500 ! video/x-raw,width=320,height=240 ! videoconvert ! videorate ! theoraenc ! oggmux ! filesink location=video.ogg

 * ]|

 * Encodes a video stream captured from a v4l2-compatible camera to Ogg/Theora

 * (the encoding will stop automatically after 500 frames)

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/gst.h>

#include <gst/base/gstbytewriter.h>

#include <gst/audio/audio.h>

#include <gst/tag/tag.h>

#include "gstoggmux.h"

/* memcpy - if someone knows a way to get rid of it, please speak up

 * note: the ogg docs even say you need this... */

#include <string.h>

#include <time.h>

#include <stdlib.h>             /* rand, srand, atoi */

GST_DEBUG_CATEGORY_STATIC (gst_ogg_mux_debug);

#define GST_CAT_DEFAULT gst_ogg_mux_debug

/* This isn't generally what you'd want with an end-time macro, because

   technically the end time of a buffer with invalid duration is invalid. But

   for sorting ogg pages this is what we want. */

#define GST_BUFFER_END_TIME(buf) \

    (GST_BUFFER_DURATION_IS_VALID (buf) \

    ? GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf) \

    : GST_BUFFER_TIMESTAMP (buf))

#define GST_GP_FORMAT "[gp %8" G_GINT64_FORMAT "]"

#define GST_GP_CAST(_gp) ((gint64) _gp)

/* set to 0.5 seconds by default */

#define DEFAULT_MAX_DELAY       G_GINT64_CONSTANT(500000000)

#define DEFAULT_MAX_PAGE_DELAY  G_GINT64_CONSTANT(500000000)

#define DEFAULT_MAX_TOLERANCE   G_GINT64_CONSTANT(40000000)

#define DEFAULT_SKELETON        FALSE

enum

{

  ARG_0,

  ARG_MAX_DELAY,

  ARG_MAX_PAGE_DELAY,

  ARG_MAX_TOLERANCE,

  ARG_SKELETON

};

static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("application/ogg; audio/ogg; video/ogg")

    );

static GstStaticPadTemplate video_sink_factory =

    GST_STATIC_PAD_TEMPLATE ("video_%u",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS ("video/x-theora; "

        "application/x-ogm-video; video/x-dirac; "

        "video/x-smoke; video/x-vp8; video/x-daala")

    );

static GstStaticPadTemplate audio_sink_factory =

    GST_STATIC_PAD_TEMPLATE ("audio_%u",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS

    ("audio/x-vorbis; audio/x-flac; audio/x-speex; audio/x-celt; "

        "application/x-ogm-audio; audio/x-opus")

    );

static GstStaticPadTemplate subtitle_sink_factory =

    GST_STATIC_PAD_TEMPLATE ("subtitle_%u",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS ("text/x-cmml, encoded = (boolean) TRUE; "

        "subtitle/x-kate; application/x-kate")

    );

static void gst_ogg_mux_finalize (GObject * object);

static GstFlowReturn gst_ogg_mux_collected (GstCollectPads * pads,

    GstOggMux * ogg_mux);

static gboolean gst_ogg_mux_sink_event (GstCollectPads * pads,

    GstCollectData * pad, GstEvent * event, gpointer user_data);

static gboolean gst_ogg_mux_handle_src_event (GstPad * pad, GstObject * parent,

    GstEvent * event);

static GstPad *gst_ogg_mux_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * name, const GstCaps * caps);

static void gst_ogg_mux_release_pad (GstElement * element, GstPad * pad);

static void gst_ogg_pad_data_reset (GstOggMux * ogg_mux,

    GstOggPadData * pad_data);

static void gst_ogg_mux_set_property (GObject * object,

    guint prop_id, const GValue * value, GParamSpec * pspec);

static void gst_ogg_mux_get_property (GObject * object,

    guint prop_id, GValue * value, GParamSpec * pspec);

static GstStateChangeReturn gst_ogg_mux_change_state (GstElement * element,

    GstStateChange transition);

/*static guint gst_ogg_mux_signals[LAST_SIGNAL] = { 0 }; */

#define gst_ogg_mux_parent_class parent_class

G_DEFINE_TYPE_WITH_CODE (GstOggMux, gst_ogg_mux, GST_TYPE_ELEMENT,

    G_IMPLEMENT_INTERFACE (GST_TYPE_PRESET, NULL));

static void

gst_ogg_mux_class_init (GstOggMuxClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;

  gstelement_class = (GstElementClass *) klass;

  gobject_class->finalize = gst_ogg_mux_finalize;

  gobject_class->get_property = gst_ogg_mux_get_property;

  gobject_class->set_property = gst_ogg_mux_set_property;

  gst_element_class_add_static_pad_template (gstelement_class, &src_factory);

  gst_element_class_add_static_pad_template (gstelement_class,

      &video_sink_factory);

  gst_element_class_add_static_pad_template (gstelement_class,

      &audio_sink_factory);

  gst_element_class_add_static_pad_template (gstelement_class,

      &subtitle_sink_factory);

  gst_element_class_set_static_metadata (gstelement_class,

      "Ogg muxer", "Codec/Muxer",

      "mux ogg streams (info about ogg: http://xiph.org)",

      "Wim Taymans <wim@fluendo.com>");

  gstelement_class->request_new_pad = gst_ogg_mux_request_new_pad;

  gstelement_class->release_pad = gst_ogg_mux_release_pad;

  g_object_class_install_property (gobject_class, ARG_MAX_DELAY,

      g_param_spec_uint64 ("max-delay", "Max delay",

          "Maximum delay in multiplexing streams", 0, G_MAXUINT64,

          DEFAULT_MAX_DELAY,

          (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, ARG_MAX_PAGE_DELAY,

      g_param_spec_uint64 ("max-page-delay", "Max page delay",

          "Maximum delay for sending out a page", 0, G_MAXUINT64,

          DEFAULT_MAX_PAGE_DELAY,

          (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, ARG_MAX_TOLERANCE,

      g_param_spec_uint64 ("max-tolerance", "Max time tolerance",

          "Maximum timestamp difference for maintaining perfect granules",

          0, G_MAXUINT64, DEFAULT_MAX_TOLERANCE,

          (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_property (gobject_class, ARG_SKELETON,

      g_param_spec_boolean ("skeleton", "Skeleton",

          "Whether to include a Skeleton track",

          DEFAULT_SKELETON,

          (GParamFlags) G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  gstelement_class->change_state = gst_ogg_mux_change_state;

}

static void

gst_ogg_mux_clear (GstOggMux * ogg_mux)

{

  ogg_mux->pulling = NULL;

  ogg_mux->need_headers = TRUE;

  ogg_mux->need_start_events = TRUE;

  ogg_mux->delta_pad = NULL;

  ogg_mux->offset = 0;

  ogg_mux->next_ts = 0;

  ogg_mux->last_ts = GST_CLOCK_TIME_NONE;

}

static void

gst_ogg_mux_init (GstOggMux * ogg_mux)

{

  GstElementClass *klass = GST_ELEMENT_GET_CLASS (ogg_mux);

  ogg_mux->srcpad =

      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,

          "src"), "src");

  gst_pad_set_event_function (ogg_mux->srcpad, gst_ogg_mux_handle_src_event);

  gst_element_add_pad (GST_ELEMENT (ogg_mux), ogg_mux->srcpad);

  /* seed random number generator for creation of serial numbers */

  srand (time (NULL));

  ogg_mux->collect = gst_collect_pads_new ();

  gst_collect_pads_set_function (ogg_mux->collect,

      (GstCollectPadsFunction) GST_DEBUG_FUNCPTR (gst_ogg_mux_collected),

      ogg_mux);

  gst_collect_pads_set_event_function (ogg_mux->collect,

      (GstCollectPadsEventFunction) GST_DEBUG_FUNCPTR (gst_ogg_mux_sink_event),

      ogg_mux);

  ogg_mux->max_delay = DEFAULT_MAX_DELAY;

  ogg_mux->max_page_delay = DEFAULT_MAX_PAGE_DELAY;

  ogg_mux->max_tolerance = DEFAULT_MAX_TOLERANCE;

  gst_ogg_mux_clear (ogg_mux);

}

static void

gst_ogg_mux_finalize (GObject * object)

{

  GstOggMux *ogg_mux;

  ogg_mux = GST_OGG_MUX (object);

  if (ogg_mux->collect) {

    gst_object_unref (ogg_mux->collect);

    ogg_mux->collect = NULL;

  }

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gst_ogg_mux_ogg_pad_destroy_notify (GstCollectData * data)

{

  GstOggPadData *oggpad = (GstOggPadData *) data;

  GstBuffer *buf;

  ogg_stream_clear (&oggpad->map.stream);

  gst_caps_replace (&oggpad->map.caps, NULL);

  if (oggpad->pagebuffers) {

    while ((buf = g_queue_pop_head (oggpad->pagebuffers)) != NULL) {

      gst_buffer_unref (buf);

    }

    g_queue_free (oggpad->pagebuffers);

    oggpad->pagebuffers = NULL;

  }

}

static GstPadLinkReturn

gst_ogg_mux_sinkconnect (GstPad * pad, GstObject * parent, GstPad * peer)

{

  GstOggMux *ogg_mux;

  ogg_mux = GST_OGG_MUX (parent);

  GST_DEBUG_OBJECT (ogg_mux, "sinkconnect triggered on %s", GST_PAD_NAME (pad));

  return GST_PAD_LINK_OK;

}

static void

gst_ogg_mux_flush (GstOggMux * ogg_mux)

{

  GSList *walk;

  for (walk = ogg_mux->collect->data; walk; walk = g_slist_next (walk)) {

    GstOggPadData *pad;

    pad = (GstOggPadData *) walk->data;

    gst_ogg_pad_data_reset (ogg_mux, pad);

  }

  gst_ogg_mux_clear (ogg_mux);

}

static gboolean

gst_ogg_mux_sink_event (GstCollectPads * pads, GstCollectData * pad,

    GstEvent * event, gpointer user_data)

{

  GstOggMux *ogg_mux = GST_OGG_MUX (user_data);

  GstOggPadData *ogg_pad = (GstOggPadData *) pad;

  GST_DEBUG_OBJECT (pad->pad, "Got %s event", GST_EVENT_TYPE_NAME (event));

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_SEGMENT:

    {

      const GstSegment *segment;

      gst_event_parse_segment (event, &segment);

      /* We don't support non time NEWSEGMENT events */

      if (segment->format != GST_FORMAT_TIME) {

        gst_event_unref (event);

        event = NULL;

        break;

      }

      gst_segment_copy_into (segment, &ogg_pad->segment);

      break;

    }

    case GST_EVENT_FLUSH_STOP:{

      /* only a single flush-stop is forwarded from collect pads */

      gst_ogg_mux_flush (ogg_mux);

      break;

    }

    case GST_EVENT_TAG:{

      GstTagList *tags;

      gst_event_parse_tag (event, &tags);

      tags = gst_tag_list_merge (ogg_pad->tags, tags, GST_TAG_MERGE_APPEND);

      if (ogg_pad->tags)

        gst_tag_list_unref (ogg_pad->tags);

      ogg_pad->tags = tags;

      GST_DEBUG_OBJECT (ogg_mux, "Got tags %" GST_PTR_FORMAT, ogg_pad->tags);

      break;

    }

    default:

      break;

  }

  /* now GstCollectPads can take care of the rest, e.g. EOS */

  if (event != NULL)

    return gst_collect_pads_event_default (pads, pad, event, FALSE);

  return TRUE;

}

static gboolean

gst_ogg_mux_is_serialno_present (GstOggMux * ogg_mux, guint32 serialno)

{

  GSList *walk;

  walk = ogg_mux->collect->data;

  while (walk) {

    GstOggPadData *pad = (GstOggPadData *) walk->data;

    if (pad->map.serialno == serialno)

      return TRUE;

    walk = walk->next;

  }

  return FALSE;

}

static void

gst_ogg_pad_data_reset (GstOggMux * ogg_mux, GstOggPadData * oggpad)

{

  oggpad->packetno = 0;

  oggpad->pageno = 0;

  oggpad->eos = FALSE;

  /* we assume there will be some control data first for this pad */

  oggpad->state = GST_OGG_PAD_STATE_CONTROL;

  oggpad->new_page = TRUE;

  oggpad->first_delta = FALSE;

  oggpad->prev_delta = FALSE;

  oggpad->data_pushed = FALSE;

  oggpad->map.headers = NULL;

  oggpad->map.queued = NULL;

  oggpad->next_granule = 0;

  oggpad->keyframe_granule = -1;

  ogg_stream_clear (&oggpad->map.stream);

  ogg_stream_init (&oggpad->map.stream, oggpad->map.serialno);

  if (oggpad->pagebuffers) {

    GstBuffer *buf;

    while ((buf = g_queue_pop_head (oggpad->pagebuffers)) != NULL) {

      gst_buffer_unref (buf);

    }

  } else if (GST_STATE (ogg_mux) > GST_STATE_READY) {

    /* This will be initialized in init_collectpads when going from ready

     * paused state */

    oggpad->pagebuffers = g_queue_new ();

  }

  gst_segment_init (&oggpad->segment, GST_FORMAT_TIME);

}

static guint32

gst_ogg_mux_generate_serialno (GstOggMux * ogg_mux)

{

  guint32 serialno;

  do {

    serialno = g_random_int_range (0, G_MAXINT32);

  } while (gst_ogg_mux_is_serialno_present (ogg_mux, serialno));

  return serialno;

}

static GstPad *

gst_ogg_mux_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * req_name, const GstCaps * caps)

{

  GstOggMux *ogg_mux;

  GstPad *newpad;

  GstElementClass *klass;

  g_return_val_if_fail (templ != NULL, NULL);

  if (templ->direction != GST_PAD_SINK)

    goto wrong_direction;

  g_return_val_if_fail (GST_IS_OGG_MUX (element), NULL);

  ogg_mux = GST_OGG_MUX (element);

  klass = GST_ELEMENT_GET_CLASS (element);

  if (templ != gst_element_class_get_pad_template (klass, "video_%u") &&

      templ != gst_element_class_get_pad_template (klass, "audio_%u") &&

      templ != gst_element_class_get_pad_template (klass, "subtitle_%u")) {

    goto wrong_template;

  }

  {

    guint32 serial;

    gchar *name = NULL;

    if (req_name == NULL || strlen (req_name) < 6) {

      /* no name given when requesting the pad, use random serial number */

      serial = gst_ogg_mux_generate_serialno (ogg_mux);

    } else {

      /* parse serial number from requested padname */

      unsigned long long_serial;

      char *endptr = NULL;

      long_serial = strtoul (&req_name[5], &endptr, 10);

      if ((endptr && *endptr) || (long_serial & ~0xffffffff)) {

        GST_WARNING_OBJECT (ogg_mux, "Invalid serial number specification: %s",

            req_name + 5);

        return NULL;

      }

      serial = (guint32) long_serial;

    }

    /* create new pad with the name */

    GST_DEBUG_OBJECT (ogg_mux, "Creating new pad for serial %d", serial);

    if (templ == gst_element_class_get_pad_template (klass, "video_%u")) {

      name = g_strdup_printf ("video_%u", serial);

    } else if (templ == gst_element_class_get_pad_template (klass, "audio_%u")) {

      name = g_strdup_printf ("audio_%u", serial);

    } else if (templ == gst_element_class_get_pad_template (klass,

            "subtitle_%u")) {

      name = g_strdup_printf ("subtitle_%u", serial);

    }

    newpad = gst_pad_new_from_template (templ, name);

    g_free (name);

    /* construct our own wrapper data structure for the pad to

     * keep track of its status */

    {

      GstOggPadData *oggpad;

      oggpad = (GstOggPadData *)

          gst_collect_pads_add_pad (ogg_mux->collect, newpad,

          sizeof (GstOggPadData), gst_ogg_mux_ogg_pad_destroy_notify, FALSE);

      ogg_mux->active_pads++;

      oggpad->map.serialno = serial;

      gst_ogg_pad_data_reset (ogg_mux, oggpad);

    }

  }

  /* setup some pad functions */

  gst_pad_set_link_function (newpad, gst_ogg_mux_sinkconnect);

  /* dd the pad to the element */

  gst_element_add_pad (element, newpad);

  return newpad;

  /* ERRORS */

wrong_direction:

  {

    g_warning ("ogg_mux: request pad that is not a SINK pad\n");

    return NULL;

  }

wrong_template:

  {

    g_warning ("ogg_mux: this is not our template!\n");

    return NULL;

  }

}

static void

gst_ogg_mux_release_pad (GstElement * element, GstPad * pad)

{

  GstOggMux *ogg_mux;

  ogg_mux = GST_OGG_MUX (gst_pad_get_parent (pad));

  gst_collect_pads_remove_pad (ogg_mux->collect, pad);

  gst_element_remove_pad (element, pad);

  gst_object_unref (ogg_mux);

}

/* handle events */

static gboolean

gst_ogg_mux_handle_src_event (GstPad * pad, GstObject * parent,

    GstEvent * event)

{

  gboolean res = FALSE;

  GstOggMux *ogg_mux = GST_OGG_MUX (parent);

  switch (GST_EVENT_TYPE (event)) {

    case GST_EVENT_SEEK:{

      GstSeekFlags flags;

      gst_event_parse_seek (event, NULL, NULL, &flags, NULL, NULL, NULL, NULL);

      if (!ogg_mux->need_headers && (flags & GST_SEEK_FLAG_FLUSH) != 0) {

        /* don't allow flushing seeks once we started */

        gst_event_unref (event);

        event = NULL;

      }

      break;

    }

    default:

      break;

  }

  if (event != NULL)

    res = gst_pad_event_default (pad, parent, event);

  return res;

}

static GstBuffer *

gst_ogg_mux_buffer_from_page (GstOggMux * mux, ogg_page * page, gboolean delta)

{

  GstBuffer *buffer;

  /* allocate space for header and body */

  buffer = gst_buffer_new_and_alloc (page->header_len + page->body_len);

  gst_buffer_fill (buffer, 0, page->header, page->header_len);

  gst_buffer_fill (buffer, page->header_len, page->body, page->body_len);

  /* Here we set granulepos as our OFFSET_END to give easy direct access to

   * this value later. Before we push it, we reset this to OFFSET + SIZE

   * (see gst_ogg_mux_push_buffer). */

  GST_BUFFER_OFFSET_END (buffer) = ogg_page_granulepos (page);

  if (delta)

    GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);

  GST_LOG_OBJECT (mux, GST_GP_FORMAT

      " created buffer %p from ogg page",

      GST_GP_CAST (ogg_page_granulepos (page)), buffer);

  return buffer;

}

static GstFlowReturn

gst_ogg_mux_push_buffer (GstOggMux * mux, GstBuffer * buffer,

    GstOggPadData * oggpad)

{

  /* fix up OFFSET and OFFSET_END again */

  GST_BUFFER_OFFSET (buffer) = mux->offset;

  mux->offset += gst_buffer_get_size (buffer);

  GST_BUFFER_OFFSET_END (buffer) = mux->offset;

  /* Ensure we have monotonically increasing timestamps in the output. */

  if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) {

    gint64 run_time = GST_BUFFER_TIMESTAMP (buffer);

    if (mux->last_ts != GST_CLOCK_TIME_NONE && run_time < mux->last_ts)

      GST_BUFFER_TIMESTAMP (buffer) = mux->last_ts;

    else

      mux->last_ts = run_time;

  }

  GST_LOG_OBJECT (mux->srcpad, "pushing %p, last_ts=%" GST_TIME_FORMAT,

      buffer, GST_TIME_ARGS (mux->last_ts));

  return gst_pad_push (mux->srcpad, buffer);

}

/* if all queues have at least one page, dequeue the page with the lowest

 * timestamp */

static gboolean

gst_ogg_mux_dequeue_page (GstOggMux * mux, GstFlowReturn * flowret)

{

  GSList *walk;

  GstOggPadData *opad = NULL;   /* "oldest" pad */

  GstClockTime oldest = GST_CLOCK_TIME_NONE;

  GstBuffer *buf = NULL;

  gboolean ret = FALSE;

  *flowret = GST_FLOW_OK;

  walk = mux->collect->data;

  while (walk) {

    GstOggPadData *pad = (GstOggPadData *) walk->data;

    /* We need each queue to either be at EOS, or have one or more pages

     * available with a set granulepos (i.e. not -1), otherwise we don't have

     * enough data yet to determine which stream needs to go next for correct

     * time ordering. */

    if (pad->pagebuffers->length == 0) {

      if (pad->eos) {

        GST_LOG_OBJECT (pad->collect.pad,

            "pad is EOS, skipping for dequeue decision");

      } else {

        GST_LOG_OBJECT (pad->collect.pad,

            "no pages in this queue, can't dequeue");

        return FALSE;

      }

    } else {

      /* We then need to check for a non-negative granulepos */

      gboolean valid = FALSE;

      GList *l;

      for (l = pad->pagebuffers->head; l != NULL; l = l->next) {

        buf = l->data;

        /* Here we check the OFFSET_END, which is actually temporarily the

         * granulepos value for this buffer */

        if (GST_BUFFER_OFFSET_END_IS_VALID (buf)) {

          valid = TRUE;

          break;

        }

      }

      if (!valid) {

        GST_LOG_OBJECT (pad->collect.pad,

            "No page timestamps in queue, can't dequeue");

        return FALSE;

      }

    }

    walk = g_slist_next (walk);

  }

  walk = mux->collect->data;

  while (walk) {

    GstOggPadData *pad = (GstOggPadData *) walk->data;

    /* any page with a granulepos of -1 can be pushed immediately.

     * TODO: it CAN be, but it seems silly to do so? */

    buf = g_queue_peek_head (pad->pagebuffers);

    while (buf && GST_BUFFER_OFFSET_END (buf) == -1) {

      GST_LOG_OBJECT (pad->collect.pad, "[gp        -1] pushing page");

      g_queue_pop_head (pad->pagebuffers);

      *flowret = gst_ogg_mux_push_buffer (mux, buf, pad);

      buf = g_queue_peek_head (pad->pagebuffers);

      ret = TRUE;

    }

    if (buf) {

      /* if no oldest buffer yet, take this one */

      if (oldest == GST_CLOCK_TIME_NONE) {

        GST_LOG_OBJECT (mux, "no oldest yet, taking buffer %p from pad %"

            GST_PTR_FORMAT " with gp time %" GST_TIME_FORMAT,

            buf, pad->collect.pad, GST_TIME_ARGS (GST_BUFFER_OFFSET (buf)));

        oldest = GST_BUFFER_OFFSET (buf);

        opad = pad;

      } else {

        /* if we have an oldest, compare with this one */

        if (GST_BUFFER_OFFSET (buf) < oldest) {

          GST_LOG_OBJECT (mux, "older buffer %p, taking from pad %"

              GST_PTR_FORMAT " with gp time %" GST_TIME_FORMAT,

              buf, pad->collect.pad, GST_TIME_ARGS (GST_BUFFER_OFFSET (buf)));

          oldest = GST_BUFFER_OFFSET (buf);

          opad = pad;

        }

      }

    }

    walk = g_slist_next (walk);

  }

  if (oldest != GST_CLOCK_TIME_NONE) {

    g_assert (opad);

    buf = g_queue_pop_head (opad->pagebuffers);

    GST_LOG_OBJECT (opad->collect.pad,

        GST_GP_FORMAT " pushing oldest page buffer %p (granulepos time %"

        GST_TIME_FORMAT ")", GST_BUFFER_OFFSET_END (buf), buf,

        GST_TIME_ARGS (GST_BUFFER_OFFSET (buf)));

    *flowret = gst_ogg_mux_push_buffer (mux, buf, opad);

    ret = TRUE;

  }

  return ret;

}

/* put the given ogg page on a per-pad queue, timestamping it correctly.

 * after that, dequeue and push as many pages as possible.

 * Caller should make sure:

 * pad->timestamp     was set with the timestamp of the first packet put

 *                    on the page

 * pad->timestamp_end was set with the timestamp + duration of the last packet

 *                    put on the page

 * pad->gp_time       was set with the time matching the gp of the last

 *                    packet put on the page

 *

 * will also reset timestamp and timestamp_end, so caller func can restart

 * counting.

 */

static GstFlowReturn

gst_ogg_mux_pad_queue_page (GstOggMux * mux, GstOggPadData * pad,

    ogg_page * page, gboolean delta)

{

  GstFlowReturn ret;

  GstBuffer *buffer = gst_ogg_mux_buffer_from_page (mux, page, delta);

  /* take the timestamp of the first packet on this page */

  GST_BUFFER_TIMESTAMP (buffer) = pad->timestamp;

  GST_BUFFER_DURATION (buffer) = pad->timestamp_end - pad->timestamp;

  /* take the gp time of the last completed packet on this page */

  GST_BUFFER_OFFSET (buffer) = pad->gp_time;

  /* the next page will start where the current page's end time leaves off */

  pad->timestamp = pad->timestamp_end;

  g_queue_push_tail (pad->pagebuffers, buffer);

  GST_LOG_OBJECT (pad->collect.pad, GST_GP_FORMAT

      " queued buffer page %p (gp time %"

      GST_TIME_FORMAT ", timestamp %" GST_TIME_FORMAT

      "), %d page buffers queued", GST_GP_CAST (ogg_page_granulepos (page)),

      buffer, GST_TIME_ARGS (GST_BUFFER_OFFSET (buffer)),

      GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),

      g_queue_get_length (pad->pagebuffers));

  while (gst_ogg_mux_dequeue_page (mux, &ret)) {

    if (ret != GST_FLOW_OK)

      break;

  }

  return ret;

}

/*

 * Given two pads, compare the buffers queued on it.

 * Returns:

 *  0 if they have an equal priority

 * -1 if the first is better

 *  1 if the second is better

 * Priority decided by: a) validity, b) older timestamp, c) smaller number

 * of muxed pages

 */

static gint

gst_ogg_mux_compare_pads (GstOggMux * ogg_mux, GstOggPadData * first,

    GstOggPadData * second)

{

  guint64 firsttime, secondtime;

  /* if the first pad doesn't contain anything or is even NULL, return

   * the second pad as best candidate and vice versa */

  if (first == NULL)

    return 1;

  if (second == NULL)

    return -1;

  /* no timestamp on first buffer, it must go first */

  firsttime = GST_BUFFER_TIMESTAMP (first->buffer);

  if (firsttime == GST_CLOCK_TIME_NONE)

    return -1;

  /* no timestamp on second buffer, it must go first */

  secondtime = GST_BUFFER_TIMESTAMP (second->buffer);

  if (secondtime == GST_CLOCK_TIME_NONE)

    return 1;

  /* first buffer has higher timestamp, second one should go first */

  if (secondtime < firsttime)

    return 1;

  /* second buffer has higher timestamp, first one should go first */

  else if (secondtime > firsttime)

    return -1;

  else {

    /* buffers with equal timestamps, prefer the pad that has the

     * least number of pages muxed */

    if (second->pageno < first->pageno)

      return 1;

    else if (second->pageno > first->pageno)

      return -1;

  }

  /* same priority if all of the above failed */

  return 0;

}

static GstBuffer *

gst_ogg_mux_decorate_buffer (GstOggMux * ogg_mux, GstOggPadData * pad,

    GstBuffer * buf)

{

  GstClockTime time, end_time;

  gint64 duration, granule, limit;

  GstClockTime next_time;

  GstClockTimeDiff diff;

  GstMapInfo map;

  ogg_packet packet;

  gboolean end_clip = TRUE;

  GstAudioClippingMeta *meta;

  /* ensure messing with metadata is ok */

  buf = gst_buffer_make_writable (buf);

  /* convert time to running time, so we need no longer bother about that */

  time = GST_BUFFER_TIMESTAMP (buf);

  if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (time))) {

    time = gst_segment_to_running_time (&pad->segment, GST_FORMAT_TIME, time);

    if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (time))) {

      gst_buffer_unref (buf);

      return NULL;

    } else {

      GST_BUFFER_TIMESTAMP (buf) = time;

    }

  }

  /* now come up with granulepos stuff corresponding to time */

  if (!pad->have_type ||

      pad->map.granulerate_n <= 0 || pad->map.granulerate_d <= 0)

    goto no_granule;

  gst_buffer_map (buf, &map, GST_MAP_READ);

  packet.packet = map.data;

  packet.bytes = map.size;

  gst_ogg_stream_update_stats (&pad->map, &packet);

  duration = gst_ogg_stream_get_packet_duration (&pad->map, &packet);

  gst_buffer_unmap (buf, &map);

  /* give up if no duration can be determined, relying on upstream */

  if (G_UNLIKELY (duration < 0)) {

    /* well, if some day we really could handle sparse input ... */

    if (pad->map.is_sparse) {

      limit = 1;

      diff = 2;

      goto resync;

    }

    GST_WARNING_OBJECT (pad->collect.pad,

        "failed to determine packet duration");

    goto no_granule;

  }

  /* The last packet may have clipped samples. We need to test against

   * the segment to ensure we do not use a granpos that encompasses those.

   */

  if (pad->map.audio_clipping) {

    GstAudioClippingMeta *cmeta = gst_buffer_get_audio_clipping_meta (buf);

    g_assert (!cmeta || cmeta->format == GST_FORMAT_DEFAULT);

    if (cmeta && cmeta->end && cmeta->end < duration) {

      GST_DEBUG_OBJECT (pad->collect.pad,

          "Clipping %" G_GUINT64_FORMAT " samples at the end", cmeta->end);

      duration -= cmeta->end;

      end_clip = FALSE;

    }

  }

  if (end_clip) {

    end_time =

        gst_ogg_stream_granule_to_time (&pad->map,

        pad->next_granule + duration);

    meta = gst_buffer_get_audio_clipping_meta (buf);

    if (meta && meta->end) {

      if (meta->format == GST_FORMAT_DEFAULT) {

        if (meta->end > duration) {

          GST_WARNING_OBJECT (pad->collect.pad,

              "Clip meta tries to clip more sample than exist in the buffer, clipping all");