ext/smoothstreaming/gstmssmanifest.c

   1 /* GStreamer
   2  * Copyright (C) 2012 Smart TV Alliance
   3  *  Author: Thiago Sousa Santos <thiago.sousa.santos@collabora.com>, Collabora Ltd.
   4  *
   5  * gstmssmanifest.c:
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <glib.h>
  24 #include <string.h>
  25 #include <libxml/parser.h>
  26 #include <libxml/tree.h>
  27
  28 #include "gstmssmanifest.h"
  29
  30 #define MSS_NODE_STREAM_FRAGMENT      "c"
  31 #define MSS_NODE_STREAM_QUALITY       "QualityLevel"
  32
  33 #define MSS_PROP_BITRATE              "Bitrate"
  34 #define MSS_PROP_DURATION             "d"
  35 #define MSS_PROP_NUMBER               "n"
  36 #define MSS_PROP_TIME                 "t"
  37 #define MSS_PROP_URL                  "Url"
  38
  39 /* TODO check if atoi is successful? */
  40
  41 typedef struct _GstMssStreamFragment
  42 {
  43   guint number;
  44   guint64 time;
  45   guint64 duration;
  46 } GstMssStreamFragment;
  47
  48 struct _GstMssStream
  49 {
  50   xmlNodePtr xmlnode;
  51
  52   gint selectedQualityIndex;
  53
  54   GList *fragments;
  55   GList *qualities;
  56
  57   gchar *url;
  58
  59   GList *current_fragment;
  60   GList *current_quality;
  61
  62   /* TODO move this to somewhere static */
  63   GRegex *regex_bitrate;
  64   GRegex *regex_position;
  65 };
  66
  67 struct _GstMssManifest
  68 {
  69   xmlDocPtr xml;
  70   xmlNodePtr xmlrootnode;
  71
  72   GSList *streams;
  73 };
  74
  75 static gboolean
  76 node_has_type (xmlNodePtr node, const gchar * name)
  77 {
  78   return strcmp ((gchar *) node->name, name) == 0;
  79 }
  80
  81 static void
  82 _gst_mss_stream_init (GstMssStream * stream, xmlNodePtr node)
  83 {
  84   xmlNodePtr iter;
  85   GstMssStreamFragment *previous_fragment = NULL;
  86   guint fragment_number = 0;
  87   guint fragment_time_accum = 0;
  88   GError *gerror = NULL;
  89
  90   stream->xmlnode = node;
  91
  92   /* get the base url path generator */
  93   stream->url = (gchar *) xmlGetProp (node, (xmlChar *) MSS_PROP_URL);
  94
  95   for (iter = node->children; iter; iter = iter->next) {
  96     if (node_has_type (iter, MSS_NODE_STREAM_FRAGMENT)) {
  97       gchar *duration_str;
  98       gchar *time_str;
  99       gchar *seqnum_str;
 100       GstMssStreamFragment *fragment = g_new (GstMssStreamFragment, 1);
 101
 102       duration_str = (gchar *) xmlGetProp (iter, (xmlChar *) MSS_PROP_DURATION);
 103       time_str = (gchar *) xmlGetProp (iter, (xmlChar *) MSS_PROP_TIME);
 104       seqnum_str = (gchar *) xmlGetProp (iter, (xmlChar *) MSS_PROP_NUMBER);
 105
 106       /* use the node's seq number or use the previous + 1 */
 107       if (seqnum_str) {
 108         fragment->number = atoi (seqnum_str);
 109         g_free (seqnum_str);
 110       } else {
 111         fragment->number = fragment_number;
 112       }
 113       fragment_number = fragment->number + 1;
 114
 115       if (time_str) {
 116         fragment->time = atoi (time_str);
 117         g_free (time_str);
 118       } else {
 119         fragment->time = fragment_time_accum;
 120       }
 121
 122       /* if we have a previous fragment, means we need to set its duration */
 123       if (previous_fragment)
 124         previous_fragment->duration = fragment->time - previous_fragment->time;
 125
 126       if (duration_str) {
 127         fragment->duration = atoi (duration_str);
 128
 129         previous_fragment = NULL;
 130         fragment_time_accum += fragment->duration;
 131         g_free (duration_str);
 132       } else {
 133         /* store to set the duration at the next iteration */
 134         previous_fragment = fragment;
 135       }
 136
 137       /* we reverse it later */
 138       stream->fragments = g_list_prepend (stream->fragments, fragment);
 139
 140     } else if (node_has_type (iter, MSS_NODE_STREAM_QUALITY)) {
 141       stream->qualities = g_list_prepend (stream->qualities, iter);
 142     } else {
 143       /* TODO gst log this */
 144     }
 145   }
 146
 147   stream->fragments = g_list_reverse (stream->fragments);
 148   stream->qualities = g_list_reverse (stream->qualities);
 149
 150   stream->current_fragment = stream->fragments;
 151   stream->current_quality = stream->qualities;
 152
 153   stream->regex_bitrate = g_regex_new ("\\{[Bb]itrate\\}", 0, 0, &gerror);
 154   stream->regex_position = g_regex_new ("\\{start[ _]time\\}", 0, 0, &gerror);
 155 }
 156
 157 GstMssManifest *
 158 gst_mss_manifest_new (const GstBuffer * data)
 159 {
 160   GstMssManifest *manifest;
 161   xmlNodePtr root;
 162   xmlNodePtr nodeiter;
 163
 164   manifest = g_malloc0 (sizeof (GstMssManifest));
 165
 166   manifest->xml = xmlReadMemory ((const gchar *) GST_BUFFER_DATA (data),
 167       GST_BUFFER_SIZE (data), "manifest", NULL, 0);
 168   root = manifest->xmlrootnode = xmlDocGetRootElement (manifest->xml);
 169
 170   for (nodeiter = root->children; nodeiter; nodeiter = nodeiter->next) {
 171     if (nodeiter->type == XML_ELEMENT_NODE
 172         && (strcmp ((const char *) nodeiter->name, "StreamIndex") == 0)) {
 173       GstMssStream *stream = g_new0 (GstMssStream, 1);
 174
 175       manifest->streams = g_slist_append (manifest->streams, stream);
 176       _gst_mss_stream_init (stream, nodeiter);
 177     }
 178   }
 179
 180   return manifest;
 181 }
 182
 183 static void
 184 gst_mss_stream_free (GstMssStream * stream)
 185 {
 186   g_list_free_full (stream->fragments, g_free);
 187   g_list_free (stream->qualities);
 188   g_free (stream->url);
 189   g_regex_unref (stream->regex_position);
 190   g_regex_unref (stream->regex_bitrate);
 191   g_free (stream);
 192 }
 193
 194 void
 195 gst_mss_manifest_free (GstMssManifest * manifest)
 196 {
 197   g_return_if_fail (manifest != NULL);
 198
 199   g_slist_free_full (manifest->streams, (GDestroyNotify) gst_mss_stream_free);
 200
 201   xmlFreeDoc (manifest->xml);
 202   g_free (manifest);
 203 }
 204
 205 GSList *
 206 gst_mss_manifest_get_streams (GstMssManifest * manifest)
 207 {
 208   return manifest->streams;
 209 }
 210
 211 GstMssStreamType
 212 gst_mss_stream_get_type (GstMssStream * stream)
 213 {
 214   gchar *prop = (gchar *) xmlGetProp (stream->xmlnode, (xmlChar *) "Type");
 215   GstMssStreamType ret = MSS_STREAM_TYPE_UNKNOWN;
 216
 217   if (strcmp (prop, "video") == 0) {
 218     ret = MSS_STREAM_TYPE_VIDEO;
 219   } else if (strcmp (prop, "audio") == 0) {
 220     ret = MSS_STREAM_TYPE_AUDIO;
 221   }
 222   xmlFree (prop);
 223   return ret;
 224 }
 225
 226 static GstCaps *
 227 _gst_mss_stream_video_caps_from_fourcc (gchar * fourcc)
 228 {
 229   if (!fourcc)
 230     return NULL;
 231
 232   if (strcmp (fourcc, "H264") == 0) {
 233     return gst_caps_new_simple ("video/x-h264", NULL);
 234   }
 235   return NULL;
 236 }
 237
 238 static GstCaps *
 239 _gst_mss_stream_audio_caps_from_fourcc (gchar * fourcc)
 240 {
 241   if (!fourcc)
 242     return NULL;
 243
 244   if (strcmp (fourcc, "AACL") == 0) {
 245     return gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, 4,
 246         NULL);
 247   }
 248   return NULL;
 249 }
 250
 251 static GstCaps *
 252 _gst_mss_stream_video_caps_from_qualitylevel_xml (xmlNodePtr node)
 253 {
 254   GstCaps *caps;
 255   GstStructure *structure;
 256   gchar *fourcc = (gchar *) xmlGetProp (node, (xmlChar *) "FourCC");
 257   gchar *max_width = (gchar *) xmlGetProp (node, (xmlChar *) "MaxWidth");
 258   gchar *max_height = (gchar *) xmlGetProp (node, (xmlChar *) "MaxHeight");
 259   gchar *codec_data =
 260       (gchar *) xmlGetProp (node, (xmlChar *) "CodecPrivateData");
 261
 262   caps = _gst_mss_stream_video_caps_from_fourcc (fourcc);
 263   if (!caps)
 264     goto end;
 265
 266   structure = gst_caps_get_structure (caps, 0);
 267
 268   if (max_width)
 269     gst_structure_set (structure, "width", G_TYPE_INT, atoi (max_width), NULL);
 270   if (max_height)
 271     gst_structure_set (structure, "height", G_TYPE_INT, atoi (max_height),
 272         NULL);
 273
 274   if (codec_data) {
 275     GValue *value = g_new0 (GValue, 1);
 276     g_value_init (value, GST_TYPE_BUFFER);
 277     gst_value_deserialize (value, (gchar *) codec_data);
 278     gst_structure_take_value (structure, "codec_data", value);
 279   }
 280
 281 end:
 282   g_free (fourcc);
 283   g_free (max_width);
 284   g_free (max_height);
 285   g_free (codec_data);
 286
 287   return caps;
 288 }
 289
 290 static GstCaps *
 291 _gst_mss_stream_audio_caps_from_qualitylevel_xml (xmlNodePtr node)
 292 {
 293   GstCaps *caps;
 294   GstStructure *structure;
 295   gchar *fourcc = (gchar *) xmlGetProp (node, (xmlChar *) "FourCC");
 296   gchar *channels = (gchar *) xmlGetProp (node, (xmlChar *) "Channels");
 297   gchar *rate = (gchar *) xmlGetProp (node, (xmlChar *) "SamplingRate");
 298   gchar *codec_data =
 299       (gchar *) xmlGetProp (node, (xmlChar *) "CodecPrivateData");
 300
 301   caps = _gst_mss_stream_audio_caps_from_fourcc (fourcc);
 302   if (!caps)
 303     goto end;
 304
 305   structure = gst_caps_get_structure (caps, 0);
 306
 307   if (channels)
 308     gst_structure_set (structure, "channels", G_TYPE_INT, atoi (channels),
 309         NULL);
 310   if (rate)
 311     gst_structure_set (structure, "rate", G_TYPE_INT, atoi (rate), NULL);
 312
 313   if (codec_data) {
 314     GValue *value = g_new0 (GValue, 1);
 315     g_value_init (value, GST_TYPE_BUFFER);
 316     gst_value_deserialize (value, (gchar *) codec_data);
 317     gst_structure_take_value (structure, "codec_data", value);
 318   }
 319
 320 end:
 321   g_free (fourcc);
 322   g_free (channels);
 323   g_free (rate);
 324   g_free (codec_data);
 325
 326   return caps;
 327 }
 328
 329 GstCaps *
 330 gst_mss_stream_get_caps (GstMssStream * stream)
 331 {
 332   GstMssStreamType streamtype = gst_mss_stream_get_type (stream);
 333   xmlNodePtr qualitylevel = stream->current_quality->data;
 334
 335   if (streamtype == MSS_STREAM_TYPE_VIDEO)
 336     return _gst_mss_stream_video_caps_from_qualitylevel_xml (qualitylevel);
 337   else if (streamtype == MSS_STREAM_TYPE_AUDIO)
 338     return _gst_mss_stream_audio_caps_from_qualitylevel_xml (qualitylevel);
 339
 340   return NULL;
 341 }
 342
 343 GstFlowReturn
 344 gst_mss_stream_get_fragment_url (GstMssStream * stream, gchar ** url)
 345 {
 346   gchar *tmp;
 347   gchar *bitrate_str;
 348   gchar *start_time_str;
 349   GstMssStreamFragment *fragment;
 350
 351   if (stream->current_fragment == NULL) /* stream is over */
 352     return GST_FLOW_UNEXPECTED;
 353
 354   fragment = stream->current_fragment->data;
 355
 356   bitrate_str =
 357       (gchar *) xmlGetProp (stream->current_quality->data,
 358       (xmlChar *) MSS_PROP_BITRATE);
 359   start_time_str = g_strdup_printf ("%" G_GUINT64_FORMAT, fragment->time);
 360
 361   tmp = g_regex_replace_literal (stream->regex_bitrate, stream->url,
 362       strlen (stream->url), 0, bitrate_str, 0, NULL);
 363   *url = g_regex_replace_literal (stream->regex_position, tmp,
 364       strlen (tmp), 0, start_time_str, 0, NULL);
 365
 366   g_free (tmp);
 367   g_free (start_time_str);
 368   g_free (bitrate_str);
 369   return GST_FLOW_OK;
 370 }
 371
 372 GstFlowReturn
 373 gst_mss_stream_advance_fragment (GstMssStream * stream)
 374 {
 375   if (stream->current_fragment == NULL)
 376     return GST_FLOW_UNEXPECTED;
 377
 378   stream->current_fragment = g_list_next (stream->current_fragment);
 379   if (stream->current_fragment == NULL);
 380   return GST_FLOW_UNEXPECTED;
 381   return GST_FLOW_OK;
 382 }
 383
 384 const gchar *
 385 gst_mss_stream_type_name (GstMssStreamType streamtype)
 386 {
 387   switch (streamtype) {
 388     case MSS_STREAM_TYPE_VIDEO:
 389       return "video";
 390     case MSS_STREAM_TYPE_AUDIO:
 391       return "audio";
 392     case MSS_STREAM_TYPE_UNKNOWN:
 393     default:
 394       return "unknown";
 395   }
 396 }