gstreamer/subprojects/gst-plugins-bad/ext/hls/gsthlsdemux-util.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

361 lines
10 KiB
C
Raw Normal View History

/* GStreamer
* Copyright (C) 2016 Jan Schmidt <jan@centricular.com>
* Copyright (C) 2016 Tim-Philipp Müller <tim@centricular.com>
*
* gsthlsdemux-util.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., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <gst/gst.h>
#include <gst/tag/tag.h>
#include <string.h>
#include "gsthlsdemux.h"
GST_DEBUG_CATEGORY_EXTERN (gst_hls_demux_debug);
#define GST_CAT_DEFAULT gst_hls_demux_debug
/* Check for sync byte, error_indicator == 0 and packet has payload.
* Adaptation control field (data[3] & 0x30) may be zero for TS packets with
* null PIDs. Still, these streams are valid TS streams (for null packets,
* AFC is supposed to be 0x1, but the spec also says decoders should just
* discard any packets with AFC = 0x00) */
#define IS_MPEGTS_HEADER(data) (data[0] == 0x47 && \
(data[1] & 0x80) == 0x00 && \
((data[3] & 0x30) != 0x00 || \
((data[3] & 0x30) == 0x00 && (data[1] & 0x1f) == 0x1f && (data[2] & 0xff) == 0xff)))
#define PCRTIME_TO_GSTTIME(t) (((t) * (guint64)1000) / 27)
#define MPEGTIME_TO_GSTTIME(t) (((t) * (guint64)100000) / 9)
static gboolean
have_ts_sync (const guint8 * data, guint size, guint packet_size, guint num)
{
while (num-- > 0) {
if (size < packet_size)
return FALSE;
if (!IS_MPEGTS_HEADER (data))
return FALSE;
data += packet_size;
size -= packet_size;
}
return TRUE;
}
static gint
find_offset (GstHLSTSReader * r, const guint8 * data, guint size)
{
guint sync_points = CLAMP (size / 188, 25, 100);
guint off;
const gint packet_size = 188;
/* FIXME: check 192 as well, and maybe also 204, 208 */
for (off = 0; off < MIN (size, packet_size); ++off) {
if (have_ts_sync (data + off, size - off, packet_size, sync_points)) {
r->packet_size = packet_size;
return off;
}
}
return -1;
}
static gboolean
handle_pcr (GstHLSTSReader * r, const guint8 * data, guint size)
{
const guint8 *p = data;
guint32 hdr = GST_READ_UINT32_BE (p);
guint af_len, flags;
guint64 pcr_base, pcr_ext, pcr, ts;
data = p + 4;
if ((hdr & 0x00000020) == 0) /* has_adaptation_field */
return FALSE;
af_len = p[4]; /* adaptation_field_len */
++data;
if (af_len < (1 + 6) || af_len > r->packet_size - (4 + 1))
return FALSE;
flags = data[0];
/* Does the packet have a PCR? */
if ((flags & 0x10) == 0)
return FALSE;
++data;
--af_len;
pcr_base = (GST_READ_UINT64_BE (data) >> 16) >> (6 + 9);
pcr_ext = (GST_READ_UINT64_BE (data) >> 16) & 0x1ff;
pcr = pcr_base * 300 + pcr_ext;
ts = PCRTIME_TO_GSTTIME (pcr);
GST_LOG ("have PCR! %" G_GUINT64_FORMAT "\t%" GST_TIME_FORMAT,
pcr, GST_TIME_ARGS (ts));
if (r->first_pcr == GST_CLOCK_TIME_NONE)
r->first_pcr = ts;
r->last_pcr = ts;
return TRUE;
}
static gboolean
handle_pmt (GstHLSTSReader * r, const guint8 * data, guint size)
{
const guint8 *p = data;
guint32 hdr = GST_READ_UINT32_BE (p);
guint slen, pcr_pid;
data = p + 4;
if ((hdr & 0x00000020) != 0) /* has_adaptation_field */
data += 1 + p[4]; /* adaptation_field_len */
data += 1 + data[0]; /* pointer_field */
if (data[0] != 0x02) /* table_id */
return FALSE;
//gst_util_dump_mem (data, 8);
/* we assume the entire PMT fits into a single packet and this is it */
if (data[6] != 0 || data[6] != data[7])
return FALSE;
slen = GST_READ_UINT16_BE (data + 1) & 0x0FFF;
if (slen > (gsize) (p + r->packet_size - (data + 1 + 2)) || slen < 5 + 2 + 4)
return FALSE;
data += 3 + 5;
slen -= 5; /* bytes after section_length field itself */
slen -= 4; /* crc at end */
pcr_pid = GST_READ_UINT16_BE (data) & 0x1fff;
if (pcr_pid != 0x1fff) {
GST_DEBUG ("pcr_pid now: %04x", pcr_pid);
r->pcr_pid = pcr_pid;
return TRUE;
}
return FALSE;
}
static gboolean
handle_pat (GstHLSTSReader * r, const guint8 * data, guint size)
{
const guint8 *p = data;
guint32 hdr = GST_READ_UINT32_BE (p);
guint slen;
data = p + 4;
if ((hdr & 0x00000020) != 0) /* has_adaptation_field */
data += 1 + p[4]; /* adaptation_field_len */
data += 1 + data[0]; /* pointer_field */
if (data[0] != 0) /* table_id */
return FALSE;
/* we assume the entire PAT fits into a single packet and this is it */
if (data[6] != 0 || data[6] != data[7])
return FALSE;
slen = GST_READ_UINT16_BE (data + 1) & 0x0FFF;
if (slen > (gsize) (p + r->packet_size - (data + 1 + 2)) || slen < 5 + 4 + 4)
return FALSE;
data += 3 + 5;
slen -= 5; /* bytes after section_length field itself */
slen -= 4; /* crc at end */
while (slen >= 4) {
guint program_num = GST_READ_UINT16_BE (data);
guint val = GST_READ_UINT16_BE (data + 2) & 0x1fff;
if (program_num != 0) {
GST_DEBUG (" program %04x: pmt_pid : %04x", program_num, val);
r->pmt_pid = val;
return TRUE;
}
data += 4;
slen -= 4;
}
return FALSE;
}
void
gst_hlsdemux_tsreader_init (GstHLSTSReader * r)
{
r->rtype = GST_HLS_TSREADER_NONE;
r->packet_size = 188;
r->pmt_pid = r->pcr_pid = -1;
r->first_pcr = GST_CLOCK_TIME_NONE;
r->last_pcr = GST_CLOCK_TIME_NONE;
}
void
gst_hlsdemux_tsreader_set_type (GstHLSTSReader * r, GstHLSTSReaderType rtype)
{
r->rtype = rtype;
r->have_id3 = FALSE;
}
static gboolean
gst_hlsdemux_tsreader_find_pcrs_mpegts (GstHLSTSReader * r,
GstBuffer * buffer, GstClockTime * first_pcr, GstClockTime * last_pcr)
{
GstMapInfo info;
gint offset;
const guint8 *p;
const guint8 *data;
gsize size;
if (!gst_buffer_map (buffer, &info, GST_MAP_READ))
return FALSE;
data = info.data;
size = info.size;
*first_pcr = *last_pcr = GST_CLOCK_TIME_NONE;
offset = find_offset (r, data, size);
if (offset < 0) {
gst_buffer_unmap (buffer, &info);
return FALSE;
}
GST_LOG ("TS packet start offset: %d", offset);
/* We don't store a partial packet at the end,
* and just assume that the final PCR is
* going to be completely inside the last data
* segment passed to us */
data += offset;
size -= offset;
for (p = data; size >= r->packet_size;
p += r->packet_size, size -= r->packet_size) {
guint32 hdr = GST_READ_UINT32_BE (p);
/* sync byte (0x47), error indicator (TEI) not set, PID 0, has_payload */
if ((hdr & 0xFF9FFF10) == 0x47000010) {
GST_LOG ("Found packet for PID 0000 (PAT)");
handle_pat (r, p, size);
}
/* sync byte (0x47), error indicator (TEI) not set, has_payload, PID = PMT_pid */
else if ((hdr & 0xFF800010) == 0x47000010
&& ((hdr >> 8) & 0x1fff) == r->pmt_pid) {
GST_LOG ("Found packet for PID %04x (PMT)", r->pmt_pid);
handle_pmt (r, p, size);
}
/* sync byte (0x47), error indicator (TEI) not set, has_adaptation_field */
else if ((hdr & 0xFF800020) == 0x47000020
&& ((hdr >> 8) & 0x1fff) == r->pcr_pid) {
GST_LOG ("Found packet for PID %04x (PCR)", r->pcr_pid);
handle_pcr (r, p, size);
}
}
gst_buffer_unmap (buffer, &info);
*first_pcr = r->first_pcr;
*last_pcr = r->last_pcr;
/* Return TRUE if this piece was big enough to get a PCR from */
return (r->first_pcr != GST_CLOCK_TIME_NONE);
}
static gboolean
gst_hlsdemux_tsreader_find_pcrs_id3 (GstHLSTSReader * r,
GstBuffer ** buffer_out, GstClockTime * first_pcr, GstClockTime * last_pcr,
GstTagList ** tags)
{
GstMapInfo info;
guint32 tag_size;
gsize size;
GstTagList *taglist;
GstSample *priv_data = NULL;
GstBuffer *buffer = *buffer_out;
GstBuffer *tag_buf;
guint64 pts;
*first_pcr = r->first_pcr;
*last_pcr = r->last_pcr;
if (r->have_id3)
return TRUE;
/* We need at least 10 bytes, starting with "ID3" for the header */
size = gst_buffer_get_size (buffer);
if (size < 10)
return FALSE;
/* Read the tag size */
tag_size = gst_tag_get_id3v2_tag_size (buffer);
/* Check we've collected that much */
if (size < tag_size)
return FALSE;
/* From here, whether the tag is valid or not we'll
* not try and read again */
r->have_id3 = TRUE;
*buffer_out =
gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, tag_size, -1);
/* Parse the tag */
taglist = gst_tag_list_from_id3v2_tag (buffer);
if (taglist == NULL) {
gst_buffer_unref (buffer);
return TRUE; /* Invalid tag, stop trying */
}
*tags = taglist;
/* Extract the timestamps */
if (!gst_tag_list_get_sample (taglist, GST_TAG_PRIVATE_DATA, &priv_data))
goto out;
if (!g_str_equal ("com.apple.streaming.transportStreamTimestamp",
gst_structure_get_string (gst_sample_get_info (priv_data), "owner")))
goto out;
/* OK, now as per section 3, the tag contains a 33-bit PCR inside a 64-bit
* BE-word */
tag_buf = gst_sample_get_buffer (priv_data);
if (tag_buf == NULL)
goto out;
if (!gst_buffer_map (tag_buf, &info, GST_MAP_READ))
goto out;
pts = GST_READ_UINT64_BE (info.data);
*first_pcr = r->first_pcr = MPEGTIME_TO_GSTTIME (pts);
GST_LOG ("Got AAC TS PTS %" G_GUINT64_FORMAT " (%" G_GUINT64_FORMAT ")",
pts, r->first_pcr);
gst_buffer_unmap (tag_buf, &info);
out:
if (priv_data)
gst_sample_unref (priv_data);
gst_buffer_unref (buffer);
return TRUE;
}
gboolean
gst_hlsdemux_tsreader_find_pcrs (GstHLSTSReader * r,
GstBuffer ** buffer, GstClockTime * first_pcr, GstClockTime * last_pcr,
GstTagList ** tags)
{
*tags = NULL;
if (r->rtype == GST_HLS_TSREADER_MPEGTS)
return gst_hlsdemux_tsreader_find_pcrs_mpegts (r, *buffer, first_pcr,
last_pcr);
return gst_hlsdemux_tsreader_find_pcrs_id3 (r, buffer, first_pcr, last_pcr,
tags);
}