mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-26 18:20:44 +00:00
de246c6741
q->bitrate is a guint64, but G_TYPE_INT may read fewer bits off the stack, and if we pass more then the NULL sentinel may not be found at the right place, which in turn might lead to crashes. https://bugzilla.gnome.org/show_bug.cgi?id=741751
1299 lines
34 KiB
C
1299 lines
34 KiB
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 <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"
|
|
|
|
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_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"
|
|
|
|
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;
|
|
|
|
GList *fragments;
|
|
GList *qualities;
|
|
|
|
gchar *url;
|
|
gchar *lang;
|
|
|
|
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;
|
|
|
|
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 (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 (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 */
|
|
}
|
|
}
|
|
|
|
stream->fragments = g_list_reverse (builder.fragments);
|
|
|
|
/* order them from smaller to bigger based on bitrates */
|
|
stream->qualities =
|
|
g_list_sort (stream->qualities, (GCompareFunc) compare_bitrate);
|
|
|
|
stream->current_fragment = stream->fragments;
|
|
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);
|
|
}
|
|
|
|
GstMssManifest *
|
|
gst_mss_manifest_new (GstBuffer * data)
|
|
{
|
|
GstMssManifest *manifest;
|
|
xmlNodePtr root;
|
|
xmlNodePtr nodeiter;
|
|
gchar *live_str;
|
|
GstMapInfo mapinfo;
|
|
|
|
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);
|
|
|
|
live_str = (gchar *) xmlGetProp (root, (xmlChar *) "IsLive");
|
|
if (live_str) {
|
|
manifest->is_live = g_ascii_strcasecmp (live_str, "true") == 0;
|
|
xmlFree (live_str);
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
gst_buffer_unmap (data, &mapinfo);
|
|
|
|
return manifest;
|
|
}
|
|
|
|
static void
|
|
gst_mss_stream_free (GstMssStream * stream)
|
|
{
|
|
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);
|
|
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 (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;
|
|
nalu.data = spsinfo.data;
|
|
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, TRUE);
|
|
if (parseres == GST_H264_PARSER_OK) {
|
|
gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION,
|
|
sps_struct.fps_num, sps_struct.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 *block_align_str =
|
|
(gchar *) xmlGetProp (node, (xmlChar *) "PacketSize");
|
|
gchar *codec_data_str =
|
|
(gchar *) xmlGetProp (node, (xmlChar *) "CodecPrivateData");
|
|
GstBuffer *codec_data = NULL;
|
|
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 (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);
|
|
}
|
|
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 (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 (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 = -1;
|
|
|
|
duration =
|
|
(gchar *) xmlGetProp (manifest->xmlrootnode,
|
|
(xmlChar *) MSS_PROP_STREAM_DURATION);
|
|
if (duration) {
|
|
dur = g_ascii_strtoull (duration, NULL, 10);
|
|
xmlFree (duration);
|
|
}
|
|
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_FLOW_ERROR);
|
|
|
|
if (!stream->current_fragment) {
|
|
GList *last = g_list_last (stream->fragments);
|
|
if (last == NULL)
|
|
return GST_CLOCK_TIME_NONE;
|
|
|
|
fragment = last->data;
|
|
return fragment->time + (fragment->duration * fragment->repetitions);
|
|
}
|
|
|
|
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;
|
|
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) {
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
stream->fragment_repetition_index = 0;
|
|
stream->current_fragment = g_list_next (stream->current_fragment);
|
|
if (stream->current_fragment == NULL)
|
|
return GST_FLOW_EOS;
|
|
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
|
|
*
|
|
* @time: time in nanoseconds
|
|
*/
|
|
void
|
|
gst_mss_manifest_seek (GstMssManifest * manifest, guint64 time)
|
|
{
|
|
GSList *iter;
|
|
|
|
for (iter = manifest->streams; iter; iter = g_slist_next (iter)) {
|
|
gst_mss_stream_seek (iter->data, time);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Seeks this stream to the fragment that contains the sample at time
|
|
*
|
|
* @time: time in nanoseconds
|
|
*/
|
|
void
|
|
gst_mss_stream_seek (GstMssStream * stream, guint64 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)) {
|
|
GList *next = g_list_next (iter);
|
|
if (next) {
|
|
fragment = next->data;
|
|
|
|
if (fragment->time > time) {
|
|
stream->current_fragment = iter;
|
|
break;
|
|
}
|
|
} else {
|
|
fragment = iter->data;
|
|
if (fragment->time + fragment->repetitions * fragment->duration > time) {
|
|
stream->current_fragment = iter;
|
|
} else {
|
|
stream->current_fragment = NULL; /* EOS */
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* position inside the repetitions */
|
|
if (stream->current_fragment) {
|
|
fragment = stream->current_fragment->data;
|
|
stream->fragment_repetition_index =
|
|
(time - fragment->time) / fragment->duration;
|
|
}
|
|
|
|
GST_DEBUG ("Stream %s seeked to fragment time %" G_GUINT64_FORMAT
|
|
" repetition %u", stream->url, fragment->time,
|
|
stream->fragment_repetition_index);
|
|
}
|
|
|
|
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 = gst_mss_stream_get_fragment_gst_timestamp (stream);
|
|
GstMssFragmentListBuilder builder;
|
|
|
|
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;
|
|
gst_mss_stream_seek (stream, current_gst_time);
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
g_return_if_fail (manifest->is_live);
|
|
|
|
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;
|
|
}
|