stv0g/tvheadend
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
tvheadend/src/parsers.c
Andreas Öman d5ceed1cae Fix error in AC3 parser
2010-06-30 18:39:57 +00:00

1185 lines
24 KiB
C
Raw Blame History

/*
* Packet parsing functions
* Copyright (C) 2007 Andreas Öman
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include "tvhead.h"
#include "parsers.h"
#include "parser_h264.h"
#include "parser_latm.h"
#include "bitstream.h"
#include "packet.h"
#include "transports.h"
#include "streaming.h"
#define PTS_MASK 0x1ffffffffLL
//#define PTS_MASK 0x7ffffLL
#define getu32(b, l) ({ \
uint32_t x = (b[0] << 24 | b[1] << 16 | b[2] << 8 | b[3]); \
b+=4; \
l-=4; \
x; \
})
#define getu16(b, l) ({ \
uint16_t x = (b[0] << 8 | b[1]); \
b+=2; \
l-=2; \
x; \
})
#define getu8(b, l) ({ \
uint8_t x = b[0]; \
b+=1; \
l-=1; \
x; \
})
static int64_t
getpts(const uint8_t *p)
{
int a = p[0];
int b = (p[1] << 8) | p[2];
int c = (p[3] << 8) | p[4];
if((a & 1) && (b & 1) && (c & 1)) {
return
((int64_t)((a >> 1) & 0x07) << 30) |
((int64_t)((b >> 1) ) << 15) |
((int64_t)((c >> 1) ))
;
} else {
// Marker bits not present
return PTS_UNSET;
}
}
static int parse_mpeg2video(th_transport_t *t, th_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
static int parse_h264(th_transport_t *t, th_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
typedef int (packet_parser_t)(th_transport_t *t, th_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
typedef void (aparser_t)(th_transport_t *t, th_stream_t *st, th_pkt_t *pkt);
static void parse_sc(th_transport_t *t, th_stream_t *st, const uint8_t *data,
int len, packet_parser_t *vp);
static void parse_aac(th_transport_t *t, th_stream_t *st, const uint8_t *data,
int len, int start);
static void parse_subtitles(th_transport_t *t, th_stream_t *st,
const uint8_t *data, int len, int start);
static int parse_mpa(th_transport_t *t, th_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
static int parse_ac3(th_transport_t *t, th_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset);
static void parser_deliver(th_transport_t *t, th_stream_t *st, th_pkt_t *pkt);
static int parse_pes_header(th_transport_t *t, th_stream_t *st,
const uint8_t *buf, size_t len);
/**
* Parse raw mpeg data
*/
void
parse_mpeg_ts(th_transport_t *t, th_stream_t *st, const uint8_t *data,
int len, int start, int err)
{
if(start)
st->st_buffer_errors = 0;
if(err)
st->st_buffer_errors++;
switch(st->st_type) {
case SCT_MPEG2VIDEO:
parse_sc(t, st, data, len, parse_mpeg2video);
break;
case SCT_H264:
parse_sc(t, st, data, len, parse_h264);
break;
case SCT_MPEG2AUDIO:
parse_sc(t, st, data, len, parse_mpa);
break;
case SCT_AC3:
parse_sc(t, st, data, len, parse_ac3);
break;
case SCT_DVBSUB:
parse_subtitles(t, st, data, len, start);
break;
case SCT_AAC:
parse_aac(t, st, data, len, start);
break;
default:
break;
}
}
/**
* Parse program stream, as from V4L2, etc.
*
* Note: data does not include startcode and packet length
*/
void
parse_mpeg_ps(th_transport_t *t, th_stream_t *st, uint8_t *data, int len)
{
int hlen;
hlen = parse_pes_header(t, st, data, len);
#if 0
int i;
for(i = 0; i < 16; i++)
printf("%02x.", data[i]);
printf(" %d\n", hlen);
#endif
data += hlen;
len -= hlen;
if(len < 1)
return;
switch(st->st_type) {
case SCT_MPEG2AUDIO:
parse_sc(t, st, data, len, parse_mpa);
break;
case SCT_MPEG2VIDEO:
parse_sc(t, st, data, len, parse_mpeg2video);
break;
default:
break;
}
}
/**
*
*/
static void
buffer_alloc(th_stream_t *st, int len)
{
if(st->st_buffer == NULL) {
st->st_buffer_size = 4000;
st->st_buffer = malloc(st->st_buffer_size);
}
if(st->st_buffer_ptr + len >= st->st_buffer_size) {
st->st_buffer_size += len * 4;
st->st_buffer = realloc(st->st_buffer, st->st_buffer_size);
}
}
/**
*
*/
static void
buffer_append(th_stream_t *st, const uint8_t *data, int len)
{
buffer_alloc(st, len);
memcpy(st->st_buffer + st->st_buffer_ptr, data, len);
st->st_buffer_ptr += len;
}
/**
*
*/
static void
buffer3_alloc(th_stream_t *st, int len)
{
if(st->st_buffer3 == NULL) {
st->st_buffer3_size = 4000;
st->st_buffer3 = malloc(st->st_buffer3_size);
}
if(st->st_buffer3_ptr + len >= st->st_buffer3_size) {
st->st_buffer3_size += len * 4;
st->st_buffer3 = realloc(st->st_buffer3, st->st_buffer3_size);
}
}
/**
*
*/
static void
buffer3_append(th_stream_t *st, const uint8_t *data, int len)
{
buffer3_alloc(st, len);
memcpy(st->st_buffer3 + st->st_buffer3_ptr, data, len);
st->st_buffer3_ptr += len;
}
/**
*
*/
static void
buffer3_cut(th_stream_t *st, int p)
{
assert(p <= st->st_buffer3_ptr);
st->st_buffer3_ptr = st->st_buffer3_ptr - p;
memmove(st->st_buffer3, st->st_buffer3 + p, st->st_buffer3_ptr);
}
/**
* Parse AAC LATM
*/
static void
parse_aac(th_transport_t *t, th_stream_t *st, const uint8_t *data,
int len, int start)
{
int l, muxlen, p;
th_pkt_t *pkt;
if(start) {
/* Payload unit start */
st->st_parser_state = 1;
st->st_buffer_ptr = 0;
st->st_parser_ptr = 0;
}
if(st->st_parser_state == 0)
return;
if(st->st_buffer == NULL) {
st->st_buffer_size = 4000;
st->st_buffer = malloc(st->st_buffer_size);
}
if(st->st_buffer_ptr + len >= st->st_buffer_size) {
st->st_buffer_size += len * 4;
st->st_buffer = realloc(st->st_buffer, st->st_buffer_size);
}
memcpy(st->st_buffer + st->st_buffer_ptr, data, len);
st->st_buffer_ptr += len;
if(st->st_parser_ptr == 0) {
int hlen;
if(st->st_buffer_ptr < 9)
return;
hlen = parse_pes_header(t, st, st->st_buffer + 6, st->st_buffer_ptr - 6);
if(hlen < 0)
return;
st->st_parser_ptr += 6 + hlen;
}
p = st->st_parser_ptr;
while((l = st->st_buffer_ptr - p) > 3) {
if(st->st_buffer[p] == 0x56 && (st->st_buffer[p + 1] & 0xe0) == 0xe0) {
muxlen = (st->st_buffer[p + 1] & 0x1f) << 8 |
st->st_buffer[p + 2];
if(l < muxlen + 3)
break;
pkt = parse_latm_audio_mux_element(t, st, st->st_buffer + p + 3, muxlen);
if(pkt != NULL)
parser_deliver(t, st, pkt);
p += muxlen + 3;
} else {
p++;
}
}
st->st_parser_ptr = p;
}
/**
* Generic video parser
*
* We scan for startcodes a'la 0x000001xx and let a specific parser
* derive further information.
*/
static void
parse_sc(th_transport_t *t, th_stream_t *st, const uint8_t *data, int len,
packet_parser_t *vp)
{
uint32_t sc = st->st_startcond;
int i, r;
buffer_alloc(st, len);
for(i = 0; i < len; i++) {
st->st_buffer[st->st_buffer_ptr++] = data[i];
sc = sc << 8 | data[i];
if((sc & 0xffffff00) != 0x00000100)
continue;
r = st->st_buffer_ptr - st->st_startcode_offset - 4;
if(r > 0 && st->st_startcode != 0) {
r = vp(t, st, r, sc, st->st_startcode_offset);
if(r == 3)
continue;
} else {
r = 1;
}
if(r == 2) {
// Drop packet
st->st_buffer_ptr = st->st_startcode_offset;
st->st_buffer[st->st_buffer_ptr++] = sc >> 24;
st->st_buffer[st->st_buffer_ptr++] = sc >> 16;
st->st_buffer[st->st_buffer_ptr++] = sc >> 8;
st->st_buffer[st->st_buffer_ptr++] = sc;
st->st_startcode = sc;
} else {
if(r == 1) {
/* Reset packet parser upon length error or if parser
tells us so */
st->st_buffer_ptr = 0;
st->st_buffer_errors = 0;
st->st_buffer[st->st_buffer_ptr++] = sc >> 24;
st->st_buffer[st->st_buffer_ptr++] = sc >> 16;
st->st_buffer[st->st_buffer_ptr++] = sc >> 8;
st->st_buffer[st->st_buffer_ptr++] = sc;
}
st->st_startcode = sc;
st->st_startcode_offset = st->st_buffer_ptr - 4;
}
}
st->st_startcond = sc;
}
/**
*
*/
static int
depacketize(th_transport_t *t, th_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset)
{
const uint8_t *buf = st->st_buffer + sc_offset;
uint32_t sc = st->st_startcode;
int hlen, plen;
if((sc != 0x1bd && sc != 0x1c0) || len < 9)
return 1;
plen = (buf[4] << 8) | buf[5];
if(plen + 6 > len || next_startcode != sc)
return 3;
if(plen + 6 < len)
return 1;
buf += 6;
len -= 6;
hlen = parse_pes_header(t, st, buf, len);
if(hlen < 0)
return 1;
buf += hlen;
len -= hlen;
buffer3_append(st, buf, len);
return 0;
}
/**
*
*/
static void
makeapkt(th_transport_t *t, th_stream_t *st, const void *buf,
int len, int64_t dts, int duration)
{
th_pkt_t *pkt = pkt_alloc(buf, len, dts, dts);
pkt->pkt_commercial = t->tht_tt_commercial_advice;
pkt->pkt_duration = duration;
parser_deliver(t, st, pkt);
st->st_curdts = PTS_UNSET;
st->st_nextdts = dts + duration;
}
const static int mpa_br[16] = {
0, 32, 48, 56,
64, 80, 96, 112,
128, 160, 192, 224,
256, 320, 384, 0
};
const static int mpa_sr[4] = {44100, 48000, 32000, 0};
static int
mpa_valid_frame(const uint8_t *buf)
{
return buf[0] == 0xff && (buf[1] & 0xfe) == 0xfc;
}
static int
parse_mpa(th_transport_t *t, th_stream_t *st, size_t ilen,
uint32_t next_startcode, int sc_offset)
{
int i, len;
const uint8_t *buf;
if((i = depacketize(t, st, ilen, next_startcode, sc_offset)) != 0)
return i;
again:
buf = st->st_buffer3;
len = st->st_buffer3_ptr;
for(i = 0; i < len - 4; i++) {
if(mpa_valid_frame(buf + i)) {
int br = mpa_br[ buf[i+2] >> 4 ];
int sr = mpa_sr[(buf[i+2] >> 2) & 3];
int pad = buf[i+2] & 1;
if(br && sr) {
int fsize = 144000 * br / sr + pad;
int duration = 90000 * 1152 / sr;
int64_t dts = st->st_curdts;
if(dts == PTS_UNSET)
dts = st->st_nextdts;
if(dts != PTS_UNSET &&
len >= i + fsize + 4 &&
mpa_valid_frame(buf + i + fsize)) {
makeapkt(t, st, buf + i, fsize, dts, duration);
buffer3_cut(st, i + fsize);
goto again;
}
}
}
}
return 1;
}
/**
* AC3 audio parser
*/
const static int ac3_freq_tab[4] = {48000, 44100, 32000, 0};
const static uint16_t ac3_frame_size_tab[38][3] = {
{ 64, 69, 96 },
{ 64, 70, 96 },
{ 80, 87, 120 },
{ 80, 88, 120 },
{ 96, 104, 144 },
{ 96, 105, 144 },
{ 112, 121, 168 },
{ 112, 122, 168 },
{ 128, 139, 192 },
{ 128, 140, 192 },
{ 160, 174, 240 },
{ 160, 175, 240 },
{ 192, 208, 288 },
{ 192, 209, 288 },
{ 224, 243, 336 },
{ 224, 244, 336 },
{ 256, 278, 384 },
{ 256, 279, 384 },
{ 320, 348, 480 },
{ 320, 349, 480 },
{ 384, 417, 576 },
{ 384, 418, 576 },
{ 448, 487, 672 },
{ 448, 488, 672 },
{ 512, 557, 768 },
{ 512, 558, 768 },
{ 640, 696, 960 },
{ 640, 697, 960 },
{ 768, 835, 1152 },
{ 768, 836, 1152 },
{ 896, 975, 1344 },
{ 896, 976, 1344 },
{ 1024, 1114, 1536 },
{ 1024, 1115, 1536 },
{ 1152, 1253, 1728 },
{ 1152, 1254, 1728 },
{ 1280, 1393, 1920 },
{ 1280, 1394, 1920 },
};
/**
* Inspect 6 bytes AC3 header
*/
static int
ac3_valid_frame(const uint8_t *buf)
{
if(buf[0] != 0x0b || buf[1] != 0x77)
return 0;
int bsid = buf[5] & 0xf;
if(bsid <= 10) {
// Normal AC3
return (buf[4] & 0xc0) != 0xc0 && (buf[4] & 0x3f) < 0x26;
} else {
// E-AC3
return (buf[2] & 0xc0) != 0xc0;
}
}
static int
parse_ac3(th_transport_t *t, th_stream_t *st, size_t ilen,
uint32_t next_startcode, int sc_offset)
{
int i, len;
const uint8_t *buf;
if((i = depacketize(t, st, ilen, next_startcode, sc_offset)) != 0)
return i;
again:
buf = st->st_buffer3;
len = st->st_buffer3_ptr;
for(i = 0; i < len - 6; i++) {
const uint8_t *p = buf + i;
if(ac3_valid_frame(p)) {
int bsid = p[5] & 0xf;
int fsize, sr;
if(bsid <= 10) {
int fscod = p[4] >> 6;
int frmsizcod = p[4] & 0x3f;
fsize = ac3_frame_size_tab[frmsizcod][fscod] * 2;
bsid -= 8;
if(bsid < 0)
bsid = 0;
sr = ac3_freq_tab[fscod] >> bsid;
} else {
fsize = ((((p[2] & 0x7) << 8) | p[3]) + 1) * 2;
if((p[4] & 0xc0) == 0xc0) {
sr = ac3_freq_tab[(p[4] >> 4) & 3] / 2;
} else {
sr = ac3_freq_tab[(p[4] >> 6) & 3];
}
}
if(sr) {
int duration = 90000 * 1536 / sr;
int64_t dts = st->st_curdts;
if(dts == PTS_UNSET)
dts = st->st_nextdts;
if(dts != PTS_UNSET && len >= i + fsize + 6 &&
ac3_valid_frame(p + fsize)) {
makeapkt(t, st, p, fsize, dts, duration);
buffer3_cut(st, i + fsize);
goto again;
}
}
}
}
return 1;
}
/**
* PES header parser
*
* Extract DTS and PTS and update current values in stream
*/
static int
parse_pes_header(th_transport_t *t, th_stream_t *st,
const uint8_t *buf, size_t len)
{
int64_t dts, pts, d;
int hdr, flags, hlen;
hdr = getu8(buf, len);
flags = getu8(buf, len);
hlen = getu8(buf, len);
if(len < hlen || (hdr & 0xc0) != 0x80)
goto err;
if((flags & 0xc0) == 0xc0) {
if(hlen < 10)
goto err;
pts = getpts(buf);
dts = getpts(buf + 5);
d = (pts - dts) & PTS_MASK;
if(d > 180000) // More than two seconds of PTS/DTS delta, probably corrupt
pts = dts = PTS_UNSET;
} else if((flags & 0xc0) == 0x80) {
if(hlen < 5)
goto err;
dts = pts = getpts(buf);
} else
return hlen + 3;
if(st->st_buffer_errors) {
st->st_curdts = PTS_UNSET;
st->st_curpts = PTS_UNSET;
} else {
st->st_curdts = dts;
st->st_curpts = pts;
}
return hlen + 3;
err:
st->st_curdts = PTS_UNSET;
st->st_curpts = PTS_UNSET;
limitedlog(&st->st_loglimit_pes, "TS", transport_component_nicename(st),
"Corrupted PES header");
return -1;
}
/**
* MPEG2VIDEO frame duration table (in 90kHz clock domain)
*/
const unsigned int mpeg2video_framedurations[16] = {
0,
3753,
3750,
3600,
3003,
3000,
1800,
1501,
1500,
};
/**
* Parse mpeg2video picture start
*/
static int
parse_mpeg2video_pic_start(th_transport_t *t, th_stream_t *st, int *frametype,
bitstream_t *bs)
{
int v, pct;
if(bs->len < 29)
return 1;
skip_bits(bs, 10); /* temporal reference */
pct = read_bits(bs, 3);
if(pct < PKT_I_FRAME || pct > PKT_B_FRAME)
return 1; /* Illegal picture_coding_type */
*frametype = pct;
v = read_bits(bs, 16); /* vbv_delay */
if(v == 0xffff)
st->st_vbv_delay = -1;
else
st->st_vbv_delay = v;
return 0;
}
/**
*
*/
void
parser_set_stream_vsize(th_stream_t *st, int width, int height)
{
int need_save = 0;
if(st->st_width == 0 && st->st_height == 0) {
need_save = 1;
st->st_meta_change = 0;
} else if(st->st_width != width || st->st_height != height) {
st->st_meta_change++;
if(st->st_meta_change == 2)
need_save = 1;
} else {
st->st_meta_change = 0;
}
if(need_save) {
st->st_width = width;
st->st_height = height;
transport_request_save(st->st_transport, 1);
}
}
/**
* Parse mpeg2video sequence start
*/
static int
parse_mpeg2video_seq_start(th_transport_t *t, th_stream_t *st,
bitstream_t *bs)
{
int v, width, height;
if(bs->len < 61)
return 1;
width = read_bits(bs, 12);
height = read_bits(bs, 12);
skip_bits(bs, 4);
st->st_frame_duration = mpeg2video_framedurations[read_bits(bs, 4)];
v = read_bits(bs, 18) * 400;
skip_bits(bs, 1);
v = read_bits(bs, 10) * 16 * 1024 / 8;
st->st_vbv_size = v;
parser_set_stream_vsize(st, width, height);
return 0;
}
/**
*
*/
static int
drop_trailing_zeroes(const uint8_t *buf, size_t len)
{
while(len > 3 && (buf[len - 3] | buf[len - 2] | buf[len - 1]) == 0)
len--;
return len;
}
/**
*
*/
static void
parser_global_data_move(th_stream_t *st, const uint8_t *data, size_t len)
{
int len2 = drop_trailing_zeroes(data, len);
st->st_global_data = realloc(st->st_global_data,
st->st_global_data_len + len2);
memcpy(st->st_global_data + st->st_global_data_len, data, len2);
st->st_global_data_len += len2;
st->st_buffer_ptr -= len;
}
/**
* MPEG2VIDEO specific reassembly
*
* Process all startcodes (also the system ones)
*
* Extract framerate (or duration to be more specific)
*
* 'steal' the st->st_buffer and use it as 'pkt' buffer
*
*/
static int
parse_mpeg2video(th_transport_t *t, th_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset)
{
uint8_t *buf = st->st_buffer + sc_offset;
bitstream_t bs;
int frametype;
init_bits(&bs, buf + 4, (len - 4) * 8);
switch(st->st_startcode) {
case 0x000001e0 ... 0x000001ef:
/* System start codes for video */
if(len >= 9)
parse_pes_header(t, st, buf + 6, len - 6);
return 1;
case 0x00000100:
/* Picture start code */
if(st->st_frame_duration == 0)
return 1;
if(parse_mpeg2video_pic_start(t, st, &frametype, &bs))
return 1;
if(st->st_curpkt != NULL)
pkt_ref_dec(st->st_curpkt);
st->st_curpkt = pkt_alloc(NULL, 0, st->st_curpts, st->st_curdts);
st->st_curpkt->pkt_frametype = frametype;
st->st_curpkt->pkt_duration = st->st_frame_duration;
st->st_curpkt->pkt_commercial = t->tht_tt_commercial_advice;
break;
case 0x000001b3:
/* Sequence start code */
if(!st->st_buffer_errors) {
if(parse_mpeg2video_seq_start(t, st, &bs))
return 1;
parser_global_data_move(st, buf, len);
}
return 2;
case 0x000001b5:
if(len < 5)
return 1;
switch(buf[4] >> 4) {
case 0x1:
// Sequence Extension
if(!st->st_buffer_errors)
parser_global_data_move(st, buf, len);
return 2;
case 0x2:
// Sequence Display Extension
if(!st->st_buffer_errors)
parser_global_data_move(st, buf, len);
return 2;
}
break;
case 0x00000101 ... 0x000001af:
/* Slices */
if(next_startcode == 0x100 || next_startcode > 0x1af) {
/* Last picture slice (because next not a slice) */
th_pkt_t *pkt = st->st_curpkt;
if(pkt == NULL) {
/* no packet, may've been discarded by sanity checks here */
return 1;
}
if(st->st_global_data) {
pkt->pkt_header = pktbuf_make(st->st_global_data,
st->st_global_data_len);
st->st_global_data = NULL;
st->st_global_data_len = 0;
}
pkt->pkt_payload = pktbuf_make(st->st_buffer, st->st_buffer_ptr - 4);
pkt->pkt_duration = st->st_frame_duration;
parser_deliver(t, st, pkt);
st->st_curpkt = NULL;
st->st_buffer = malloc(st->st_buffer_size);
/* If we know the frame duration, increase DTS accordingly */
if(st->st_curdts != PTS_UNSET)
st->st_curdts += st->st_frame_duration;
/* PTS cannot be extrapolated (it's not linear) */
st->st_curpts = PTS_UNSET;
return 1;
}
break;
case 0x000001b8:
// GOP header
if(!st->st_buffer_errors)
parser_global_data_move(st, buf, len);
return 2;
case 0x000001b2:
// User data
break;
default:
break;
}
return 0;
}
/**
* H.264 parser
*/
static int
parse_h264(th_transport_t *t, th_stream_t *st, size_t len,
uint32_t next_startcode, int sc_offset)
{
uint8_t *buf = st->st_buffer + sc_offset;
uint32_t sc = st->st_startcode;
int64_t d;
int l2, pkttype, duration, isfield;
bitstream_t bs;
int ret = 0;
if(sc >= 0x000001e0 && sc <= 0x000001ef) {
/* System start codes for video */
if(len >= 9)
parse_pes_header(t, st, buf + 6, len - 6);
if(st->st_prevdts != PTS_UNSET && st->st_curdts != PTS_UNSET) {
d = (st->st_curdts - st->st_prevdts) & 0x1ffffffffLL;
if(d < 90000)
st->st_frame_duration = d;
}
st->st_prevdts = st->st_curdts;
return 1;
}
bs.data = NULL;
if(sc == 0x10c) {
// Padding
st->st_buffer_ptr -= len;
ret = 2;
} else {
switch(sc & 0x1f) {
case 7:
if(!st->st_buffer_errors) {
h264_nal_deescape(&bs, buf + 3, len - 3);
h264_decode_seq_parameter_set(st, &bs);
parser_global_data_move(st, buf, len);
}
ret = 2;
break;
case 8:
if(!st->st_buffer_errors) {
h264_nal_deescape(&bs, buf + 3, len - 3);
h264_decode_pic_parameter_set(st, &bs);
parser_global_data_move(st, buf, len);
}
ret = 2;
break;
case 5: /* IDR+SLICE */
case 1:
if(st->st_curpkt != NULL || st->st_frame_duration == 0)
break;
l2 = len - 3 > 64 ? 64 : len - 3;
h264_nal_deescape(&bs, buf + 3, l2); /* we just want the first stuff */
if(h264_decode_slice_header(st, &bs, &pkttype, &duration, &isfield)) {
free(bs.data);
return 1;
}
st->st_curpkt = pkt_alloc(NULL, 0, st->st_curpts, st->st_curdts);
st->st_curpkt->pkt_frametype = pkttype;
st->st_curpkt->pkt_field = isfield;
st->st_curpkt->pkt_duration = duration ?: st->st_frame_duration;
st->st_curpkt->pkt_commercial = t->tht_tt_commercial_advice;
break;
default:
break;
}
}
free(bs.data);
if(next_startcode >= 0x000001e0 && next_startcode <= 0x000001ef) {
/* Complete frame */
th_pkt_t *pkt = st->st_curpkt;
if(pkt != NULL) {
if(st->st_global_data) {
pkt->pkt_header = pktbuf_make(st->st_global_data,
st->st_global_data_len);
st->st_global_data = NULL;
st->st_global_data_len = 0;
}
pkt->pkt_payload = pktbuf_make(st->st_buffer, st->st_buffer_ptr - 4);
parser_deliver(t, st, pkt);
st->st_curpkt = NULL;
st->st_buffer = malloc(st->st_buffer_size);
st->st_curdts = PTS_UNSET;
st->st_curpts = PTS_UNSET;
}
return 1;
}
return ret;
}
/**
* http://broadcasting.ru/pdf-standard-specifications/subtitling/dvb-sub/en300743.v1.2.1.pdf
*/
static void
parse_subtitles(th_transport_t *t, th_stream_t *st, const uint8_t *data,
int len, int start)
{
th_pkt_t *pkt;
int psize, hlen;
uint8_t *buf;
if(start) {
/* Payload unit start */
st->st_parser_state = 1;
st->st_buffer_errors = 0;
}
if(st->st_parser_state == 0)
return;
buffer_append(st, data, len);
if(st->st_buffer_ptr < 6)
return;
uint32_t startcode =
(st->st_buffer[0] << 24) |
(st->st_buffer[1] << 16) |
(st->st_buffer[2] << 8) |
(st->st_buffer[3]);
if(startcode == 0x1be) {
st->st_parser_state = 0;
return;
}
psize = st->st_buffer[4] << 8 | st->st_buffer[5];
if(st->st_buffer_ptr != psize + 6)
return;
st->st_parser_state = 0;
hlen = parse_pes_header(t, st, st->st_buffer + 6, st->st_buffer_ptr - 6);
if(hlen < 0)
return;
psize -= hlen;
buf = st->st_buffer + 6 + hlen;
if(psize < 2 || buf[0] != 0x20 || buf[1] != 0x00)
return;
psize -= 2;
buf += 2;
if(psize >= 6) {
// end_of_PES_data_field_marker
if(buf[psize - 1] == 0xff) {
pkt = pkt_alloc(buf, psize - 1, st->st_curpts, st->st_curdts);
pkt->pkt_commercial = t->tht_tt_commercial_advice;
parser_deliver(t, st, pkt);
}
}
}
/**
*
*/
static void
parser_deliver(th_transport_t *t, th_stream_t *st, th_pkt_t *pkt)
{
#if 0
printf("PARSE: %-12s %d %10"PRId64" %10"PRId64" %10d %10d\n",
streaming_component_type2txt(st->st_type),
pkt->pkt_frametype,
pkt->pkt_dts,
pkt->pkt_pts,
pkt->pkt_duration,
pktbuf_len(pkt->pkt_payload));
#endif
// avgstat_add(&st->st_rate, pkt->pkt_payloadlen, dispatch_clock);
/**
* Input is ok
*/
transport_set_streaming_status_flags(t, TSS_PACKETS);
/* Forward packet */
pkt->pkt_componentindex = st->st_index;
streaming_message_t *sm = streaming_msg_create_pkt(pkt);
streaming_pad_deliver(&t->tht_streaming_pad, sm);
streaming_msg_free(sm);
/* Decrease our own reference to the packet */
pkt_ref_dec(pkt);
}
Reference in a new issue View git blame Copy permalink