gstreamer/ext/smoothstreaming/gstmssmanifest.c

/* GStreamer
 * Copyright (C) 2012 Smart TV Alliance
 *  Author: Thiago Sousa Santos <thiago.sousa.santos@collabora.com>, Collabora Ltd.
 *
 * gstmssmanifest.c:
 *
 * 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.
 */

#include <glib.h>
#include <string.h>
#include <libxml/parser.h>
#include <libxml/tree.h>

#include "gstmssmanifest.h"

#define MSS_NODE_STREAM_FRAGMENT      "c"
#define MSS_NODE_STREAM_QUALITY       "QualityLevel"

#define MSS_PROP_BITRATE              "Bitrate"
#define MSS_PROP_DURATION             "d"
#define MSS_PROP_NUMBER               "n"
#define MSS_PROP_TIME                 "t"
#define MSS_PROP_URL                  "Url"

/* TODO check if atoi is successful? */

typedef struct _GstMssStreamFragment
{
  guint number;
  guint64 time;
  guint64 duration;
} GstMssStreamFragment;

struct _GstMssStream
{
  xmlNodePtr xmlnode;

  gint selectedQualityIndex;

  GList *fragments;
  GList *qualities;

  gchar *url;

  GList *current_fragment;
  GList *current_quality;

  /* TODO move this to somewhere static */
  GRegex *regex_bitrate;
  GRegex *regex_position;
};

struct _GstMssManifest
{
  xmlDocPtr xml;
  xmlNodePtr xmlrootnode;

  GSList *streams;
};

static gboolean
node_has_type (xmlNodePtr node, const gchar * name)
{
  return strcmp ((gchar *) node->name, name) == 0;
}

static void
_gst_mss_stream_init (GstMssStream * stream, xmlNodePtr node)
{
  xmlNodePtr iter;
  GstMssStreamFragment *previous_fragment = NULL;
  guint fragment_number = 0;
  guint fragment_time_accum = 0;
  GError *gerror = NULL;

  stream->xmlnode = node;

  /* get the base url path generator */
  stream->url = (gchar *) xmlGetProp (node, (xmlChar *) MSS_PROP_URL);

  for (iter = node->children; iter; iter = iter->next) {
    if (node_has_type (iter, MSS_NODE_STREAM_FRAGMENT)) {
      gchar *duration_str;
      gchar *time_str;
      gchar *seqnum_str;
      GstMssStreamFragment *fragment = g_new (GstMssStreamFragment, 1);

      duration_str = (gchar *) xmlGetProp (iter, (xmlChar *) MSS_PROP_DURATION);
      time_str = (gchar *) xmlGetProp (iter, (xmlChar *) MSS_PROP_TIME);
      seqnum_str = (gchar *) xmlGetProp (iter, (xmlChar *) MSS_PROP_NUMBER);

      /* use the node's seq number or use the previous + 1 */
      if (seqnum_str) {
        fragment->number = atoi (seqnum_str);
        g_free (seqnum_str);
      } else {
        fragment->number = fragment_number;
      }
      fragment_number = fragment->number + 1;

      if (time_str) {
        fragment->time = atoi (time_str);
        g_free (time_str);
      } else {
        fragment->time = fragment_time_accum;
      }

      /* if we have a previous fragment, means we need to set its duration */
      if (previous_fragment)
        previous_fragment->duration = fragment->time - previous_fragment->time;

      if (duration_str) {
        fragment->duration = atoi (duration_str);

        previous_fragment = NULL;
        fragment_time_accum += fragment->duration;
        g_free (duration_str);
      } else {
        /* store to set the duration at the next iteration */
        previous_fragment = fragment;
      }

      /* we reverse it later */
      stream->fragments = g_list_prepend (stream->fragments, fragment);

    } else if (node_has_type (iter, MSS_NODE_STREAM_QUALITY)) {
      stream->qualities = g_list_prepend (stream->qualities, iter);
    } else {
      /* TODO gst log this */
    }
  }

  stream->fragments = g_list_reverse (stream->fragments);
  stream->qualities = g_list_reverse (stream->qualities);

  stream->current_fragment = stream->fragments;
  stream->current_quality = stream->qualities;

  stream->regex_bitrate = g_regex_new ("\\{[Bb]itrate\\}", 0, 0, &gerror);
  stream->regex_position = g_regex_new ("\\{start[ _]time\\}", 0, 0, &gerror);
}

GstMssManifest *
gst_mss_manifest_new (const GstBuffer * data)
{
  GstMssManifest *manifest;
  xmlNodePtr root;
  xmlNodePtr nodeiter;

  manifest = g_malloc0 (sizeof (GstMssManifest));

  manifest->xml = xmlReadMemory ((const gchar *) GST_BUFFER_DATA (data),
      GST_BUFFER_SIZE (data), "manifest", NULL, 0);
  root = manifest->xmlrootnode = xmlDocGetRootElement (manifest->xml);

  for (nodeiter = root->children; nodeiter; nodeiter = nodeiter->next) {
    if (nodeiter->type == XML_ELEMENT_NODE
        && (strcmp ((const char *) nodeiter->name, "StreamIndex") == 0)) {
      GstMssStream *stream = g_new0 (GstMssStream, 1);

      manifest->streams = g_slist_append (manifest->streams, stream);
      _gst_mss_stream_init (stream, nodeiter);
    }
  }

  return manifest;
}

static void
gst_mss_stream_free (GstMssStream * stream)
{
  g_list_free_full (stream->fragments, g_free);
  g_list_free (stream->qualities);
  g_free (stream->url);
  g_regex_unref (stream->regex_position);
  g_regex_unref (stream->regex_bitrate);
  g_free (stream);
}

void
gst_mss_manifest_free (GstMssManifest * manifest)
{
  g_return_if_fail (manifest != NULL);

  g_slist_free_full (manifest->streams, (GDestroyNotify) gst_mss_stream_free);

  xmlFreeDoc (manifest->xml);
  g_free (manifest);
}

GSList *
gst_mss_manifest_get_streams (GstMssManifest * manifest)
{
  return manifest->streams;
}

GstMssStreamType
gst_mss_stream_get_type (GstMssStream * stream)
{
  gchar *prop = (gchar *) xmlGetProp (stream->xmlnode, (xmlChar *) "Type");
  GstMssStreamType ret = MSS_STREAM_TYPE_UNKNOWN;

  if (strcmp (prop, "video") == 0) {
    ret = MSS_STREAM_TYPE_VIDEO;
  } else if (strcmp (prop, "audio") == 0) {
    ret = MSS_STREAM_TYPE_AUDIO;
  }
  xmlFree (prop);
  return ret;
}

static GstCaps *
_gst_mss_stream_video_caps_from_fourcc (gchar * fourcc)
{
  if (!fourcc)
    return NULL;

  if (strcmp (fourcc, "H264") == 0) {
    return gst_caps_new_simple ("video/x-h264", "stream-format", G_TYPE_STRING,
        "avc", NULL);
  }
  return NULL;
}

static GstCaps *
_gst_mss_stream_audio_caps_from_fourcc (gchar * fourcc)
{
  if (!fourcc)
    return NULL;

  if (strcmp (fourcc, "AACL") == 0) {
    return gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, 4,
        NULL);
  }
  return NULL;
}

/* copied and adapted from h264parse */
static GstBuffer *
_make_h264_codec_data (GstBuffer * sps, GstBuffer * pps)
{
  GstBuffer *buf;
  gint sps_size = 0, pps_size = 0, num_sps = 0, num_pps = 0;
  guint8 profile_idc = 0, profile_comp = 0, level_idc = 0;
  guint8 *data;
  gint nl;

  sps_size += GST_BUFFER_SIZE (sps) + 2;
  profile_idc = GST_BUFFER_DATA (sps)[1];
  profile_comp = GST_BUFFER_DATA (sps)[2];
  level_idc = GST_BUFFER_DATA (sps)[3];
  num_sps = 1;

  pps_size += GST_BUFFER_SIZE (pps) + 2;
  num_pps = 1;

  buf = gst_buffer_new_and_alloc (5 + 1 + sps_size + 1 + pps_size);
  data = GST_BUFFER_DATA (buf);
  nl = 4;

  data[0] = 1;                  /* AVC Decoder Configuration Record ver. 1 */
  data[1] = profile_idc;        /* profile_idc                             */
  data[2] = profile_comp;       /* profile_compability                     */
  data[3] = level_idc;          /* level_idc                               */
  data[4] = 0xfc | (nl - 1);    /* nal_length_size_minus1                  */
  data[5] = 0xe0 | num_sps;     /* number of SPSs */

  data += 6;
  GST_WRITE_UINT16_BE (data, GST_BUFFER_SIZE (sps));
  memcpy (data + 2, GST_BUFFER_DATA (sps), GST_BUFFER_SIZE (sps));
  data += 2 + GST_BUFFER_SIZE (sps);

  data[0] = num_pps;
  data++;
  GST_WRITE_UINT16_BE (data, GST_BUFFER_SIZE (pps));
  memcpy (data + 2, GST_BUFFER_DATA (pps), GST_BUFFER_SIZE (pps));
  data += 2 + GST_BUFFER_SIZE (pps);

  return buf;
}

static GstBuffer *
_gst_mss_stream_create_h264_codec_data (const gchar * codecdatastr)
{
  GValue sps_value = { 0, };
  GValue pps_value = { 0, };
  GstBuffer *sps;
  GstBuffer *pps;
  GstBuffer *buffer;
  gchar *sps_str;
  gchar *pps_str;

  /* search for the sps start */
  if (g_str_has_prefix (codecdatastr, "00000001")) {
    sps_str = (gchar *) codecdatastr + 8;
  } else {
    return NULL;                /* invalid mss codec data */
  }

  /* search for the pps start */
  pps_str = g_strstr_len (sps_str, -1, "00000001");
  if (!pps_str) {
    return NULL;                /* invalid mss codec data */
  }

  g_value_init (&sps_value, GST_TYPE_BUFFER);
  pps_str[0] = '\0';
  gst_value_deserialize (&sps_value, sps_str);
  pps_str[0] = '0';

  g_value_init (&pps_value, GST_TYPE_BUFFER);
  pps_str = pps_str + 8;
  gst_value_deserialize (&pps_value, pps_str);

  sps = gst_value_get_buffer (&sps_value);
  pps = gst_value_get_buffer (&pps_value);

  buffer = _make_h264_codec_data (sps, pps);
  g_value_reset (&sps_value);
  g_value_reset (&pps_value);

  return buffer;
}

static GstCaps *
_gst_mss_stream_video_caps_from_qualitylevel_xml (xmlNodePtr node)
{
  GstCaps *caps;
  GstStructure *structure;
  gchar *fourcc = (gchar *) xmlGetProp (node, (xmlChar *) "FourCC");
  gchar *max_width = (gchar *) xmlGetProp (node, (xmlChar *) "MaxWidth");
  gchar *max_height = (gchar *) xmlGetProp (node, (xmlChar *) "MaxHeight");
  gchar *codec_data =
      (gchar *) xmlGetProp (node, (xmlChar *) "CodecPrivateData");

  caps = _gst_mss_stream_video_caps_from_fourcc (fourcc);
  if (!caps)
    goto end;

  structure = gst_caps_get_structure (caps, 0);

  if (max_width)
    gst_structure_set (structure, "width", G_TYPE_INT, atoi (max_width), NULL);
  if (max_height)
    gst_structure_set (structure, "height", G_TYPE_INT, atoi (max_height),
        NULL);

  if (codec_data) {
    GValue *value = g_new0 (GValue, 1);
    g_value_init (value, GST_TYPE_BUFFER);

    if (strcmp (fourcc, "H264") == 0) {
      GstBuffer *buf = _gst_mss_stream_create_h264_codec_data (codec_data);

      gst_value_take_buffer (value, buf);
    } else {
      gst_value_deserialize (value, (gchar *) codec_data);
    }

    gst_structure_take_value (structure, "codec_data", value);
  }

end:
  g_free (fourcc);
  g_free (max_width);
  g_free (max_height);
  g_free (codec_data);

  return caps;
}

static GstCaps *
_gst_mss_stream_audio_caps_from_qualitylevel_xml (xmlNodePtr node)
{
  GstCaps *caps;
  GstStructure *structure;
  gchar *fourcc = (gchar *) xmlGetProp (node, (xmlChar *) "FourCC");
  gchar *channels = (gchar *) xmlGetProp (node, (xmlChar *) "Channels");
  gchar *rate = (gchar *) xmlGetProp (node, (xmlChar *) "SamplingRate");
  gchar *codec_data =
      (gchar *) xmlGetProp (node, (xmlChar *) "CodecPrivateData");

  caps = _gst_mss_stream_audio_caps_from_fourcc (fourcc);
  if (!caps)
    goto end;

  structure = gst_caps_get_structure (caps, 0);

  if (channels)
    gst_structure_set (structure, "channels", G_TYPE_INT, atoi (channels),
        NULL);
  if (rate)
    gst_structure_set (structure, "rate", G_TYPE_INT, atoi (rate), NULL);

  if (codec_data) {
    GValue *value = g_new0 (GValue, 1);
    g_value_init (value, GST_TYPE_BUFFER);
    gst_value_deserialize (value, (gchar *) codec_data);
    gst_structure_take_value (structure, "codec_data", value);
  }

end:
  g_free (fourcc);
  g_free (channels);
  g_free (rate);
  g_free (codec_data);

  return caps;
}

GstCaps *
gst_mss_stream_get_caps (GstMssStream * stream)
{
  GstMssStreamType streamtype = gst_mss_stream_get_type (stream);
  xmlNodePtr qualitylevel = stream->current_quality->data;

  if (streamtype == MSS_STREAM_TYPE_VIDEO)
    return _gst_mss_stream_video_caps_from_qualitylevel_xml (qualitylevel);
  else if (streamtype == MSS_STREAM_TYPE_AUDIO)
    return _gst_mss_stream_audio_caps_from_qualitylevel_xml (qualitylevel);

  return NULL;
}

GstFlowReturn
gst_mss_stream_get_fragment_url (GstMssStream * stream, gchar ** url)
{
  gchar *tmp;
  gchar *bitrate_str;
  gchar *start_time_str;
  GstMssStreamFragment *fragment;

  if (stream->current_fragment == NULL) /* stream is over */
    return GST_FLOW_UNEXPECTED;

  fragment = stream->current_fragment->data;

  bitrate_str =
      (gchar *) xmlGetProp (stream->current_quality->data,
      (xmlChar *) MSS_PROP_BITRATE);
  start_time_str = g_strdup_printf ("%" G_GUINT64_FORMAT, fragment->time);

  tmp = g_regex_replace_literal (stream->regex_bitrate, stream->url,
      strlen (stream->url), 0, bitrate_str, 0, NULL);
  *url = g_regex_replace_literal (stream->regex_position, tmp,
      strlen (tmp), 0, start_time_str, 0, NULL);

  g_free (tmp);
  g_free (start_time_str);
  g_free (bitrate_str);
  return GST_FLOW_OK;
}

GstFlowReturn
gst_mss_stream_advance_fragment (GstMssStream * stream)
{
  if (stream->current_fragment == NULL)
    return GST_FLOW_UNEXPECTED;

  stream->current_fragment = g_list_next (stream->current_fragment);
  if (stream->current_fragment == NULL);
  return GST_FLOW_UNEXPECTED;
  return GST_FLOW_OK;
}

const gchar *
gst_mss_stream_type_name (GstMssStreamType streamtype)
{
  switch (streamtype) {
    case MSS_STREAM_TYPE_VIDEO:
      return "video";
    case MSS_STREAM_TYPE_AUDIO:
      return "audio";
    case MSS_STREAM_TYPE_UNKNOWN:
    default:
      return "unknown";
  }
}