/* 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/gst.h>

#include <gst/base/gstcollectpads.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 "]"

typedef enum

{

  GST_OGG_FLAG_BOS = GST_ELEMENT_FLAG_LAST,

  GST_OGG_FLAG_EOS

}

GstOggFlag;

/* elementfactory information */

static const GstElementDetails gst_ogg_mux_details =

GST_ELEMENT_DETAILS ("Ogg muxer",

    "Codec/Muxer",

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

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

/* OggMux signals and args */

enum

{

  /* FILL ME */

  LAST_SIGNAL

};

/* set to 0.5 seconds by default */

#define DEFAULT_MAX_DELAY       G_GINT64_CONSTANT(500000000)

#define DEFAULT_MAX_PAGE_DELAY  G_GINT64_CONSTANT(500000000)

enum

{

  ARG_0,

  ARG_MAX_DELAY,

  ARG_MAX_PAGE_DELAY,

};

static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("application/ogg")

    );

static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink_%d",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS ("video/x-theora; "

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

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

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

    );

static void gst_ogg_mux_base_init (gpointer g_class);

static void gst_ogg_mux_class_init (GstOggMuxClass * klass);

static void gst_ogg_mux_init (GstOggMux * ogg_mux);

static void gst_ogg_mux_finalize (GObject * object);

static GstFlowReturn

gst_ogg_mux_collected (GstCollectPads * pads, GstOggMux * ogg_mux);

static gboolean gst_ogg_mux_handle_src_event (GstPad * pad, GstEvent * event);

static GstPad *gst_ogg_mux_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * name);

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

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 GstElementClass *parent_class = NULL;

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

GType

gst_ogg_mux_get_type (void)

{

  static GType ogg_mux_type = 0;

  if (G_UNLIKELY (ogg_mux_type == 0)) {

    static const GTypeInfo ogg_mux_info = {

      sizeof (GstOggMuxClass),

      gst_ogg_mux_base_init,

      NULL,

      (GClassInitFunc) gst_ogg_mux_class_init,

      NULL,

      NULL,

      sizeof (GstOggMux),

      0,

      (GInstanceInitFunc) gst_ogg_mux_init,

    };

    ogg_mux_type =

        g_type_register_static (GST_TYPE_ELEMENT, "GstOggMux", &ogg_mux_info,

        0);

  }

  return ogg_mux_type;

}

static void

gst_ogg_mux_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&src_factory));

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&sink_factory));

  gst_element_class_set_details (element_class, &gst_ogg_mux_details);

}

static void

gst_ogg_mux_class_init (GstOggMuxClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;

  gstelement_class = (GstElementClass *) klass;

  parent_class = g_type_class_peek_parent (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;

  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_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));

  gstelement_class->change_state = gst_ogg_mux_change_state;

}

#if 0

static const GstEventMask *

gst_ogg_mux_get_sink_event_masks (GstPad * pad)

{

  static const GstEventMask gst_ogg_mux_sink_event_masks[] = {

    {GST_EVENT_EOS, 0},

    {GST_EVENT_DISCONTINUOUS, 0},

    {0,}

  };

  return gst_ogg_mux_sink_event_masks;

}

#endif

static void

gst_ogg_mux_clear (GstOggMux * ogg_mux)

{

  ogg_mux->pulling = NULL;

  ogg_mux->need_headers = TRUE;

  ogg_mux->max_delay = DEFAULT_MAX_DELAY;

  ogg_mux->max_page_delay = DEFAULT_MAX_PAGE_DELAY;

  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);

  GST_OBJECT_FLAG_SET (GST_ELEMENT (ogg_mux), GST_OGG_FLAG_BOS);

  /* 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_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)

{

  GstOggPad *oggpad = (GstOggPad *) data;

  GstBuffer *buf;

  ogg_stream_clear (&oggpad->stream);

  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, GstPad * peer)

{

  GstOggMux *ogg_mux;

  ogg_mux = GST_OGG_MUX (gst_pad_get_parent (pad));

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

  gst_object_unref (ogg_mux);

  return GST_PAD_LINK_OK;

}

static GstPad *

gst_ogg_mux_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * req_name)

{

  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, "sink_%d"))

    goto wrong_template;

  {

    gint serial;

    gchar *name;

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

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

      serial = rand ();

    } else {

      /* parse serial number from requested padname */

      serial = atoi (&req_name[5]);

    }

    /* create new pad with the name */

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

    name = g_strdup_printf ("sink_%d", 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 */

    {

      GstOggPad *oggpad;

      oggpad = (GstOggPad *)

          gst_collect_pads_add_pad_full (ogg_mux->collect, newpad,

          sizeof (GstOggPad), gst_ogg_mux_ogg_pad_destroy_notify);

      ogg_mux->active_pads++;

      oggpad->serial = serial;

      ogg_stream_init (&oggpad->stream, serial);

      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->pagebuffers = g_queue_new ();

    }

  }

  /* 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, GstEvent * event)

{

  GstEventType type;

  type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;

  switch (type) {

    case GST_EVENT_SEEK:

      /* disable seeking for now */

      return FALSE;

    default:

      break;

  }

  return gst_pad_event_default (pad, event);

}

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);

  memcpy (GST_BUFFER_DATA (buffer), page->header, page->header_len);

  memcpy (GST_BUFFER_DATA (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", ogg_page_granulepos (page), buffer);

  return buffer;

}

static GstFlowReturn

gst_ogg_mux_push_buffer (GstOggMux * mux, GstBuffer * buffer)

{

  GstCaps *caps;

  /* fix up OFFSET and OFFSET_END again */

  GST_BUFFER_OFFSET (buffer) = mux->offset;

  mux->offset += GST_BUFFER_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)) {

    if (mux->last_ts != GST_CLOCK_TIME_NONE &&

        GST_BUFFER_TIMESTAMP (buffer) < mux->last_ts)

      GST_BUFFER_TIMESTAMP (buffer) = mux->last_ts;

    else

      mux->last_ts = GST_BUFFER_TIMESTAMP (buffer);

  }

  caps = gst_pad_get_negotiated_caps (mux->srcpad);

  gst_buffer_set_caps (buffer, caps);

  gst_caps_unref (caps);

  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;

  GstOggPad *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) {

    GstOggPad *pad = (GstOggPad *) 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 */

      int i;

      gboolean valid = FALSE;

      for (i = 0; i < pad->pagebuffers->length; i++) {

        buf = g_queue_peek_nth (pad->pagebuffers, i);

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

         * granulepos value for this buffer */

        if (GST_BUFFER_OFFSET_END (buf) != -1) {

          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) {

    GstOggPad *pad = (GstOggPad *) 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);

      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 %"