[MPlayer-cvslog] CVS: main/libmpdemux demux_ts.c,1.25,1.26
Nico Sabbi CVS
syncmail at mplayerhq.hu
Sun Mar 20 15:21:02 CET 2005
CVS change done by Nico Sabbi CVS
Update of /cvsroot/mplayer/main/libmpdemux
In directory mail:/var2/tmp/cvs-serv23822
Modified Files:
demux_ts.c
Log Message:
initial support for SL packetized data, with certain limitations; partly reworked the tables management for a better code reuse
Index: demux_ts.c
===================================================================
RCS file: /cvsroot/mplayer/main/libmpdemux/demux_ts.c,v
retrieving revision 1.25
retrieving revision 1.26
diff -u -r1.25 -r1.26
--- demux_ts.c 25 Feb 2005 22:27:46 -0000 1.25
+++ demux_ts.c 20 Mar 2005 14:20:59 -0000 1.26
@@ -69,20 +69,30 @@
AUDIO_AAC = mmioFOURCC('M', 'P', '4', 'A'),
SPU_DVD = 0x3000000,
SPU_DVB = 0x3000001,
- PES_PRIVATE1 = 0xBD00000
+ PES_PRIVATE1 = 0xBD00000,
+ SL_PES_STREAM = 0xD000000,
+ SL_SECTION = 0xD100000,
+ MP4_OD = 0xD200000,
} es_stream_type_t;
+typedef struct {
+ uint8_t *buffer;
+ uint16_t buffer_len;
+} ts_section_t;
typedef struct {
int size;
unsigned char *start;
uint16_t payload_size;
- es_stream_type_t type;
+ es_stream_type_t type, subtype;
float pts, last_pts;
int pid;
char lang[4];
int last_cc; // last cc code (-1 if first packet)
- uint64_t seen;
+ ts_section_t section;
+ struct {
+ uint8_t au_start, au_end, last_au_end;
+ } sl;
} ES_stream_t;
@@ -99,6 +109,44 @@
} av_fifo_t;
typedef struct {
+ int32_t object_type; //aka codec used
+ int32_t stream_type; //video, audio etc.
+} mp4_decoder_config_t;
+
+typedef struct {
+ //flags
+ uint8_t flags;
+ uint8_t au_start;
+ uint8_t au_end;
+ uint8_t random_accesspoint;
+ uint8_t random_accesspoint_only;
+ uint8_t padding;
+ uint8_t use_ts;
+ uint8_t idle;
+ uint8_t duration;
+
+ uint32_t ts_resolution, ocr_resolution;
+ uint8_t ts_len, ocr_len, au_len, instant_bitrate_len, degr_len, au_seqnum_len, packet_seqnum_len;
+ uint32_t timescale;
+ uint16_t au_duration, cts_duration;
+ uint64_t ocr, dts, cts;
+} mp4_sl_config_t;
+
+typedef struct {
+ uint16_t id;
+ uint8_t flags;
+ mp4_decoder_config_t decoder;
+ mp4_sl_config_t sl;
+} mp4_es_descr_t;
+
+typedef struct {
+ uint16_t id;
+ uint8_t flags;
+ mp4_es_descr_t *es;
+ uint16_t es_cnt;
+} mp4_od_t;
+
+typedef struct {
uint8_t skip;
uint8_t table_id;
uint8_t ssi;
@@ -113,8 +161,7 @@
uint16_t pmt_pid;
} *progs;
uint16_t progs_cnt;
- char buffer[65535];
- uint16_t buffer_len;
+ ts_section_t section;
} pat_t;
typedef struct {
@@ -129,8 +176,7 @@
uint8_t last_section_number;
uint16_t PCR_PID;
uint16_t prog_descr_length;
- char buffer[2048];
- uint16_t buffer_len;
+ ts_section_t section;
uint16_t es_cnt;
struct pmt_es_t {
uint16_t pid;
@@ -138,7 +184,11 @@
uint16_t descr_length;
uint8_t format_descriptor[5];
uint8_t lang[4];
+ uint16_t mp4_es_id;
} *es;
+ mp4_od_t iod, *od;
+ mp4_es_descr_t *mp4es;
+ int od_cnt, mp4es_cnt;
} pmt_t;
typedef struct {
@@ -153,6 +203,15 @@
} ts_priv_t;
+typedef struct {
+ es_stream_type_t type;
+ ts_section_t section;
+} TS_pids_t;
+
+
+#define IS_AUDIO(x) (((x) == AUDIO_MP2) || ((x) == AUDIO_A52) || ((x) == AUDIO_LPCM_BE) || ((x) == AUDIO_AAC))
+#define IS_VIDEO(x) (((x) == VIDEO_MPEG1) || ((x) == VIDEO_MPEG2) || ((x) == VIDEO_MPEG4) || ((x) == VIDEO_H264))
+
static int ts_parse(demuxer_t *demuxer, ES_stream_t *es, unsigned char *packet, int probe);
extern void resync_audio_stream( sh_audio_t *sh_audio );
@@ -503,8 +562,8 @@
}
}
- is_audio = ((es.type == AUDIO_MP2) || (es.type == AUDIO_A52) || (es.type == AUDIO_LPCM_BE) || (es.type == AUDIO_AAC));
- is_video = ((es.type == VIDEO_MPEG1) || (es.type == VIDEO_MPEG2) || (es.type == VIDEO_MPEG4) || (es.type == VIDEO_H264));
+ is_audio = IS_AUDIO(es.type) || ((es.type==SL_PES_STREAM) && IS_AUDIO(es.subtype));
+ is_video = IS_VIDEO(es.type) || ((es.type==SL_PES_STREAM) && IS_VIDEO(es.subtype));
is_sub = ((es.type == SPU_DVD) || (es.type == SPU_DVB));
@@ -579,7 +638,7 @@
{
if(is_video && (req_vpid == es.pid))
{
- param->vtype = es.type;
+ param->vtype = IS_VIDEO(es.type) ? es.type : es.subtype;
param->vpid = es.pid;
video_found = 1;
break;
@@ -590,7 +649,7 @@
{
if(is_audio && (req_apid == es.pid))
{
- param->atype = es.type;
+ param->atype = IS_AUDIO(es.type) ? es.type : es.subtype;
param->apid = es.pid;
audio_found = 1;
break;
@@ -609,7 +668,7 @@
{
if((req_vpid == -1) || (req_vpid == es.pid))
{
- param->vtype = es.type;
+ param->vtype = IS_VIDEO(es.type) ? es.type : es.subtype;
param->vpid = es.pid;
video_found = 1;
}
@@ -637,7 +696,7 @@
{
if((req_apid == -1) || (req_apid == es.pid))
{
- param->atype = es.type;
+ param->atype = IS_AUDIO(es.type) ? es.type : es.subtype;
param->apid = es.pid;
audio_found = 1;
}
@@ -717,7 +776,6 @@
{
priv->ts.pids[i]->payload_size = 0;
priv->ts.pids[i]->pts = priv->ts.pids[i]->last_pts = 0;
- priv->ts.pids[i]->seen = 0;
priv->ts.pids[i]->last_cc = -1;
}
}
@@ -760,6 +818,8 @@
priv->ts.pids[i] = NULL;
priv->pat.progs = NULL;
priv->pat.progs_cnt = 0;
+ priv->pat.section.buffer = NULL;
+ priv->pat.section.buffer_len = 0;
priv->pmt = NULL;
priv->pmt_cnt = 0;
@@ -848,8 +908,10 @@
priv->fifo[1].buffer_size = 32767;
priv->fifo[2].buffer_size = 32767;
- priv->pat.buffer_len = 0;
-
+ priv->pat.section.buffer_len = 0;
+ for(i = 0; i < priv->pmt_cnt; i++)
+ priv->pmt[i].section.buffer_len = 0;
+
demuxer->filepos = stream_tell(demuxer->stream);
return demuxer;
}
@@ -861,6 +923,8 @@
if(priv)
{
+ if(priv->pat.section.buffer)
+ free(priv->pat.section.buffer);
if(priv->pat.progs)
free(priv->pat.progs);
@@ -868,6 +932,8 @@
{
for(i = 0; i < priv->pmt_cnt; i++)
{
+ if(priv->pmt[i].section.buffer)
+ free(priv->pmt[i].section.buffer);
if(priv->pmt[i].es)
free(priv->pmt[i].es);
}
@@ -878,7 +944,177 @@
demuxer->priv=NULL;
}
-static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, int32_t type_from_pmt)
+
+extern unsigned char mp_getbits(unsigned char*, unsigned int, unsigned char);
+#define getbits mp_getbits
+
+static int mp4_parse_sl_packet(pmt_t *pmt, uint8_t *buf, uint16_t packet_len, int pid, int is_aligned, ES_stream_t *pes_es)
+{
+ int i, n, m, es_id = -1;
+ uint64_t v = 0;
+ uint32_t pl_size = 0;
+ int deg_flag = 0;
+ mp4_es_descr_t *es = NULL;
+ mp4_sl_config_t *sl = NULL;
+ uint8_t au_start = 0, au_end = 0, ocr_flag = 0, random_accesspoint = 0, random_accesspoint_only = 0,
+ padding = 0, padding_bits = 0, use_ts = 0, idle = 0, duration = 0;
+
+ if(! pmt || ! is_aligned || !packet_len) //FIXME
+ return 0;
+
+ for(i = 0; i < pmt->es_cnt; i++)
+ {
+ if(pmt->es[i].pid == pid)
+ es_id = pmt->es[i].mp4_es_id;
+ }
+ if(es_id < 0)
+ return -1;
+
+ for(i = 0; i < pmt->mp4es_cnt; i++)
+ {
+ if(pmt->mp4es[i].id == es_id)
+ es = &(pmt->mp4es[i]);
+ }
+ if(! es)
+ return -1;
+
+ pes_es->subtype = es->decoder.object_type;
+
+ sl = &(es->sl);
+ if(!sl)
+ return -1;
+
+ //now es is the complete es_descriptor of out mp4 ES stream
+ mp_msg(MSGT_DEMUXER,MSGL_DBG2, "ID: %d, FLAGS: 0x%x\n", es->id, sl->flags);
+
+ n = 0;
+ if(sl->au_start)
+ pes_es->sl.au_start = au_start = getbits(buf, n++, 1);
+ else
+ pes_es->sl.au_start = (pes_es->sl.last_au_end ? 1 : 0);
+ if(sl->au_end)
+ pes_es->sl.au_end = au_end = getbits(buf, n++, 1);
+
+ if(!sl->au_start && !sl->au_end)
+ {
+ pes_es->sl.au_start = pes_es->sl.au_end = au_start = au_end = 1;
+ }
+ pes_es->sl.last_au_end = pes_es->sl.au_end;
+
+
+ if(sl->ocr_len > 0)
+ ocr_flag = getbits(buf, n++, 1);
+ if(sl->idle)
+ idle = getbits(buf, n++, 1);
+ if(sl->padding)
+ padding = getbits(buf, n++, 1);
+ if(padding)
+ {
+ padding_bits = getbits(buf, n, 3);
+ n += 3;
+ }
+
+ if(idle || (padding && !padding_bits))
+ {
+ //pes_es->payload_size = 0;
+ return -1;
+ }
+
+ //(! idle && (!padding || padding_bits != 0)) is true
+ n += sl->packet_seqnum_len;
+ if(sl->degr_len)
+ deg_flag = getbits(buf, n++, 3);
+ if(deg_flag)
+ n += sl->degr_len;
+
+ if(ocr_flag)
+ {
+ n += sl->ocr_len;
+ mp_msg(MSGT_DEMUXER,MSGL_DBG2, "OCR: %d bits\n", sl->ocr_len);
+ }
+
+ if(packet_len * 8 <= n)
+ return -1;
+
+ mp_msg(MSGT_DEMUXER,MSGL_DBG2, "\nAU_START: %d, AU_END: %d\n", au_start, au_end);
+ if(au_start)
+ {
+ int dts_flag = 0, cts_flag = 0, ib_flag = 0;
+ uint64_t dts, cts;
+
+ if(sl->random_accesspoint)
+ n++;
+ n += sl->au_seqnum_len;
+ if(packet_len * 8 <= n+8)
+ return -1;
+ if(sl->use_ts)
+ {
+ dts_flag = getbits(buf, n++, 3);
+ cts_flag = getbits(buf, n++, 3);
+ }
+ if(sl->instant_bitrate_len)
+ ib_flag = getbits(buf, n++, 3);
+ if(packet_len * 8 <= n+8)
+ return -1;
+ if(dts_flag && (sl->ts_len > 0))
+ {
+ n += sl->ts_len;
+ mp_msg(MSGT_DEMUXER,MSGL_DBG2, "DTS: %d bits\n", sl->ts_len);
+ }
+ if(packet_len * 8 <= n+8)
+ return -1;
+ if(cts_flag && (sl->ts_len > 0))
+ {
+ int i = 0, m;
+
+ while(i < sl->ts_len)
+ {
+ m = min(8, sl->ts_len - i);
+ v |= getbits(buf, n, m);
+ if(sl->ts_len - i > 8)
+ v <<= 8;
+ i += m;
+ n += m;
+ if(packet_len * 8 <= n+8)
+ return -1;
+ }
+
+ pes_es->pts = (float) v / (float) sl->ts_resolution;
+ mp_msg(MSGT_DEMUXER,MSGL_DBG2, "CTS: %d bits, value: %llu/%d = %.3f\n", sl->ts_len, v, sl->ts_resolution, pes_es->pts);
+ }
+
+
+ i = 0;
+ pl_size = 0;
+ while(i < sl->au_len)
+ {
+ m = min(8, sl->au_len - i);
+ pl_size |= getbits(buf, n, m);
+ if(sl->au_len - i > 8)
+ pl_size <<= 8;
+ i += m;
+ n += m;
+ if(packet_len * 8 <= n+8)
+ return -1;
+ }
+ mp_msg(MSGT_DEMUXER,MSGL_DBG2, "AU_LEN: %u (%d bits)\n", pl_size, sl->au_len);
+ if(ib_flag)
+ n += sl->instant_bitrate_len;
+ }
+
+ m = (n+7)/8;
+ pes_es->payload_size -= min(m, pes_es->payload_size);
+ if(0 < pl_size && pl_size < pes_es->payload_size)
+ pes_es->payload_size = pl_size;
+ //pes_es->sl.size = pes_es->payload_size;
+
+ mp_msg(MSGT_DEMUXER,MSGL_DBG2, "mp4_parse_sl_packet, final n=%d, m=%d, size from pes hdr: %u, size from sl hdr: %d\n",
+ n, m, pes_es->payload_size, pl_size);
+
+ return m;
+}
+
+static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, int32_t type_from_pmt, pmt_t *pmt, int pid)
{
unsigned char *p;
uint32_t header_len;
@@ -889,19 +1125,12 @@
//Here we are always at the start of a PES packet
mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(%p, %d): \n", buf, (uint32_t) packet_len);
- if(packet_len == 0)
- {
- mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(,PACKET_LEN = 0, EXIT\n");
- return 0;
- }
-
- if(packet_len > 184)
+ if(packet_len == 0 || packet_len > 184)
{
- mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2, BUFFER LEN IS TOO BIG: %d, EXIT\n", packet_len);
+ mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2, BUFFER LEN IS TOO SMALL OR TOO BIG: %d EXIT\n", packet_len);
return 0;
}
-
p = buf;
pkt_len = packet_len;
@@ -1049,7 +1278,7 @@
return 1;
}
}
- else if ((stream_id >= 0xbc) && ((stream_id & 0xf0) == 0xe0))
+ else if((stream_id >= 0xe0) && (stream_id <= 0xef))
{
es->start = p;
es->size = packet_len;
@@ -1065,13 +1294,29 @@
}
else if ((stream_id == 0xfa))
{
- if(type_from_pmt != -1) //MP4 A/V
+ int l;
+
+ if(type_from_pmt != UNKNOWN) //MP4 A/V or SL
{
es->start = p;
es->size = packet_len;
es->type = type_from_pmt;
if(es->payload_size)
- es->payload_size -= packet_len;
+ es->payload_size -= es->size;
+
+ if(type_from_pmt == SL_PES_STREAM)
+ {
+ l = mp4_parse_sl_packet(pmt, p, packet_len, pid, pes_is_aligned, es);
+ mp_msg(MSGT_DEMUX, MSGL_DBG2, "L=%d, TYPE=%x\n", l, type_from_pmt);
+ if(l < 0)
+ {
+ mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: couldn't parse SL header, passing along full PES payload\n");
+ l = 0;
+ }
+
+ es->start += l;
+ es->size -= l;
+ }
return 1;
}
@@ -1206,51 +1451,74 @@
}
*/
-static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int size)
+static uint8_t collect_section(ts_section_t *section, int is_start, unsigned char *buff, int size)
{
- uint8_t skip, m = 0;
- unsigned char *ptr;
- unsigned char *base;
- int entries, i, sections;
- uint16_t progid;
- struct pat_progs_t *tmp;
-
- //PRE-FILLING
- if(! is_start)
+ uint8_t skip = 0, *ptr, tid;
+ uint16_t tlen;
+
+ if(! is_start && !section->buffer_len)
+ return 0;
+
+ if(is_start)
{
- if(priv->pat.buffer_len == 0) //a broken packet
+ if(! section->buffer)
{
- return 0;
+ section->buffer = (uint8_t*) malloc(4096+256);
+ if(section->buffer == NULL)
+ return 0;
}
-
- if(priv->pat.skip)
- m = min(priv->pat.skip, size);
-
- priv->pat.skip -= m;
- if(m == size)
- return -1; //keep on buffering
+ section->buffer_len = 0;
}
- else //IS_START, replace the old content
+
+ if(size + section->buffer_len > 4096+256)
{
- priv->pat.buffer_len = 0;
- skip = buff[0]+1;
- m = min(skip, size);
-
- priv->pat.skip = skip - m;
-
- if(m == size)
- return -1;
+ mp_msg(MSGT_DEMUX, MSGL_V, "COLLECT_SECTION, excessive len: %d + %d\n", section->buffer_len, size);
+ return 0;
}
- //FILLING
- memcpy(&(priv->pat.buffer[priv->pat.buffer_len]), &buff[m], size - m);
+ memcpy(&(section->buffer[section->buffer_len]), buff, size);
+ section->buffer_len += size;
+
+ if(section->buffer_len < 3)
+ return 0;
+
+ skip = section->buffer[0];
+ if(skip + 4 > section->buffer_len)
+ return 0;
+
+ ptr = &(section->buffer[skip + 1]);
+ tid = ptr[0];
+ tlen = ((ptr[1] & 0x0f) << 8) | ptr[2];
+ mp_msg(MSGT_DEMUX, MSGL_V, "SKIP: %d+1, TID: %d, TLEN: %d\n", skip, tid, tlen);
+ if(section->buffer_len < (skip+1+3+tlen))
+ {
+ mp_msg(MSGT_DEMUX, MSGL_DBG2, "DATA IS NOT ENOUGH, NEXT TIME\n");
+ return 0;
+ }
+
+ return skip+1;
+}
- priv->pat.buffer_len += size - m;
+static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int size)
+{
+ uint8_t skip;
+ unsigned char *ptr;
+ unsigned char *base;
+ int entries, i;
+ uint16_t progid;
+ struct pat_progs_t *tmp;
+ ts_section_t *section;
+ section = &(priv->pat.section);
+ skip = collect_section(section, is_start, buff, size);
+ if(! skip)
+ return 0;
+
+ ptr = &(section->buffer[skip]);
//PARSING
- ptr = priv->pat.buffer;
-
priv->pat.table_id = ptr[0];
+ if(priv->pat.table_id != 0)
+ return 0;
priv->pat.ssi = (ptr[1] >> 7) & 0x1;
priv->pat.curr_next = ptr[5] & 0x01;
priv->pat.ts_id = (ptr[3] << 8 ) | ptr[4];
@@ -1259,28 +1527,11 @@
priv->pat.section_number = ptr[6];
priv->pat.last_section_number = ptr[7];
-
- if((! priv->pat.curr_next) || (priv->pat.table_id != 0)) // || (! priv->pat.ssi))
- return 0;
-
-
- //beginning of sections loop
- sections = priv->pat.last_section_number - priv->pat.section_number + 1;
- mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PAT, section %d of %d, TOTAL: %d\n", priv->pat.section_number, priv->pat.last_section_number, sections);
-
- if(priv->pat.section_length + 3 > priv->pat.buffer_len)
- {
- mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PAT, section larger than buffer size: %d > %d, EXIT\n",
- priv->pat.section_length, priv->pat.buffer_len - 3);
-
- return -1; //KEEP ON FILLING THE TABLE
- }
-
//check_crc32(0xFFFFFFFFL, ptr, priv->pat.buffer_len - 4, &ptr[priv->pat.buffer_len - 4]);
+ mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PAT: section_len: %d, section %d/%d\n", priv->pat.section_length, priv->pat.section_number, priv->pat.last_section_number);
entries = (int) (priv->pat.section_length - 9) / 4; //entries per section
-
for(i=0; i < entries; i++)
{
int32_t idx;
@@ -1330,6 +1581,373 @@
}
+static uint16_t get_mp4_desc_len(uint8_t *buf, int *len)
+{
+ //uint16_t i = 0, size = 0;
+ int i = 0, j, size = 0;
+
+ mp_msg(MSGT_DEMUX, MSGL_DBG2, "PARSE_MP4_DESC_LEN(%d), bytes: ", *len);
+ j = min(*len, 4);
+ while(i < j)
+ {
+ mp_msg(MSGT_DEMUX, MSGL_DBG2, " %x ", buf[i]);
+ size |= (buf[i] & 0x7f);
+ if(!(buf[i] & 0x80))
+ break;
+ size <<= 7;
+ i++;
+ }
+ mp_msg(MSGT_DEMUX, MSGL_DBG2, ", SIZE=%d\n", size);
+
+ *len = i+1;
+ return size;
+}
+
+
+static uint16_t parse_mp4_slconfig_descriptor(pmt_t *pmt, uint8_t *buf, int len, void *elem)
+{
+ int i = 0;
+ uint64_t tslen = 0;
+ mp4_es_descr_t *es;
+ mp4_sl_config_t *sl;
+
+ mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_SLCONFIG_DESCRIPTOR(%d)\n", len);
+ es = (mp4_es_descr_t *) elem;
+ if(!es)
+ {
+ mp_msg(MSGT_DEMUX, MSGL_V, "argh! NULL elem passed, skip\n");
+ return len;
+ }
+ sl = &(es->sl);
+
+ sl->ts_len = sl->ocr_len = sl->au_len = sl->instant_bitrate_len = sl->degr_len = sl->au_seqnum_len = sl->packet_seqnum_len = 0;
+ sl->ocr = sl->dts = sl->cts = 0;
+
+ if(buf[0] == 0)
+ {
+ i++;
+ sl->flags = buf[i];
+ i++;
+ sl->ts_resolution = (buf[i] << 24) | (buf[i+1] << 16) | (buf[i+2] << 8) | buf[i+3];
+ i += 4;
+ sl->ocr_resolution = (buf[i] << 24) | (buf[i+1] << 16) | (buf[i+2] << 8) | buf[i+3];
+ i += 4;
+ tslen = sl->ts_len = buf[i];
+ i++;
+ sl->ocr_len = buf[i];
+ i++;
+ sl->au_len = buf[i];
+ i++;
+ sl->instant_bitrate_len = buf[i];
+ i++;
+ sl->degr_len = (buf[i] >> 4) & 0x0f;
+ sl->au_seqnum_len = ((buf[i] & 0x0f) << 1) | ((buf[i+1] >> 7) & 0x01);
+ i++;
+ sl->packet_seqnum_len = ((buf[i] >> 2) & 0x1f);
+ i++;
+
+ }
+ else if(buf[0] == 1)
+ {
+ sl->flags = 0;
+ tslen = sl->ts_resolution = 1000;
+ tslen = sl->ts_len = 32;
+ i++;
+ }
+ else if(buf[0] == 2)
+ {
+ sl->flags = 4;
+ i++;
+ }
+ else
+ {
+ sl->flags = 0;
+ i++;
+ }
+
+ sl->au_start = (sl->flags >> 7) & 0x1;
+ sl->au_end = (sl->flags >> 6) & 0x1;
+ sl->random_accesspoint = (sl->flags >> 5) & 0x1;
+ sl->random_accesspoint_only = (sl->flags >> 4) & 0x1;
+ sl->padding = (sl->flags >> 3) & 0x1;
+ sl->use_ts = (sl->flags >> 2) & 0x1;
+ sl->idle = (sl->flags >> 1) & 0x1;
+ sl->duration = sl->flags & 0x1;
+
+ if(sl->duration)
+ {
+ sl->timescale = (buf[i] << 24) | (buf[i+1] << 16) | (buf[i+2] << 8) | buf[i+3];
+ i += 4;
+ sl->au_duration = (buf[i] << 8) | buf[i+1];
+ i += 2;
+ sl->cts_duration = (buf[i] << 8) | buf[i+1];
+ i += 2;
+ }
+ else //no support for fixed durations atm
+ sl->timescale = sl->au_duration = sl->cts_duration = 0;
+
+ mp_msg(MSGT_DEMUX, MSGL_V, "MP4SLCONFIG(0x%x), predef: %d, flags: %x, use_ts: %d, tslen: %d, timescale: %d, dts: %llu, cts: %llu\n",
+ len, buf[0], sl->flags, sl->use_ts, sl->ts_len, sl->timescale, (uint64_t) sl->dts, (uint64_t) sl->cts);
+
+ return len;
+}
+
+static int parse_mp4_descriptors(pmt_t *pmt, uint8_t *buf, int len, void *elem);
+
+static uint16_t parse_mp4_decoder_config_descriptor(pmt_t *pmt, uint8_t *buf, int len, void *elem)
+{
+ int i = 0;
+ mp4_es_descr_t *es;
+ mp4_decoder_config_t *dec;
+
+ mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_DECODER_CONFIG_DESCRIPTOR(%d)\n", len);
+ es = (mp4_es_descr_t *) elem;
+ if(!es)
+ {
+ mp_msg(MSGT_DEMUX, MSGL_V, "argh! NULL elem passed, skip\n");
+ return len;
+ }
+ dec = (mp4_decoder_config_t*) &(es->decoder);
+
+ dec->object_type = buf[i];
+ dec->stream_type = (buf[i+1]>>2) & 0x3f;
+
+ if(dec->object_type == 1 && dec->stream_type == 1)
+ {
+ dec->object_type = MP4_OD;
+ dec->stream_type = MP4_OD;
+ }
+ else if(dec->stream_type == 4)
+ {
+ if(dec->object_type == 0x6a)
+ dec->object_type = VIDEO_MPEG1;
+ if(dec->object_type >= 0x60 && dec->object_type <= 0x65)
+ dec->object_type = VIDEO_MPEG2;
+ else if(dec->object_type == 0x20)
+ dec->object_type = VIDEO_MPEG4;
+ else if(dec->object_type == 0x21)
+ dec->object_type = VIDEO_H264;
+ else dec->object_type = UNKNOWN;
+ }
+ else if(dec->stream_type == 5)
+ {
+ if(dec->object_type == 0x40)
+ dec->object_type = AUDIO_AAC;
+ else if(dec->object_type == 0x6b)
+ dec->object_type = AUDIO_MP2;
+ else if(dec->object_type >= 0x66 && dec->object_type <= 0x69)
+ dec->object_type = AUDIO_MP2;
+ }
+ else
+ dec->object_type = dec->stream_type = UNKNOWN;
+
+ mp_msg(MSGT_DEMUX, MSGL_V, "MP4DECODER(0x%x), object_type: 0x%x, stream_type: 0x%x\n", len, dec->object_type, dec->stream_type);
+
+ return len;
+}
+
+static uint16_t parse_mp4_es_descriptor(pmt_t *pmt, uint8_t *buf, int len, void *elem)
+{
+ int i = 0, j = 0, k, found;
+ uint8_t flag;
+ mp4_es_descr_t es, *target_es, *tmp;
+
+ mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4ES: len=%d\n", len);
+
+ while(i < len)
+ {
+ es.id = (buf[i] << 8) | buf[i+1];
+ mp_msg(MSGT_DEMUX, MSGL_V, "MP4ES_ID: %d\n", es.id);
+ i += 2;
+ flag = buf[i];
+ i++;
+ if(flag & 0x80)
+ i += 2;
+ if(flag & 0x40)
+ i += buf[i]+1;
+ if(flag & 0x20) //OCR, maybe we need it
+ i += 2;
+
+ j = parse_mp4_descriptors(pmt, &buf[i], len-i, &es);
+ mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4ES, types after parse_mp4_descriptors: 0x%x, 0x%x\n", es.decoder.object_type, es.decoder.stream_type);
+ if(es.decoder.object_type != UNKNOWN && es.decoder.stream_type != UNKNOWN)
+ {
+ found = 0;
+ //search this ES_ID if we already have it
+ for(k=0; k < pmt->mp4es_cnt; k++)
+ {
+ if(pmt->mp4es[k].id == es.id)
+ {
+ target_es = &(pmt->mp4es[k]);
+ found = 1;
+ }
+ }
+
+ if(! found)
+ {
+ tmp = (mp4_es_descr_t *) realloc(pmt->mp4es, sizeof(mp4_es_descr_t)*(pmt->mp4es_cnt+1));
+ if(tmp == NULL)
+ {
+ fprintf(stderr, "CAN'T REALLOC MP4_ES_DESCR\n");
+ continue;
+ }
+ pmt->mp4es = tmp;
+ target_es = &(pmt->mp4es[pmt->mp4es_cnt]);
+ pmt->mp4es_cnt++;
+ }
+ memcpy(target_es, &es, sizeof(mp4_es_descr_t));
+ mp_msg(MSGT_DEMUX, MSGL_V, "MP4ES_CNT: %d, ID=%d\n", pmt->mp4es_cnt, target_es->id);
+ }
+
+ i += j;
+ }
+
+ return len;
+}
+
+static int parse_mp4_object_descriptor(pmt_t *pmt, uint8_t *buf, int len, void *elem)
+{
+ int i, j = 0, id;
+
+ id = (buf[0] << 2) | ((buf[1] & 0xc0) >> 6);
+ mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_OBJECT_DESCRIPTOR: len=%d, OD_ID=%d\n", len, id);
+ if(buf[1] & 0x20)
+ {
+ i += buf[2] + 1; //url
+ mp_msg(MSGT_DEMUX, MSGL_V, "URL\n");
+ }
+ else
+ {
+ i = 2;
+
+ while(i < len)
+ {
+ j = parse_mp4_descriptors(pmt, &(buf[i]), len-i, elem);
+ mp_msg(MSGT_DEMUX, MSGL_V, "OBJD, NOW i = %d, j=%d, LEN=%d\n", i, j, len);
+ i += j;
+ }
+ }
+}
+
+
+static int parse_mp4_iod(pmt_t *pmt, uint8_t *buf, int len, void *elem)
+{
+ int i, j = 0;
+ mp4_od_t *iod = &(pmt->iod);
+
+ iod->id = (buf[0] << 2) | ((buf[1] & 0xc0) >> 6);
+ mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_IOD: len=%d, IOD_ID=%d\n", len, iod->id);
+ i = 2;
+ if(buf[1] & 0x20)
+ {
+ i += buf[2] + 1; //url
+ mp_msg(MSGT_DEMUX, MSGL_V, "URL\n");
+ }
+ else
+ {
+ i = 7;
+ while(i < len)
+ {
+ j = parse_mp4_descriptors(pmt, &(buf[i]), len-i, elem);
+ mp_msg(MSGT_DEMUX, MSGL_V, "IOD, NOW i = %d, j=%d, LEN=%d\n", i, j, len);
+ i += j;
+ }
+ }
+}
+
+static int parse_mp4_descriptors(pmt_t *pmt, uint8_t *buf, int len, void *elem)
+{
+ int tag, descr_len, i = 0, j = 0;
+
+ mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_DESCRIPTORS, len=%d\n", len);
+ if(! len)
+ return len;
+
+ while(i < len)
+ {
+ tag = buf[i];
+ j = len - i -1;
+ descr_len = get_mp4_desc_len(&(buf[i+1]), &j);
+ mp_msg(MSGT_DEMUX, MSGL_V, "TAG=%d (0x%x), DESCR_len=%d, len=%d, j=%d\n", tag, tag, descr_len, len, j);
+ if(descr_len > len - j+1)
+ {
+ mp_msg(MSGT_DEMUX, MSGL_V, "descriptor is too long, exit\n");
+ return len;
+ }
+ i += j+1;
+
+ switch(tag)
+ {
+ case 0x1:
+ parse_mp4_object_descriptor(pmt, &(buf[i]), descr_len, elem);
+ break;
+ case 0x2:
+ parse_mp4_iod(pmt, &(buf[i]), descr_len, elem);
+ break;
+ case 0x3:
+ parse_mp4_es_descriptor(pmt, &(buf[i]), descr_len, elem);
+ break;
+ case 0x4:
+ parse_mp4_decoder_config_descriptor(pmt, &buf[i], descr_len, elem);
+ break;
+ case 0x6:
+ parse_mp4_slconfig_descriptor(pmt, &buf[i], descr_len, elem);
+ break;
+ default:
+ mp_msg(MSGT_DEMUX, MSGL_V, "Unsupported mp4 descriptor 0x%x\n", tag);
+ }
+ i += descr_len;
+ }
+
+ return len;
+}
+
+static ES_stream_t *new_pid(ts_priv_t *priv, int pid)
+{
+ ES_stream_t *tss;
+
+ tss = malloc(sizeof(ES_stream_t));
+ if(! tss)
+ return NULL;
+ memset(tss, 0, sizeof(ES_stream_t));
+ tss->pid = pid;
+ tss->last_cc = -1;
+ tss->type = UNKNOWN;
+ tss->subtype = UNKNOWN;
+ priv->ts.pids[pid] = tss;
+
+ return tss;
+}
+
+
+static int parse_program_descriptors(pmt_t *pmt, uint8_t *buf, uint16_t len)
+{
+ uint16_t i = 0, k, olen = len;
+
+ while(len > 0)
+ {
+ mp_msg(MSGT_DEMUX, MSGL_V, "PROG DESCR, TAG=%x, LEN=%d(%x)\n", buf[i], buf[i+1], buf[i+1]);
+ if(buf[i+1] > len-2)
+ {
+ mp_msg(MSGT_DEMUX, MSGL_V, "ERROR, descriptor len is too long, skipping\n");
+ return olen;
+ }
+
+ if(buf[i] == 0x1d)
+ {
+ if(buf[i+3] == 2) //buggy versions of vlc muxer make this non-standard mess (missing iod_scope)
+ k = 3;
+ else
+ k = 4; //this is standard compliant
+ parse_mp4_descriptors(pmt, &buf[i+k], (int) buf[i+1]-(k-2), NULL);
+ }
+
+ len -= 2 + buf[i+1];
+ }
+
+ return olen;
+}
+
static int parse_descriptors(struct pmt_es_t *es, uint8_t *ptr)
{
int j, descr_len, len;
@@ -1339,18 +1957,21 @@
while(len > 2)
{
descr_len = ptr[j+1];
- mp_msg(MSGT_DEMUX, MSGL_DBG2, "...descr id: 0x%x, len=%d\n", ptr[j], descr_len);
+ mp_msg(MSGT_DEMUX, MSGL_V, "...descr id: 0x%x, len=%d\n", ptr[j], descr_len);
if(descr_len > len)
{
- mp_msg(MSGT_DEMUX, MSGL_DBG2, "INVALID DESCR LEN: %d vs %d max, EXIT LOOP\n", descr_len, len);
+ mp_msg(MSGT_DEMUX, MSGL_ERR, "INVALID DESCR LEN for tag %02x: %d vs %d max, EXIT LOOP\n", ptr[j], descr_len, len);
return -1;
}
if(ptr[j] == 0x6a) //A52 Descriptor
{
- es->type = AUDIO_A52;
- mp_msg(MSGT_DEMUX, MSGL_DBG2, "DVB A52 Descriptor\n");
+ if(es->type == 0x6)
+ {
+ es->type = AUDIO_A52;
+ mp_msg(MSGT_DEMUX, MSGL_DBG2, "DVB A52 Descriptor\n");
+ }
}
else if(ptr[j] == 0x59) //Subtitling Descriptor
{
@@ -1413,6 +2034,11 @@
mp_msg(MSGT_DEMUX, MSGL_DBG2, "FORMAT %s\n", es->format_descriptor);
}
}
+ else if(ptr[j] == 0x1e)
+ {
+ es->mp4_es_id = (ptr[j+2] << 8) | ptr[j+3];
+ mp_msg(MSGT_DEMUX, MSGL_V, "SL Descriptor: ES_ID: %d(%x), pid: %d\n", es->mp4_es_id, es->mp4_es_id, es->pid);
+ }
else
mp_msg(MSGT_DEMUX, MSGL_DBG2, "Unknown descriptor 0x%x, SKIPPING\n", ptr[j]);
@@ -1423,7 +2049,32 @@
return 1;
}
-
+static int parse_sl_section(pmt_t *pmt, ts_section_t *section, uint16_t progid, uint16_t pid, int is_start, unsigned char *buff, int size)
+{
+ int tid, len, skip;
+ uint8_t *ptr;
+ skip = collect_section(section, is_start, buff, size);
+ if(! skip)
+ return 0;
+
+ ptr = &(section->buffer[skip]);
+ tid = ptr[0];
+ len = ((ptr[1] & 0x0f) << 8) | ptr[2];
+ mp_msg(MSGT_DEMUX, MSGL_V, "TABLEID: %d (av. %d), skip=%d, LEN: %d\n", tid, section->buffer_len, skip, len);
+ if(len > 4093 || section->buffer_len < len || tid != 5)
+ {
+ mp_msg(MSGT_DEMUX, MSGL_V, "SECTION TOO LARGE or wrong section type, EXIT\n");
+ return 0;
+ }
+
+ if(! (ptr[5] & 1))
+ return 0;
+
+ //8 is the current position, len - 9 is the amount of data available
+ parse_mp4_descriptors(pmt, &ptr[8], len - 9, NULL);
+
+ return 1;
+}
static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_start, unsigned char *buff, int size)
{
@@ -1433,7 +2084,9 @@
uint8_t skip, m=0;
pmt_t *tmp;
struct pmt_es_t *tmp_es;
-
+ ts_section_t *section;
+ ES_stream_t *tss;
+
idx = progid_idx_in_pmt(priv, progid);
if(idx == -1)
@@ -1453,53 +2106,21 @@
pmt = &(priv->pmt[idx]);
-
- if(! is_start)
- {
- if(pmt->buffer_len == 0)
- {
- //BROKEN PMT PACKET, DISCARD
- return -1;
- }
-
- if(pmt->skip)
- m = min(pmt->skip, size);
-
- pmt->skip -= m;
- if(m == size)
- return 0;
- }
- else
- {
- pmt->buffer_len = 0;
- skip = buff[0] + 1;
- m = min(skip, size);
-
- pmt->skip = skip - m;
-
- if(m == size)
- return 0;
- }
-
-
- if(size-m + pmt->buffer_len > 2048)
- {
- mp_msg(MSGT_DEMUX, MSGL_V, "FILL_PMT(prog=%d, PID=%d), ERROR! PMT TOO LONG, IGNORING\n", progid, pid);
- pmt->buffer_len = 0;
+ section = &(pmt->section);
+ skip = collect_section(section, is_start, buff, size);
+ if(! skip)
return 0;
- }
+
+ base = &(section->buffer[skip]);
- memcpy(&(pmt->buffer[pmt->buffer_len]), &buff[m], size - m);
pmt->progid = progid;
- pmt->buffer_len += size - m;
mp_msg(MSGT_DEMUX, MSGL_V, "FILL_PMT(prog=%d), PMT_len: %d, IS_START: %d, TS_PID: %d, SIZE=%d, M=%d, ES_CNT=%d, IDX=%d, PMT_PTR=%p\n",
- progid, pmt->buffer_len, is_start, pid, size, m, pmt->es_cnt, idx, pmt);
-
- base = pmt->buffer;
-
+ progid, pmt->section.buffer_len, is_start, pid, size, m, pmt->es_cnt, idx, pmt);
pmt->table_id = base[0];
+ if(pmt->table_id != 2)
+ return -1;
pmt->ssi = base[1] & 0x80;
pmt->section_length = (((base[1] & 0xf) << 8 ) | base[2]);
pmt->version_number = (base[5] >> 1) & 0x1f;
@@ -1508,26 +2129,14 @@
pmt->last_section_number = base[7];
pmt->PCR_PID = ((base[8] & 0x1f) << 8 ) | base[9];
pmt->prog_descr_length = ((base[10] & 0xf) << 8 ) | base[11];
-
-
-
- if((pmt->curr_next == 0) || (pmt->table_id != 2))
- return -1;
-
-
- if(pmt->section_length + 3 > pmt->buffer_len)
- {
- mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, SECTION LENGTH TOO LARGE FOR CURRENT BUFFER (%d vs %d), NEXT TIME\n", pmt->section_length, pmt->buffer_len);
-
- return -1;
- }
-
if(pmt->prog_descr_length > pmt->section_length - 9)
{
mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, INVALID PROG_DESCR LENGTH (%d vs %d)\n", pmt->prog_descr_length, pmt->section_length - 9);
return -1;
}
+ if(pmt->prog_descr_length)
+ parse_program_descriptors(pmt, &base[12], pmt->prog_descr_length);
es_base = &base[12 + pmt->prog_descr_length]; //the beginning of th ES loop
@@ -1569,9 +2178,12 @@
pmt->es[idx].pid = es_pid;
- pmt->es[idx].type = es_type;
-
- pmt->es[idx].type = UNKNOWN;
+ if(es_type != 0x6)
+ pmt->es[idx].type = UNKNOWN;
+ else
+ pmt->es[idx].type = es_type;
+
+ parse_descriptors(&pmt->es[idx], &es_base[5]);
switch(es_type)
{
@@ -1583,12 +2195,10 @@
break;
case 3:
case 4:
- parse_descriptors(&pmt->es[idx], &es_base[5]);
pmt->es[idx].type = AUDIO_MP2;
break;
case 6:
- parse_descriptors(&pmt->es[idx], &es_base[5]);
- if(pmt->es[idx].type == 0x6)
+ if(pmt->es[idx].type == 0x6) //this could have been ovrwritten by parse_descriptors
pmt->es[idx].type = UNKNOWN;
break;
case 0x10:
@@ -1596,28 +2206,31 @@
break;
case 0x0f:
case 0x11:
- parse_descriptors(&pmt->es[idx], &es_base[5]);
pmt->es[idx].type = AUDIO_AAC;
break;
case 0x1b:
pmt->es[idx].type = VIDEO_H264;
break;
+ case 0x12:
+ pmt->es[idx].type = SL_PES_STREAM;
+ break;
+ case 0x13:
+ pmt->es[idx].type = SL_SECTION;
+ break;
case 0x81:
pmt->es[idx].type = AUDIO_A52;
break;
-
default:
- {
- if(es_type > 0x80)
- {
- parse_descriptors(&pmt->es[idx], &es_base[5]);
- }
- else
- {
- mp_msg(MSGT_DEMUX, MSGL_DBG2, "UNKNOWN ES TYPE=0x%x\n", es_type);
- pmt->es[idx].type = UNKNOWN;
- }
- }
+ mp_msg(MSGT_DEMUX, MSGL_DBG2, "UNKNOWN ES TYPE=0x%x\n", es_type);
+ pmt->es[idx].type = UNKNOWN;
+ }
+
+ tss = priv->ts.pids[es_pid]; //an ES stream
+ if(tss == NULL)
+ {
+ tss = new_pid(priv, es_pid);
+ if(tss)
+ tss->type = pmt->es[idx].type;
}
section_bytes -= 5 + pmt->es[idx].descr_length;
@@ -1634,6 +2247,27 @@
return 1;
}
+static pmt_t* pmt_of_pid(ts_priv_t *priv, int pid)
+{
+ int32_t i, j;
+
+ if(priv->pmt)
+ {
+ for(i = 0; i < priv->pmt_cnt; i++)
+ {
+ if(priv->pmt[i].es && priv->pmt[i].es_cnt)
+ {
+ for(j = 0; j < priv->pmt[i].es_cnt; j++)
+ if(priv->pmt[i].es[j].pid == pid)
+ return &(priv->pmt[i]);
+ }
+ }
+
+ }
+
+ return NULL;
+}
+
static inline int32_t pid_type_from_pmt(ts_priv_t *priv, int pid)
{
@@ -1723,6 +2357,7 @@
int *dp_offset = 0, *buffer_size = 0;
int32_t progid, pid_type, bad, ts_error;
int junk = 0;
+ pmt_t *pmt;
while(! done)
@@ -1768,16 +2403,9 @@
tss = priv->ts.pids[pid]; //an ES stream
if(tss == NULL)
{
- tss = malloc(sizeof(ES_stream_t));
- if(! tss)
+ tss = new_pid(priv, pid);
+ if(tss == NULL)
continue;
- memset(tss, 0, sizeof(ES_stream_t));
- tss->pid = pid;
- tss->last_cc = -1;
- tss->type = UNKNOWN;
- tss->payload_size = 0;
- tss->seen = 0;
- priv->ts.pids[pid] = tss;
}
@@ -1837,11 +2465,10 @@
is_start = 0; //queued to the packet data
}
- tss->seen++;
- if(tss->seen == 16 && cc_ok) //at least a complete round
- mp_msg(MSGT_DEMUX, MSGL_V, "\nNew TS pid=%u\n", pid);
-
-
+ //find the program that the pid belongs to; if (it's the right one or -1) && pid_type==SL_SECTION
+ //call parse_sl_section()
+ pmt = pmt_of_pid(priv, pid);
+
//TABLE PARSING
base = priv->ts.packet_size - buf_size;
@@ -1852,6 +2479,30 @@
parse_pat(priv, is_start, &packet[base], buf_size);
continue;
}
+ else if((tss->type == SL_SECTION) && pmt)
+ {
+ int k, ok=0, mp4_es_id = -1;
+ ts_section_t *section;
+ for(k = 0; k < pmt->mp4es_cnt; k++)
+ {
+ if(pmt->mp4es[k].decoder.object_type == MP4_OD && pmt->mp4es[k].decoder.stream_type == MP4_OD)
+ mp4_es_id = pmt->mp4es[k].id;
+ }
+ mp_msg(MSGT_DEMUX, MSGL_V, "ESID: %d\n", mp4_es_id);
+ for(k = 0; k < pmt->es_cnt; k++)
+ {
+ if(pmt->es[k].mp4_es_id == mp4_es_id)
+ ok = 1;
+ }
+ stream_read(stream,&packet[base], buf_size);
+ stream_skip(stream, junk);
+ if(ok)
+ {
+ section = &(tss->section);
+ parse_sl_section(pmt, section, progid, pid, is_start, &packet[base], buf_size);
+ }
+ continue;
+ }
else
{
progid = prog_id_in_pat(priv, pid);
@@ -1872,9 +2523,8 @@
priv->last_pid = pid;
- is_video = ((tss->type == VIDEO_MPEG1) || (tss->type == VIDEO_MPEG2) || (tss->type == VIDEO_MPEG4) || (tss->type == VIDEO_H264));
- is_audio = ((tss->type == AUDIO_MP2) || (tss->type == AUDIO_A52) || (tss->type == AUDIO_LPCM_BE) || (tss->type == AUDIO_AAC)
- || (tss->type == PES_PRIVATE1));
+ is_video = IS_VIDEO(tss->type) || (tss->type==SL_PES_STREAM && IS_VIDEO(tss->subtype));
+ is_audio = IS_AUDIO(tss->type) || (tss->type==SL_PES_STREAM && IS_AUDIO(tss->subtype)) || (tss->type == PES_PRIVATE1);
is_sub = ((tss->type == SPU_DVD) || (tss->type == SPU_DVB));
pid_type = pid_type_from_pmt(priv, pid);
@@ -1992,7 +2642,7 @@
stream_read(stream, p, buf_size);
stream_skip(stream, junk);
- len = pes_parse2(p, buf_size, es, pid_type);
+ len = pes_parse2(p, buf_size, es, pid_type, pmt, pid);
es->pid = tss->pid;
if(probe)
@@ -2012,6 +2662,7 @@
{
uint8_t *lang = NULL;
tss->type = es->type;
+ tss->subtype = es->subtype;
if(is_audio)
lang = pid_lang_from_pmt(priv, es->pid);
@@ -2095,6 +2746,7 @@
es->pid = tss->pid;
es->type = tss->type;
+ es->subtype = tss->subtype;
es->pts = tss->pts = tss->last_pts;
es->start = &packet[base];
More information about the MPlayer-cvslog
mailing list