mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-22 16:26:39 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/ext/smoothstreaming/gstmssmanifest.c

1682 lines
46 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 2012 Smart TV Alliance
* Copyright (C) 2016 Igalia S.L
* Copyright (C) 2016 Metrological
* 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 <stdio.h>
#include <ctype.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
/* for parsing h264 codec data */
#include <gst/codecparsers/gsth264parser.h>
#include "gstmssmanifest.h"
#include "gstmssfragmentparser.h"
GST_DEBUG_CATEGORY_EXTERN (mssdemux_debug);
#define GST_CAT_DEFAULT mssdemux_debug
#define DEFAULT_TIMESCALE 10000000
#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_DVR_WINDOW_LENGTH "DVRWindowLength"
#define MSS_PROP_LANGUAGE "Language"
#define MSS_PROP_NUMBER "n"
#define MSS_PROP_REPETITIONS "r"
#define MSS_PROP_STREAM_DURATION "Duration"
#define MSS_PROP_TIME "t"
#define MSS_PROP_TIMESCALE "TimeScale"
#define MSS_PROP_URL "Url"
#define GST_MSSMANIFEST_LIVE_MIN_FRAGMENT_DISTANCE 3
typedef struct _GstMssStreamFragment
{
guint number;
guint64 time;
guint64 duration;
guint repetitions;
} GstMssStreamFragment;
typedef struct _GstMssStreamQuality
{
xmlNodePtr xmlnode;
gchar *bitrate_str;
guint64 bitrate;
} GstMssStreamQuality;
struct _GstMssStream
{
xmlNodePtr xmlnode;
gboolean active; /* if the stream is currently being used */
gint selectedQualityIndex;
gboolean has_live_fragments;
GstAdapter *live_adapter;
GList *fragments;
GList *qualities;
gchar *url;
gchar *lang;
GstMssFragmentParser fragment_parser;
guint fragment_repetition_index;
GList *current_fragment;
GList *current_quality;
/* TODO move this to somewhere static */
GRegex *regex_bitrate;
GRegex *regex_position;
};
struct _GstMssManifest
{
xmlDocPtr xml;
xmlNodePtr xmlrootnode;
gboolean is_live;
gint64 dvr_window;
guint64 look_ahead_fragment_count;
GString *protection_system_id;
gchar *protection_data;
GSList *streams;
};
/* For parsing and building a fragments list */
typedef struct _GstMssFragmentListBuilder
{
GList *fragments;
GstMssStreamFragment *previous_fragment;
guint fragment_number;
guint64 fragment_time_accum;
} GstMssFragmentListBuilder;
static void
gst_mss_fragment_list_builder_init (GstMssFragmentListBuilder * builder)
{
builder->fragments = NULL;
builder->previous_fragment = NULL;
builder->fragment_time_accum = 0;
builder->fragment_number = 0;
}
static void
gst_mss_fragment_list_builder_add (GstMssFragmentListBuilder * builder,
xmlNodePtr node)
{
gchar *duration_str;
gchar *time_str;
gchar *seqnum_str;
gchar *repetition_str;
GstMssStreamFragment *fragment = g_new (GstMssStreamFragment, 1);
duration_str = (gchar *) xmlGetProp (node, (xmlChar *) MSS_PROP_DURATION);
time_str = (gchar *) xmlGetProp (node, (xmlChar *) MSS_PROP_TIME);
seqnum_str = (gchar *) xmlGetProp (node, (xmlChar *) MSS_PROP_NUMBER);
repetition_str =
(gchar *) xmlGetProp (node, (xmlChar *) MSS_PROP_REPETITIONS);
/* use the node's seq number or use the previous + 1 */
if (seqnum_str) {
fragment->number = g_ascii_strtoull (seqnum_str, NULL, 10);
xmlFree (seqnum_str);
builder->fragment_number = fragment->number;
} else {
fragment->number = builder->fragment_number;
}
builder->fragment_number = fragment->number + 1;
if (repetition_str) {
fragment->repetitions = g_ascii_strtoull (repetition_str, NULL, 10);
xmlFree (repetition_str);
} else {
fragment->repetitions = 1;
}
if (time_str) {
fragment->time = g_ascii_strtoull (time_str, NULL, 10);
xmlFree (time_str);
builder->fragment_time_accum = fragment->time;
} else {
fragment->time = builder->fragment_time_accum;
}
/* if we have a previous fragment, means we need to set its duration */
if (builder->previous_fragment)
builder->previous_fragment->duration =
(fragment->time -
builder->previous_fragment->time) /
builder->previous_fragment->repetitions;
if (duration_str) {
fragment->duration = g_ascii_strtoull (duration_str, NULL, 10);
builder->previous_fragment = NULL;
builder->fragment_time_accum += fragment->duration * fragment->repetitions;
xmlFree (duration_str);
} else {
/* store to set the duration at the next iteration */
builder->previous_fragment = fragment;
}
/* we reverse it later */
builder->fragments = g_list_prepend (builder->fragments, fragment);
GST_LOG ("Adding fragment number: %u, time: %" G_GUINT64_FORMAT
", duration: %" G_GUINT64_FORMAT ", repetitions: %u",
fragment->number, fragment->time, fragment->duration,
fragment->repetitions);
}
static GstBuffer *gst_buffer_from_hex_string (const gchar * s);
static gboolean
node_has_type (xmlNodePtr node, const gchar * name)
{
return strcmp ((gchar *) node->name, name) == 0;
}
static GstMssStreamQuality *
gst_mss_stream_quality_new (xmlNodePtr node)
{
GstMssStreamQuality *q = g_slice_new (GstMssStreamQuality);
q->xmlnode = node;
q->bitrate_str = (gchar *) xmlGetProp (node, (xmlChar *) MSS_PROP_BITRATE);
if (q->bitrate_str != NULL)
q->bitrate = g_ascii_strtoull (q->bitrate_str, NULL, 10);
else
q->bitrate = 0;
return q;
}
static void
gst_mss_stream_quality_free (GstMssStreamQuality * quality)
{
g_return_if_fail (quality != NULL);
xmlFree (quality->bitrate_str);
g_slice_free (GstMssStreamQuality, quality);
}
static gint
compare_bitrate (GstMssStreamQuality * a, GstMssStreamQuality * b)
{
if (a->bitrate > b->bitrate)
return 1;
if (a->bitrate < b->bitrate)
return -1;
return 0;
}
static void
_gst_mss_stream_init (GstMssManifest * manifest, GstMssStream * stream,
xmlNodePtr node)
{
xmlNodePtr iter;
GstMssFragmentListBuilder builder;
gst_mss_fragment_list_builder_init (&builder);
stream->xmlnode = node;
/* get the base url path generator */
stream->url = (gchar *) xmlGetProp (node, (xmlChar *) MSS_PROP_URL);
stream->lang = (gchar *) xmlGetProp (node, (xmlChar *) MSS_PROP_LANGUAGE);
/* for live playback each fragment usually has timing
* information for the few next look-ahead fragments so the
* playlist can be built incrementally from the first fragment
* of the manifest.
*/
GST_DEBUG ("Live stream: %s, look-ahead fragments: %" G_GUINT64_FORMAT,
manifest->is_live ? "yes" : "no", manifest->look_ahead_fragment_count);
stream->has_live_fragments = manifest->is_live
&& manifest->look_ahead_fragment_count;
for (iter = node->children; iter; iter = iter->next) {
if (node_has_type (iter, MSS_NODE_STREAM_FRAGMENT)) {
gst_mss_fragment_list_builder_add (&builder, iter);
} else if (node_has_type (iter, MSS_NODE_STREAM_QUALITY)) {
GstMssStreamQuality *quality = gst_mss_stream_quality_new (iter);
stream->qualities = g_list_prepend (stream->qualities, quality);
} else {
/* TODO gst log this */
}
}
if (stream->has_live_fragments) {
stream->live_adapter = gst_adapter_new ();
}
if (builder.fragments) {
stream->fragments = g_list_reverse (builder.fragments);
if (manifest->is_live) {
GList *iter = g_list_last (stream->fragments);
gint i;
for (i = 0; i < GST_MSSMANIFEST_LIVE_MIN_FRAGMENT_DISTANCE; i++) {
if (g_list_previous (iter)) {
iter = g_list_previous (iter);
} else {
break;
}
}
stream->current_fragment = iter;
} else {
stream->current_fragment = stream->fragments;
}
}
/* order them from smaller to bigger based on bitrates */
stream->qualities =
g_list_sort (stream->qualities, (GCompareFunc) compare_bitrate);
stream->current_quality = stream->qualities;
stream->regex_bitrate = g_regex_new ("\\{[Bb]itrate\\}", 0, 0, NULL);
stream->regex_position = g_regex_new ("\\{start[ _]time\\}", 0, 0, NULL);
gst_mss_fragment_parser_init (&stream->fragment_parser);
}
static void
_gst_mss_parse_protection (GstMssManifest * manifest,
xmlNodePtr protection_node)
{
xmlNodePtr nodeiter;
for (nodeiter = protection_node->children; nodeiter;
nodeiter = nodeiter->next) {
if (nodeiter->type == XML_ELEMENT_NODE
&& (strcmp ((const char *) nodeiter->name, "ProtectionHeader") == 0)) {
xmlChar *system_id_attribute =
xmlGetProp (nodeiter, (xmlChar *) "SystemID");
gchar *value = (gchar *) system_id_attribute;
int id_len = strlen (value);
GString *system_id;
if (value[0] == '{') {
value++;
id_len--;
}
system_id = g_string_new (value);
system_id = g_string_ascii_down (system_id);
if (value[id_len - 1] == '}')
system_id = g_string_truncate (system_id, id_len - 1);
manifest->protection_system_id = system_id;
manifest->protection_data = (gchar *) xmlNodeGetContent (nodeiter);
xmlFree (system_id_attribute);
break;
}
}
}
GstMssManifest *
gst_mss_manifest_new (GstBuffer * data)
{
GstMssManifest *manifest;
xmlNodePtr root;
xmlNodePtr nodeiter;
gchar *live_str;
GstMapInfo mapinfo;
gchar *look_ahead_fragment_count_str;
if (!gst_buffer_map (data, &mapinfo, GST_MAP_READ)) {
return NULL;
}
manifest = g_malloc0 (sizeof (GstMssManifest));
manifest->xml = xmlReadMemory ((const gchar *) mapinfo.data,
mapinfo.size, "manifest", NULL, 0);
root = manifest->xmlrootnode = xmlDocGetRootElement (manifest->xml);
if (root == NULL) {
GST_WARNING ("No root node ! Invalid manifest");
gst_mss_manifest_free (manifest);
return NULL;
}
live_str = (gchar *) xmlGetProp (root, (xmlChar *) "IsLive");
if (live_str) {
manifest->is_live = g_ascii_strcasecmp (live_str, "true") == 0;
xmlFree (live_str);
}
/* the entire file is always available for non-live streams */
if (!manifest->is_live) {
manifest->dvr_window = 0;
manifest->look_ahead_fragment_count = 0;
} else {
/* if 0, or non-existent, the length is infinite */
gchar *dvr_window_str = (gchar *) xmlGetProp (root,
(xmlChar *) MSS_PROP_DVR_WINDOW_LENGTH);
if (dvr_window_str) {
manifest->dvr_window = g_ascii_strtoull (dvr_window_str, NULL, 10);
xmlFree (dvr_window_str);
if (manifest->dvr_window <= 0) {
manifest->dvr_window = 0;
}
}
look_ahead_fragment_count_str =
(gchar *) xmlGetProp (root, (xmlChar *) "LookAheadFragmentCount");
if (look_ahead_fragment_count_str) {
manifest->look_ahead_fragment_count =
g_ascii_strtoull (look_ahead_fragment_count_str, NULL, 10);
xmlFree (look_ahead_fragment_count_str);
if (manifest->look_ahead_fragment_count <= 0) {
manifest->look_ahead_fragment_count = 0;
}
}
}
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 (manifest, stream, nodeiter);
}
if (nodeiter->type == XML_ELEMENT_NODE
&& (strcmp ((const char *) nodeiter->name, "Protection") == 0)) {
_gst_mss_parse_protection (manifest, nodeiter);
}
}
gst_buffer_unmap (data, &mapinfo);
return manifest;
}
static void
gst_mss_stream_free (GstMssStream * stream)
{
if (stream->live_adapter) {
gst_adapter_clear (stream->live_adapter);
g_object_unref (stream->live_adapter);
}
g_list_free_full (stream->fragments, g_free);
g_list_free_full (stream->qualities,
(GDestroyNotify) gst_mss_stream_quality_free);
xmlFree (stream->url);
xmlFree (stream->lang);
g_regex_unref (stream->regex_position);
g_regex_unref (stream->regex_bitrate);
gst_mss_fragment_parser_clear (&stream->fragment_parser);
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);
if (manifest->protection_system_id != NULL)
g_string_free (manifest->protection_system_id, TRUE);
xmlFree (manifest->protection_data);
xmlFreeDoc (manifest->xml);
g_free (manifest);
}
const gchar *
gst_mss_manifest_get_protection_system_id (GstMssManifest * manifest)
{
if (manifest->protection_system_id != NULL)
return manifest->protection_system_id->str;
return NULL;
}
const gchar *
gst_mss_manifest_get_protection_data (GstMssManifest * manifest)
{
return manifest->protection_data;
}
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 (prop == NULL)
return 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;
} else {
GST_DEBUG ("Unsupported stream type: %s", prop);
}
xmlFree (prop);
return ret;
}
static GstCaps *
_gst_mss_stream_video_caps_from_fourcc (gchar * fourcc)
{
if (!fourcc)
return NULL;
if (strcmp (fourcc, "H264") == 0 || strcmp (fourcc, "AVC1") == 0) {
return gst_caps_new_simple ("video/x-h264", "stream-format", G_TYPE_STRING,
"avc", NULL);
} else if (strcmp (fourcc, "WVC1") == 0) {
return gst_caps_new_simple ("video/x-wmv", "wmvversion", G_TYPE_INT, 3,
"format", G_TYPE_STRING, "WVC1", 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);
} else if (strcmp (fourcc, "WmaPro") == 0 || strcmp (fourcc, "WMAP") == 0) {
return gst_caps_new_simple ("audio/x-wma", "wmaversion", G_TYPE_INT, 3,
NULL);
}
return NULL;
}
static GstCaps *
_gst_mss_stream_audio_caps_from_audio_tag (gint audiotag)
{
switch (audiotag) {
case 83: /* MP3 */
return gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, 1,
"layer", G_TYPE_INT, 3, NULL);
case 255: /* AAC */
return gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, 4,
NULL);
default:
break;
}
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;
GstMapInfo spsinfo, ppsinfo, codecdatainfo;
if (gst_buffer_get_size (sps) < 4)
return NULL;
gst_buffer_map (sps, &spsinfo, GST_MAP_READ);
gst_buffer_map (pps, &ppsinfo, GST_MAP_READ);
sps_size += spsinfo.size + 2;
profile_idc = spsinfo.data[1];
profile_comp = spsinfo.data[2];
level_idc = spsinfo.data[3];
num_sps = 1;
pps_size += ppsinfo.size + 2;
num_pps = 1;
buf = gst_buffer_new_and_alloc (5 + 1 + sps_size + 1 + pps_size);
gst_buffer_map (buf, &codecdatainfo, GST_MAP_WRITE);
data = codecdatainfo.data;
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, spsinfo.size);
memcpy (data + 2, spsinfo.data, spsinfo.size);
data += 2 + spsinfo.size;
data[0] = num_pps;
data++;
GST_WRITE_UINT16_BE (data, ppsinfo.size);
memcpy (data + 2, ppsinfo.data, ppsinfo.size);
data += 2 + ppsinfo.size;
gst_buffer_unmap (sps, &spsinfo);
gst_buffer_unmap (pps, &ppsinfo);
gst_buffer_unmap (buf, &codecdatainfo);
return buf;
}
static void
_gst_mss_stream_add_h264_codec_data (GstCaps * caps, const gchar * codecdatastr)
{
GstBuffer *sps;
GstBuffer *pps;
GstBuffer *buffer;
gchar *sps_str;
gchar *pps_str;
GstH264NalUnit nalu = { 0, };
GstH264SPS sps_struct;
GstH264ParserResult parseres;
GstMapInfo spsinfo;
/* search for the sps start */
if (g_str_has_prefix (codecdatastr, "00000001")) {
sps_str = (gchar *) codecdatastr + 8;
} else {
return; /* invalid mss codec data */
}
/* search for the pps start */
pps_str = g_strstr_len (sps_str, -1, "00000001");
if (!pps_str) {
return; /* invalid mss codec data */
}
pps_str[0] = '\0';
sps = gst_buffer_from_hex_string (sps_str);
pps_str[0] = '0';
pps_str = pps_str + 8;
pps = gst_buffer_from_hex_string (pps_str);
gst_buffer_map (sps, &spsinfo, GST_MAP_READ);
nalu.ref_idc = (spsinfo.data[0] & 0x60) >> 5;
nalu.type = GST_H264_NAL_SPS;
nalu.size = spsinfo.size - 1;
nalu.data = spsinfo.data + 1;
nalu.offset = 0;
nalu.sc_offset = 0;
nalu.valid = TRUE;
nalu.header_bytes = 0;
nalu.extension_type = GST_H264_NAL_EXTENSION_NONE;
parseres = gst_h264_parse_sps (&nalu, &sps_struct);
if (parseres == GST_H264_PARSER_OK) {
gint fps_num, fps_den;
/* MSS apparently only supports non-interlaced/progressive H.264 content */
gst_h264_video_calculate_framerate (&sps_struct, 0, 0, &fps_num, &fps_den);
gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION,
fps_num, fps_den, NULL);
}
buffer = _make_h264_codec_data (sps, pps);
gst_buffer_unmap (sps, &spsinfo);
gst_buffer_unref (sps);
gst_buffer_unref (pps);
if (buffer != NULL) {
gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, buffer, NULL);
gst_buffer_unref (buffer);
}
}
static GstCaps *
_gst_mss_stream_video_caps_from_qualitylevel_xml (GstMssStreamQuality * q)
{
xmlNodePtr node = q->xmlnode;
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");
if (!max_width)
max_width = (gchar *) xmlGetProp (node, (xmlChar *) "Width");
if (!max_height)
max_height = (gchar *) xmlGetProp (node, (xmlChar *) "Height");
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,
(int) g_ascii_strtoull (max_width, NULL, 10), NULL);
}
if (max_height) {
gst_structure_set (structure, "height", G_TYPE_INT,
(int) g_ascii_strtoull (max_height, NULL, 10), NULL);
}
if (codec_data && strlen (codec_data)) {
if (strcmp (fourcc, "H264") == 0 || strcmp (fourcc, "AVC1") == 0) {
_gst_mss_stream_add_h264_codec_data (caps, codec_data);
} else {
GstBuffer *buffer = gst_buffer_from_hex_string ((gchar *) codec_data);
gst_structure_set (structure, "codec_data", GST_TYPE_BUFFER, buffer,
NULL);
gst_buffer_unref (buffer);
}
}
end:
xmlFree (fourcc);
xmlFree (max_width);
xmlFree (max_height);
xmlFree (codec_data);
return caps;
}
static guint8
_frequency_index_from_sampling_rate (guint sampling_rate)
{
static const guint aac_sample_rates[] = { 96000, 88200, 64000, 48000, 44100,
32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350
};
guint8 i;
for (i = 0; i < G_N_ELEMENTS (aac_sample_rates); i++) {
if (aac_sample_rates[i] == sampling_rate)
return i;
}
return 15;
}
static GstBuffer *
_make_aacl_codec_data (guint64 sampling_rate, guint64 channels)
{
GstBuffer *buf;
guint8 *data;
guint8 frequency_index;
guint8 buf_size;
GstMapInfo info;
buf_size = 2;
frequency_index = _frequency_index_from_sampling_rate (sampling_rate);
if (frequency_index == 15)
buf_size += 3;
buf = gst_buffer_new_and_alloc (buf_size);
gst_buffer_map (buf, &info, GST_MAP_WRITE);
data = info.data;
data[0] = 2 << 3; /* AAC-LC object type is 2 */
data[0] += frequency_index >> 1;
data[1] = (frequency_index & 0x01) << 7;
/* Sampling rate is not in frequencies table, write manually */
if (frequency_index == 15) {
data[1] += sampling_rate >> 17;
data[2] = (sampling_rate >> 9) & 0xFF;
data[3] = (sampling_rate >> 1) & 0xFF;
data[4] = sampling_rate & 0x01;
data += 3;
}
data[1] += (channels & 0x0F) << 3;
gst_buffer_unmap (buf, &info);
return buf;
}
static GstCaps *
_gst_mss_stream_audio_caps_from_qualitylevel_xml (GstMssStreamQuality * q)
{
xmlNodePtr node = q->xmlnode;
GstCaps *caps = NULL;
GstStructure *structure;
gchar *fourcc = (gchar *) xmlGetProp (node, (xmlChar *) "FourCC");
gchar *audiotag = (gchar *) xmlGetProp (node, (xmlChar *) "AudioTag");
gchar *channels_str = (gchar *) xmlGetProp (node, (xmlChar *) "Channels");
gchar *rate_str = (gchar *) xmlGetProp (node, (xmlChar *) "SamplingRate");
gchar *depth_str = (gchar *) xmlGetProp (node, (xmlChar *) "BitsPerSample");
gchar *block_align_str =
(gchar *) xmlGetProp (node, (xmlChar *) "PacketSize");
gchar *codec_data_str =
(gchar *) xmlGetProp (node, (xmlChar *) "CodecPrivateData");
GstBuffer *codec_data = NULL;
gint depth = 0;
gint block_align = 0;
gint rate = 0;
gint channels = 0;
gint atag = 0;
if (!fourcc) /* sometimes the fourcc is omitted, we fallback to the Subtype in the StreamIndex node */
fourcc = (gchar *) xmlGetProp (node->parent, (xmlChar *) "Subtype");
if (fourcc) {
caps = _gst_mss_stream_audio_caps_from_fourcc (fourcc);
} else if (audiotag) {
atag = g_ascii_strtoull (audiotag, NULL, 10);
caps = _gst_mss_stream_audio_caps_from_audio_tag (atag);
}
if (!caps)
goto end;
structure = gst_caps_get_structure (caps, 0);
if (codec_data_str && strlen (codec_data_str)) {
codec_data = gst_buffer_from_hex_string ((gchar *) codec_data_str);
}
if (rate_str)
rate = (gint) g_ascii_strtoull (rate_str, NULL, 10);
if (channels_str)
channels = (int) g_ascii_strtoull (channels_str, NULL, 10);
if (depth_str)
depth = (gint) g_ascii_strtoull (depth_str, NULL, 10);
if (block_align_str)
block_align = (int) g_ascii_strtoull (block_align_str, NULL, 10);
if (!codec_data) {
gint codec_data_len;
codec_data_str = (gchar *) xmlGetProp (node, (xmlChar *) "WaveFormatEx");
if (codec_data_str != NULL) {
codec_data_len = strlen (codec_data_str) / 2;
/* a WAVEFORMATEX structure is 18 bytes */
if (codec_data_str && codec_data_len >= 18) {
GstMapInfo mapinfo;
codec_data = gst_buffer_from_hex_string ((gchar *) codec_data_str);
/* since this is a WAVEFORMATEX, try to get the block_align and rate */
gst_buffer_map (codec_data, &mapinfo, GST_MAP_READ);
if (!channels_str) {
channels = GST_READ_UINT16_LE (mapinfo.data + 2);
}
if (!rate_str) {
rate = GST_READ_UINT32_LE (mapinfo.data + 4);
}
if (!block_align) {
block_align = GST_READ_UINT16_LE (mapinfo.data + 12);
}
if (!depth) {
depth = GST_READ_UINT16_LE (mapinfo.data + 14);
}
gst_buffer_unmap (codec_data, &mapinfo);
/* Consume all the WAVEFORMATEX structure, and pass only the rest of
* the data as the codec private data */
gst_buffer_resize (codec_data, 18, -1);
} else {
GST_WARNING ("Dropping WaveFormatEx: data is %d bytes, "
"but at least 18 bytes are expected", codec_data_len);
}
}
}
if (!codec_data && ((fourcc && strcmp (fourcc, "AACL") == 0) || atag == 255)
&& rate && channels) {
codec_data = _make_aacl_codec_data (rate, channels);
}
if (block_align)
gst_structure_set (structure, "block_align", G_TYPE_INT, block_align, NULL);
if (channels)
gst_structure_set (structure, "channels", G_TYPE_INT, channels, NULL);
if (rate)
gst_structure_set (structure, "rate", G_TYPE_INT, rate, NULL);
if (depth)
gst_structure_set (structure, "depth", G_TYPE_INT, depth, NULL);
if (q->bitrate)
gst_structure_set (structure, "bitrate", G_TYPE_INT, (int) q->bitrate,
NULL);
if (codec_data)
gst_structure_set (structure, "codec_data", GST_TYPE_BUFFER, codec_data,
NULL);
end:
if (codec_data)
gst_buffer_unref (codec_data);
xmlFree (fourcc);
xmlFree (audiotag);
xmlFree (channels_str);
xmlFree (rate_str);
xmlFree (depth_str);
xmlFree (block_align_str);
xmlFree (codec_data_str);
return caps;
}
void
gst_mss_stream_set_active (GstMssStream * stream, gboolean active)
{
stream->active = active;
}
guint64
gst_mss_stream_get_timescale (GstMssStream * stream)
{
gchar *timescale;
guint64 ts = DEFAULT_TIMESCALE;
timescale =
(gchar *) xmlGetProp (stream->xmlnode, (xmlChar *) MSS_PROP_TIMESCALE);
if (!timescale) {
timescale =
(gchar *) xmlGetProp (stream->xmlnode->parent,
(xmlChar *) MSS_PROP_TIMESCALE);
}
if (timescale) {
ts = g_ascii_strtoull (timescale, NULL, 10);
xmlFree (timescale);
}
return ts;
}
guint64
gst_mss_manifest_get_timescale (GstMssManifest * manifest)
{
gchar *timescale;
guint64 ts = DEFAULT_TIMESCALE;
timescale =
(gchar *) xmlGetProp (manifest->xmlrootnode,
(xmlChar *) MSS_PROP_TIMESCALE);
if (timescale) {
ts = g_ascii_strtoull (timescale, NULL, 10);
xmlFree (timescale);
}
return ts;
}
guint64
gst_mss_manifest_get_duration (GstMssManifest * manifest)
{
gchar *duration;
guint64 dur = 0;
/* try the property */
duration =
(gchar *) xmlGetProp (manifest->xmlrootnode,
(xmlChar *) MSS_PROP_STREAM_DURATION);
if (duration) {
dur = g_ascii_strtoull (duration, NULL, 10);
xmlFree (duration);
}
/* else use the fragment list */
if (dur <= 0) {
guint64 max_dur = 0;
GSList *iter;
for (iter = manifest->streams; iter; iter = g_slist_next (iter)) {
GstMssStream *stream = iter->data;
if (stream->active) {
if (stream->fragments) {
GList *l = g_list_last (stream->fragments);
GstMssStreamFragment *fragment = (GstMssStreamFragment *) l->data;
guint64 frag_dur =
fragment->time + fragment->duration * fragment->repetitions;
max_dur = MAX (frag_dur, max_dur);
}
}
}
if (max_dur != 0)
dur = max_dur;
}
return dur;
}
/*
* Gets the duration in nanoseconds
*/
GstClockTime
gst_mss_manifest_get_gst_duration (GstMssManifest * manifest)
{
guint64 duration = -1;
guint64 timescale;
GstClockTime gstdur = GST_CLOCK_TIME_NONE;
duration = gst_mss_manifest_get_duration (manifest);
timescale = gst_mss_manifest_get_timescale (manifest);
if (duration != -1 && timescale != -1)
gstdur =
(GstClockTime) gst_util_uint64_scale_round (duration, GST_SECOND,
timescale);
return gstdur;
}
GstClockTime
gst_mss_manifest_get_min_fragment_duration (GstMssManifest * manifest)
{
GSList *iter;
GstClockTime dur = GST_CLOCK_TIME_NONE;
GstClockTime iter_dur;
for (iter = manifest->streams; iter; iter = g_slist_next (iter)) {
GstMssStream *stream = iter->data;
iter_dur = gst_mss_stream_get_fragment_gst_duration (stream);
if (iter_dur != GST_CLOCK_TIME_NONE && iter_dur != 0) {
if (GST_CLOCK_TIME_IS_VALID (dur)) {
dur = MIN (dur, iter_dur);
} else {
dur = iter_dur;
}
}
}
return dur;
}
GstCaps *
gst_mss_stream_get_caps (GstMssStream * stream)
{
GstMssStreamType streamtype = gst_mss_stream_get_type (stream);
GstMssStreamQuality *qualitylevel = stream->current_quality->data;
GstCaps *caps = NULL;
if (streamtype == MSS_STREAM_TYPE_VIDEO)
caps = _gst_mss_stream_video_caps_from_qualitylevel_xml (qualitylevel);
else if (streamtype == MSS_STREAM_TYPE_AUDIO)
caps = _gst_mss_stream_audio_caps_from_qualitylevel_xml (qualitylevel);
return caps;
}
GstFlowReturn
gst_mss_stream_get_fragment_url (GstMssStream * stream, gchar ** url)
{
gchar *tmp;
gchar *start_time_str;
guint64 time;
GstMssStreamFragment *fragment;
GstMssStreamQuality *quality = stream->current_quality->data;
g_return_val_if_fail (stream->active, GST_FLOW_ERROR);
if (stream->current_fragment == NULL) /* stream is over */
return GST_FLOW_EOS;
fragment = stream->current_fragment->data;
time =
fragment->time + fragment->duration * stream->fragment_repetition_index;
start_time_str = g_strdup_printf ("%" G_GUINT64_FORMAT, time);
tmp = g_regex_replace_literal (stream->regex_bitrate, stream->url,
strlen (stream->url), 0, quality->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);
if (*url == NULL)
return GST_FLOW_ERROR;
return GST_FLOW_OK;
}
GstClockTime
gst_mss_stream_get_fragment_gst_timestamp (GstMssStream * stream)
{
guint64 time;
guint64 timescale;
GstMssStreamFragment *fragment;
g_return_val_if_fail (stream->active, GST_CLOCK_TIME_NONE);
if (!stream->current_fragment) {
GList *last = g_list_last (stream->fragments);
if (last == NULL)
return GST_CLOCK_TIME_NONE;
fragment = last->data;
time = fragment->time + (fragment->duration * fragment->repetitions);
} else {
fragment = stream->current_fragment->data;
time =
fragment->time +
(fragment->duration * stream->fragment_repetition_index);
}
timescale = gst_mss_stream_get_timescale (stream);
return (GstClockTime) gst_util_uint64_scale_round (time, GST_SECOND,
timescale);
}
GstClockTime
gst_mss_stream_get_fragment_gst_duration (GstMssStream * stream)
{
guint64 dur;
guint64 timescale;
GstMssStreamFragment *fragment;
g_return_val_if_fail (stream->active, GST_FLOW_ERROR);
if (!stream->current_fragment)
return GST_CLOCK_TIME_NONE;
fragment = stream->current_fragment->data;
dur = fragment->duration;
timescale = gst_mss_stream_get_timescale (stream);
return (GstClockTime) gst_util_uint64_scale_round (dur, GST_SECOND,
timescale);
}
gboolean
gst_mss_stream_has_next_fragment (GstMssStream * stream)
{
g_return_val_if_fail (stream->active, FALSE);
if (stream->current_fragment == NULL)
return FALSE;
return TRUE;
}
GstFlowReturn
gst_mss_stream_advance_fragment (GstMssStream * stream)
{
GstMssStreamFragment *fragment;
const gchar *stream_type_name =
gst_mss_stream_type_name (gst_mss_stream_get_type (stream));
g_return_val_if_fail (stream->active, GST_FLOW_ERROR);
if (stream->current_fragment == NULL)
return GST_FLOW_EOS;
fragment = stream->current_fragment->data;
stream->fragment_repetition_index++;
if (stream->fragment_repetition_index < fragment->repetitions)
goto beach;
stream->fragment_repetition_index = 0;
stream->current_fragment = g_list_next (stream->current_fragment);
GST_DEBUG ("Advanced to fragment #%d on %s stream", fragment->number,
stream_type_name);
if (stream->current_fragment == NULL)
return GST_FLOW_EOS;
beach:
gst_mss_fragment_parser_clear (&stream->fragment_parser);
gst_mss_fragment_parser_init (&stream->fragment_parser);
return GST_FLOW_OK;
}
GstFlowReturn
gst_mss_stream_regress_fragment (GstMssStream * stream)
{
GstMssStreamFragment *fragment;
g_return_val_if_fail (stream->active, GST_FLOW_ERROR);
if (stream->current_fragment == NULL)
return GST_FLOW_EOS;
fragment = stream->current_fragment->data;
if (stream->fragment_repetition_index == 0) {
stream->current_fragment = g_list_previous (stream->current_fragment);
if (stream->current_fragment == NULL)
return GST_FLOW_EOS;
fragment = stream->current_fragment->data;
stream->fragment_repetition_index = fragment->repetitions - 1;
} else {
stream->fragment_repetition_index--;
}
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";
}
}
/*
* Seeks all streams to the fragment that contains the set time
*
* @forward: if this is forward playback
* @time: time in nanoseconds
*/
void
gst_mss_manifest_seek (GstMssManifest * manifest, gboolean forward,
guint64 time)
{
GSList *iter;
for (iter = manifest->streams; iter; iter = g_slist_next (iter)) {
GstMssStream *stream = iter->data;
gst_mss_manifest_live_adapter_clear (stream);
gst_mss_stream_seek (stream, forward, 0, time, NULL);
}
}
#define SNAP_AFTER(forward,flags) \
((forward && (flags & GST_SEEK_FLAG_SNAP_AFTER)) || \
(!forward && (flags & GST_SEEK_FLAG_SNAP_BEFORE)))
/*
* Seeks this stream to the fragment that contains the sample at time
*
* @time: time in nanoseconds
*/
void
gst_mss_stream_seek (GstMssStream * stream, gboolean forward,
GstSeekFlags flags, guint64 time, guint64 * final_time)
{
GList *iter;
guint64 timescale;
GstMssStreamFragment *fragment = NULL;
timescale = gst_mss_stream_get_timescale (stream);
time = gst_util_uint64_scale_round (time, timescale, GST_SECOND);
GST_DEBUG ("Stream %s seeking to %" G_GUINT64_FORMAT, stream->url, time);
for (iter = stream->fragments; iter; iter = g_list_next (iter)) {
fragment = iter->data;
if (fragment->time + fragment->repetitions * fragment->duration > time) {
stream->current_fragment = iter;
stream->fragment_repetition_index =
(time - fragment->time) / fragment->duration;
if (((time - fragment->time) % fragment->duration) == 0) {
/* for reverse playback, start from the previous fragment when we are
* exactly at a limit */
if (!forward)
stream->fragment_repetition_index--;
} else if (SNAP_AFTER (forward, flags))
stream->fragment_repetition_index++;
if (stream->fragment_repetition_index == fragment->repetitions) {
/* move to the next one */
stream->fragment_repetition_index = 0;
stream->current_fragment = g_list_next (iter);
fragment =
stream->current_fragment ? stream->current_fragment->data : NULL;
} else if (stream->fragment_repetition_index == -1) {
if (g_list_previous (iter)) {
stream->current_fragment = g_list_previous (iter);
fragment = stream->current_fragment->data;
g_assert (fragment);
stream->fragment_repetition_index = fragment->repetitions - 1;
} else {
stream->fragment_repetition_index = 0;
}
}
break;
}
}
GST_DEBUG ("Stream %s seeked to fragment time %" G_GUINT64_FORMAT
" repetition %u", stream->url,
fragment ? fragment->time : GST_CLOCK_TIME_NONE,
stream->fragment_repetition_index);
if (final_time) {
if (fragment) {
*final_time = gst_util_uint64_scale_round (fragment->time +
stream->fragment_repetition_index * fragment->duration,
GST_SECOND, timescale);
} else {
GstMssStreamFragment *last_fragment = g_list_last (iter)->data;
*final_time = gst_util_uint64_scale_round (last_fragment->time +
last_fragment->repetitions * last_fragment->duration,
GST_SECOND, timescale);
}
}
}
guint64
gst_mss_manifest_get_current_bitrate (GstMssManifest * manifest)
{
guint64 bitrate = 0;
GSList *iter;
for (iter = gst_mss_manifest_get_streams (manifest); iter;
iter = g_slist_next (iter)) {
GstMssStream *stream = iter->data;
if (stream->active && stream->current_quality) {
GstMssStreamQuality *q = stream->current_quality->data;
bitrate += q->bitrate;
}
}
return bitrate;
}
gboolean
gst_mss_manifest_is_live (GstMssManifest * manifest)
{
return manifest->is_live;
}
static void
gst_mss_stream_reload_fragments (GstMssStream * stream, xmlNodePtr streamIndex)
{
xmlNodePtr iter;
guint64 current_gst_time;
GstMssFragmentListBuilder builder;
current_gst_time = gst_mss_stream_get_fragment_gst_timestamp (stream);
gst_mss_fragment_list_builder_init (&builder);
GST_DEBUG ("Current position: %" GST_TIME_FORMAT,
GST_TIME_ARGS (current_gst_time));
for (iter = streamIndex->children; iter; iter = iter->next) {
if (node_has_type (iter, MSS_NODE_STREAM_FRAGMENT)) {
gst_mss_fragment_list_builder_add (&builder, iter);
} else {
/* TODO gst log this */
}
}
/* store the new fragments list */
if (builder.fragments) {
g_list_free_full (stream->fragments, g_free);
stream->fragments = g_list_reverse (builder.fragments);
stream->current_fragment = stream->fragments;
/* TODO Verify how repositioning here works for reverse
* playback - it might start from the wrong fragment */
gst_mss_stream_seek (stream, TRUE, 0, current_gst_time, NULL);
}
}
static void
gst_mss_manifest_reload_fragments_from_xml (GstMssManifest * manifest,
xmlNodePtr root)
{
xmlNodePtr nodeiter;
GSList *streams = manifest->streams;
/* we assume the server is providing the streams in the same order in
* every manifest */
for (nodeiter = root->children; nodeiter && streams;
nodeiter = nodeiter->next) {
if (nodeiter->type == XML_ELEMENT_NODE
&& (strcmp ((const char *) nodeiter->name, "StreamIndex") == 0)) {
gst_mss_stream_reload_fragments (streams->data, nodeiter);
streams = g_slist_next (streams);
}
}
}
void
gst_mss_manifest_reload_fragments (GstMssManifest * manifest, GstBuffer * data)
{
xmlDocPtr xml;
xmlNodePtr root;
GstMapInfo info;
gst_buffer_map (data, &info, GST_MAP_READ);
xml = xmlReadMemory ((const gchar *) info.data,
info.size, "manifest", NULL, 0);
root = xmlDocGetRootElement (xml);
gst_mss_manifest_reload_fragments_from_xml (manifest, root);
xmlFreeDoc (xml);
gst_buffer_unmap (data, &info);
}
gboolean
gst_mss_stream_select_bitrate (GstMssStream * stream, guint64 bitrate)
{
GList *iter = stream->current_quality;
GList *next;
GstMssStreamQuality *q = iter->data;
while (q->bitrate > bitrate) {
next = g_list_previous (iter);
if (next) {
iter = next;
q = iter->data;
} else {
break;
}
}
while (q->bitrate < bitrate) {
GstMssStreamQuality *next_q;
next = g_list_next (iter);
if (next) {
next_q = next->data;
if (next_q->bitrate < bitrate) {
iter = next;
q = iter->data;
} else {
break;
}
} else {
break;
}
}
if (iter == stream->current_quality)
return FALSE;
stream->current_quality = iter;
return TRUE;
}
guint64
gst_mss_stream_get_current_bitrate (GstMssStream * stream)
{
GstMssStreamQuality *q;
if (stream->current_quality == NULL)
return 0;
q = stream->current_quality->data;
return q->bitrate;
}
/**
* gst_mss_manifest_change_bitrate:
* @manifest: the manifest
* @bitrate: the maximum bitrate to use (bps)
*
* Iterates over the active streams and changes their bitrates to the maximum
* value so that the bitrates of all streams are not larger than
* @bitrate.
*
* Return: %TRUE if any stream changed its bitrate
*/
gboolean
gst_mss_manifest_change_bitrate (GstMssManifest * manifest, guint64 bitrate)
{
gboolean ret = FALSE;
GSList *iter;
/* TODO This algorithm currently sets the same bitrate for all streams,
* it should actually use the sum of all streams bitrates to compare to
* the target value */
if (bitrate == 0) {
/* use maximum */
bitrate = G_MAXUINT64;
}
for (iter = gst_mss_manifest_get_streams (manifest); iter;
iter = g_slist_next (iter)) {
GstMssStream *stream = iter->data;
if (stream->active) {
ret = ret | gst_mss_stream_select_bitrate (stream, bitrate);
}
}
return ret;
}
static GstBuffer *
gst_buffer_from_hex_string (const gchar * s)
{
GstBuffer *buffer = NULL;
gint len;
gchar ts[3];
guint8 *data;
gint i;
GstMapInfo info;
len = strlen (s);
if (len & 1)
return NULL;
buffer = gst_buffer_new_and_alloc (len / 2);
gst_buffer_map (buffer, &info, GST_MAP_WRITE);
data = info.data;
for (i = 0; i < len / 2; i++) {
if (!isxdigit ((int) s[i * 2]) || !isxdigit ((int) s[i * 2 + 1])) {
gst_buffer_unref (buffer);
return NULL;
}
ts[0] = s[i * 2 + 0];
ts[1] = s[i * 2 + 1];
ts[2] = 0;
data[i] = (guint8) strtoul (ts, NULL, 16);
}
gst_buffer_unmap (buffer, &info);
return buffer;
}
const gchar *
gst_mss_stream_get_lang (GstMssStream * stream)
{
return stream->lang;
}
static GstClockTime
gst_mss_manifest_get_dvr_window_length_clock_time (GstMssManifest * manifest)
{
gint64 timescale;
/* the entire file is always available for non-live streams */
if (manifest->dvr_window == 0)
return GST_CLOCK_TIME_NONE;
timescale = gst_mss_manifest_get_timescale (manifest);
return (GstClockTime) gst_util_uint64_scale_round (manifest->dvr_window,
GST_SECOND, timescale);
}
static gboolean
gst_mss_stream_get_live_seek_range (GstMssStream * stream, gint64 * start,
gint64 * stop)
{
GList *l;
GstMssStreamFragment *fragment;
guint64 timescale = gst_mss_stream_get_timescale (stream);
g_return_val_if_fail (stream->active, FALSE);
/* XXX: assumes all the data in the stream is still available */
l = g_list_first (stream->fragments);
fragment = (GstMssStreamFragment *) l->data;
*start = gst_util_uint64_scale_round (fragment->time, GST_SECOND, timescale);
l = g_list_last (stream->fragments);
fragment = (GstMssStreamFragment *) l->data;
*stop = gst_util_uint64_scale_round (fragment->time + fragment->duration *
fragment->repetitions, GST_SECOND, timescale);
return TRUE;
}
gboolean
gst_mss_manifest_get_live_seek_range (GstMssManifest * manifest, gint64 * start,
gint64 * stop)
{
GSList *iter;
gboolean ret = FALSE;
for (iter = manifest->streams; iter; iter = g_slist_next (iter)) {
GstMssStream *stream = iter->data;
if (stream->active) {
/* FIXME: bound this correctly for multiple streams */
if (!(ret = gst_mss_stream_get_live_seek_range (stream, start, stop)))
break;
}
}
if (ret && gst_mss_manifest_is_live (manifest)) {
GstClockTime dvr_window =
gst_mss_manifest_get_dvr_window_length_clock_time (manifest);
if (GST_CLOCK_TIME_IS_VALID (dvr_window) && *stop - *start > dvr_window) {
*start = *stop - dvr_window;
}
}
return ret;
}
void
gst_mss_manifest_live_adapter_push (GstMssStream * stream, GstBuffer * buffer)
{
gst_adapter_push (stream->live_adapter, buffer);
}
gsize
gst_mss_manifest_live_adapter_available (GstMssStream * stream)
{
return gst_adapter_available (stream->live_adapter);
}
GstBuffer *
gst_mss_manifest_live_adapter_take_buffer (GstMssStream * stream, gsize nbytes)
{
return gst_adapter_take_buffer (stream->live_adapter, nbytes);
}
void
gst_mss_manifest_live_adapter_clear (GstMssStream * stream)
{
if (stream->live_adapter)
gst_adapter_clear (stream->live_adapter);
}
gboolean
gst_mss_stream_fragment_parsing_needed (GstMssStream * stream)
{
return stream->fragment_parser.status == GST_MSS_FRAGMENT_HEADER_PARSER_INIT;
}
void
gst_mss_stream_parse_fragment (GstMssStream * stream, GstBuffer * buffer)
{
const gchar *stream_type_name;
guint8 index;
GstMoofBox *moof;
GstTrafBox *traf;
if (!stream->has_live_fragments)
return;
if (!gst_mss_fragment_parser_add_buffer (&stream->fragment_parser, buffer))
return;
moof = stream->fragment_parser.moof;
traf = &g_array_index (moof->traf, GstTrafBox, 0);
stream_type_name =
gst_mss_stream_type_name (gst_mss_stream_get_type (stream));
for (index = 0; index < traf->tfrf->entries_count; index++) {
GstTfrfBoxEntry *entry =
&g_array_index (traf->tfrf->entries, GstTfrfBoxEntry, index);
GList *l = g_list_last (stream->fragments);
GstMssStreamFragment *last;
GstMssStreamFragment *fragment;
guint64 parsed_time = entry->time;
guint64 parsed_duration = entry->duration;
if (l == NULL)
break;
last = (GstMssStreamFragment *) l->data;
/* only add the fragment to the list if it's outside the time in the
* current list */
if (last->time >= entry->time)
continue;
fragment = g_new (GstMssStreamFragment, 1);
fragment->number = last->number + 1;
fragment->repetitions = 1;
fragment->time = parsed_time;
fragment->duration = parsed_duration;
stream->fragments = g_list_append (stream->fragments, fragment);
GST_LOG ("Adding fragment number: %u to %s stream, time: %"
G_GUINT64_FORMAT ", duration: %" G_GUINT64_FORMAT ", repetitions: %u",
fragment->number, stream_type_name, fragment->time,
fragment->duration, fragment->repetitions);
}
}
Reference in a new issue View git blame Copy permalink