From ae9c3d530c55e86eb54d8cf23a23c5ce6301ec6e Mon Sep 17 00:00:00 2001 From: wm4 Date: Fri, 7 Sep 2012 14:42:25 +0200 Subject: libmpdemux: add back demux_ts Someone wanted this. Apparently both libavformat's TS demuxer and demux_ts are crap, and work/fail in different cases. This demuxer has been removed in 1fde09db6f4ce. All code added comes from the revision before that. Some required bits have been added in the commit before this one (re-adding demux_mpg), in particular the changes to video.c. stream_dvb will use this demuxer by default, otherwise demux_lavf is preferred (as it has been before). Some TS related command line options are not re-added. Closed captions might not work. --- Makefile | 1 + libmpdemux/demux_ts.c | 3533 +++++++++++++++++++++++++++++++++++++++++++++++++ libmpdemux/demux_ts.h | 24 + libmpdemux/demuxer.c | 15 +- libmpdemux/stheader.h | 2 + 5 files changed, 3574 insertions(+), 1 deletion(-) create mode 100644 libmpdemux/demux_ts.c create mode 100644 libmpdemux/demux_ts.h diff --git a/Makefile b/Makefile index 34e4bdef8f..863eeb4b85 100644 --- a/Makefile +++ b/Makefile @@ -235,6 +235,7 @@ SRCS_COMMON = asxparser.c \ libmpdemux/demux_mf.c \ libmpdemux/demux_mkv.c \ libmpdemux/demux_mpg.c \ + libmpdemux/demux_ts.c \ libmpdemux/mp3_hdr.c \ libmpdemux/parse_es.c \ libmpdemux/mpeg_hdr.c \ diff --git a/libmpdemux/demux_ts.c b/libmpdemux/demux_ts.c new file mode 100644 index 0000000000..dbf12b7456 --- /dev/null +++ b/libmpdemux/demux_ts.c @@ -0,0 +1,3533 @@ +/* + * Demultiplexer for MPEG2 Transport Streams. + * + * Written by Nico + * Kind feedback is appreciated; 'sucks' and alike is not. + * Originally based on demux_pva.c written by Matteo Giani and FFmpeg (libavformat) sources + * + * This file is part of MPlayer. + * + * MPlayer 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 2 of the License, or + * (at your option) any later version. + * + * MPlayer 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 MPlayer; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include +#include +#include + +#include "config.h" +#include "mp_msg.h" +#include "options.h" + +#include "libmpcodecs/dec_audio.h" +#include "stream/stream.h" +#include "demuxer.h" +#include "parse_es.h" +#include "stheader.h" +#include "ms_hdr.h" +#include "mpeg_hdr.h" +#include "demux_ts.h" + +#define TS_PH_PACKET_SIZE 192 +#define TS_FEC_PACKET_SIZE 204 +#define TS_PACKET_SIZE 188 +#define NB_PID_MAX 8192 + +#define MAX_HEADER_SIZE 6 /* enough for PES header + length */ +#define MAX_CHECK_SIZE 65535 +#define NUM_CONSECUTIVE_TS_PACKETS 32 +#define NUM_CONSECUTIVE_AUDIO_PACKETS 348 +#define MAX_A52_FRAME_SIZE 3840 + +#ifndef SIZE_MAX +#define SIZE_MAX ((size_t)-1) +#endif + +#define TYPE_AUDIO 1 +#define TYPE_VIDEO 2 +#define TYPE_SUB 3 + +int ts_prog; +int ts_keep_broken=0; +off_t ts_probe = 0; +int audio_substream_id = -1; + +typedef enum +{ + UNKNOWN = -1, + VIDEO_MPEG1 = 0x10000001, + VIDEO_MPEG2 = 0x10000002, + VIDEO_MPEG4 = 0x10000004, + VIDEO_H264 = 0x10000005, + VIDEO_AVC = mmioFOURCC('a', 'v', 'c', '1'), + VIDEO_DIRAC = mmioFOURCC('d', 'r', 'a', 'c'), + VIDEO_VC1 = mmioFOURCC('W', 'V', 'C', '1'), + AUDIO_MP2 = 0x50, + AUDIO_A52 = 0x2000, + AUDIO_DTS = 0x2001, + AUDIO_LPCM_BE = 0x10001, + AUDIO_AAC = mmioFOURCC('M', 'P', '4', 'A'), + AUDIO_AAC_LATM = mmioFOURCC('M', 'P', '4', 'L'), + AUDIO_TRUEHD = mmioFOURCC('T', 'R', 'H', 'D'), + AUDIO_S302M = mmioFOURCC('B', 'S', 'S', 'D'), + SPU_DVD = 0x3000000, + SPU_DVB = 0x3000001, + SPU_TELETEXT = 0x3000002, + SPU_PGS = 0x3000003, + 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, subtype; + double pts, last_pts; + int pid; + char lang[4]; + int last_cc; // last cc code (-1 if first packet) + int is_synced; + ts_section_t section; + uint8_t *extradata; + int extradata_alloc, extradata_len; + struct { + uint8_t au_start, au_end, last_au_end; + } sl; +} ES_stream_t; + +typedef struct { + void *sh; + int id; + int type; +} sh_av_t; + +typedef struct MpegTSContext { + int packet_size; // raw packet size, including FEC if present e.g. 188 bytes + ES_stream_t *pids[NB_PID_MAX]; + sh_av_t streams[NB_PID_MAX]; +} MpegTSContext; + + +typedef struct { + demux_stream_t *ds; + demux_packet_t *pack; + int offset, buffer_size; +} av_fifo_t; + +#define MAX_EXTRADATA_SIZE 64*1024 +typedef struct { + int32_t object_type; //aka codec used + int32_t stream_type; //video, audio etc. + uint8_t buf[MAX_EXTRADATA_SIZE]; + uint16_t buf_size; + uint8_t szm1; +} 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; + uint16_t section_length; + uint16_t ts_id; + uint8_t version_number; + uint8_t curr_next; + uint8_t section_number; + uint8_t last_section_number; + struct pat_progs_t { + uint16_t id; + uint16_t pmt_pid; + } *progs; + uint16_t progs_cnt; + ts_section_t section; +} pat_t; + +typedef struct { + uint16_t progid; + uint8_t skip; + uint8_t table_id; + uint8_t ssi; + uint16_t section_length; + uint8_t version_number; + uint8_t curr_next; + uint8_t section_number; + uint8_t last_section_number; + uint16_t PCR_PID; + uint16_t prog_descr_length; + ts_section_t section; + uint16_t es_cnt; + struct pmt_es_t { + uint16_t pid; + uint32_t type; //it's 8 bit long, but cast to the right type as FOURCC + 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 { + uint64_t size; + float duration; + double first_pts; + double last_pts; +} TS_stream_info; + +typedef struct { + MpegTSContext ts; + int last_pid; + av_fifo_t fifo[3]; //0 for audio, 1 for video, 2 for subs + pat_t pat; + pmt_t *pmt; + uint16_t pmt_cnt; + uint32_t prog; + uint32_t vbitrate; + int keep_broken; + int last_aid; + int last_vid; + int last_sid; + char packet[TS_FEC_PACKET_SIZE]; + TS_stream_info vstr, astr; +} ts_priv_t; + + +typedef struct { + es_stream_type_t type; + ts_section_t section; +} TS_pids_t; + + +static int IS_AUDIO(es_stream_type_t type) +{ + switch (type) { + case AUDIO_MP2: + case AUDIO_A52: + case AUDIO_LPCM_BE: + case AUDIO_AAC: + case AUDIO_AAC_LATM: + case AUDIO_DTS: + case AUDIO_TRUEHD: + case AUDIO_S302M: + return 1; + } + return 0; +} + +static int IS_VIDEO(es_stream_type_t type) +{ + switch (type) { + case VIDEO_MPEG1: + case VIDEO_MPEG2: + case VIDEO_MPEG4: + case VIDEO_H264: + case VIDEO_AVC: + case VIDEO_DIRAC: + case VIDEO_VC1: + return 1; + } + return 0; +} + +static int IS_SUB(es_stream_type_t type) +{ + switch (type) { + case SPU_DVD: + case SPU_DVB: + case SPU_PGS: + case SPU_TELETEXT: + return 1; + } + return 0; +} + +static int ts_parse(demuxer_t *demuxer, ES_stream_t *es, unsigned char *packet, int probe); + +static uint8_t get_packet_size(const unsigned char *buf, int size) +{ + int i; + + if (size < (TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS)) + return 0; + + for(i=0; ipriv; + + if(priv->ts.streams[es->pid].sh) + return; + + if((IS_AUDIO(es->type) || IS_AUDIO(es->subtype)) && priv->last_aid+1 < MAX_A_STREAMS) + { + sh_audio_t *sh = new_sh_audio_aid(demuxer, priv->last_aid, es->pid); + if(sh) + { + const char *lang = pid_lang_from_pmt(priv, es->pid); + sh->needs_parsing = 1; + sh->format = IS_AUDIO(es->type) ? es->type : es->subtype; + sh->ds = demuxer->audio; + + priv->ts.streams[es->pid].id = priv->last_aid; + priv->ts.streams[es->pid].sh = sh; + priv->ts.streams[es->pid].type = TYPE_AUDIO; + mp_msg(MSGT_DEMUX, MSGL_V, "\r\nADDED AUDIO PID %d, type: %x stream n. %d\r\n", es->pid, sh->format, priv->last_aid); + if (lang && lang[0]) + mp_msg(MSGT_IDENTIFY, MSGL_V, "ID_AID_%d_LANG=%s\n", es->pid, lang); + priv->last_aid++; + } + + if(es->extradata && es->extradata_len) + { + sh->wf = malloc(sizeof(*sh->wf) + es->extradata_len); + sh->wf->cbSize = es->extradata_len; + memcpy(sh->wf + 1, es->extradata, es->extradata_len); + } + } + + if((IS_VIDEO(es->type) || IS_VIDEO(es->subtype)) && priv->last_vid+1 < MAX_V_STREAMS) + { + sh_video_t *sh = new_sh_video_vid(demuxer, priv->last_vid, es->pid); + if(sh) + { + sh->format = IS_VIDEO(es->type) ? es->type : es->subtype; + sh->ds = demuxer->video; + + priv->ts.streams[es->pid].id = priv->last_vid; + priv->ts.streams[es->pid].sh = sh; + priv->ts.streams[es->pid].type = TYPE_VIDEO; + mp_msg(MSGT_DEMUX, MSGL_V, "\r\nADDED VIDEO PID %d, type: %x stream n. %d\r\n", es->pid, sh->format, priv->last_vid); + priv->last_vid++; + + + if(sh->format == VIDEO_AVC && es->extradata && es->extradata_len) + { + int w = 0, h = 0; + sh->bih = calloc(1, sizeof(*sh->bih) + es->extradata_len); + sh->bih->biSize= sizeof(*sh->bih) + es->extradata_len; + sh->bih->biCompression = sh->format; + memcpy(sh->bih + 1, es->extradata, es->extradata_len); + mp_msg(MSGT_DEMUXER,MSGL_DBG2, "EXTRADATA(%d BYTES): \n", es->extradata_len); + for(i = 0;i < es->extradata_len; i++) + mp_msg(MSGT_DEMUXER,MSGL_DBG2, "%02x ", (int) es->extradata[i]); + mp_msg(MSGT_DEMUXER,MSGL_DBG2,"\n"); + if(parse_avc_sps(es->extradata, es->extradata_len, &w, &h)) + { + sh->bih->biWidth = w; + sh->bih->biHeight = h; + } + } + } + } + + if(IS_SUB(es->type) && priv->last_sid+1 < MAX_S_STREAMS) + { + sh_sub_t *sh = new_sh_sub_sid_lang(demuxer, priv->last_sid, es->pid, pid_lang_from_pmt(priv, es->pid)); + if (sh) { + switch (es->type) { + case SPU_DVB: + sh->type = 'b'; break; + case SPU_DVD: + sh->type = 'v'; break; + case SPU_PGS: + sh->type = 'p'; break; + } + priv->ts.streams[es->pid].id = priv->last_sid; + priv->ts.streams[es->pid].sh = sh; + priv->ts.streams[es->pid].type = TYPE_SUB; + priv->last_sid++; + } + } +} + +static int ts_check_file(demuxer_t * demuxer) +{ + const int buf_size = (TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS); + unsigned char buf[TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS], done = 0, *ptr; + uint32_t _read, i, count = 0, is_ts; + int cc[NB_PID_MAX], last_cc[NB_PID_MAX], pid, cc_ok, c, good, bad; + uint8_t size = 0; + off_t pos = 0; + off_t init_pos; + + mp_msg(MSGT_DEMUX, MSGL_V, "Checking for MPEG-TS...\n"); + + init_pos = stream_tell(demuxer->stream); + is_ts = 0; + while(! done) + { + i = 1; + c = 0; + + while(((c=stream_read_char(demuxer->stream)) != 0x47) + && (c >= 0) + && (i < MAX_CHECK_SIZE) + && ! demuxer->stream->eof + ) i++; + + + if(c != 0x47) + { + mp_msg(MSGT_DEMUX, MSGL_V, "THIS DOESN'T LOOK LIKE AN MPEG-TS FILE!\n"); + is_ts = 0; + done = 1; + continue; + } + + pos = stream_tell(demuxer->stream) - 1; + buf[0] = c; + _read = stream_read(demuxer->stream, &buf[1], buf_size-1); + + if(_read < buf_size-1) + { + mp_msg(MSGT_DEMUX, MSGL_V, "COULDN'T READ ENOUGH DATA, EXITING TS_CHECK\n"); + stream_reset(demuxer->stream); + return 0; + } + + size = get_packet_size(buf, buf_size); + if(size) + { + done = 1; + is_ts = 1; + } + + if(pos - init_pos >= MAX_CHECK_SIZE) + { + done = 1; + is_ts = 0; + } + } + + mp_msg(MSGT_DEMUX, MSGL_V, "TRIED UP TO POSITION %"PRIu64", FOUND %x, packet_size= %d, SEEMS A TS? %d\n", (uint64_t) pos, c, size, is_ts); + stream_seek(demuxer->stream, pos); + + if(! is_ts) + return 0; + + //LET'S CHECK continuity counters + good = bad = 0; + for(count = 0; count < NB_PID_MAX; count++) + { + cc[count] = last_cc[count] = -1; + } + + for(count = 0; count < NUM_CONSECUTIVE_TS_PACKETS; count++) + { + ptr = &(buf[size * count]); + pid = ((ptr[1] & 0x1f) << 8) | ptr[2]; + mp_msg(MSGT_DEMUX, MSGL_DBG2, "BUF: %02x %02x %02x %02x, PID %d, SIZE: %d \n", + ptr[0], ptr[1], ptr[2], ptr[3], pid, size); + + if((pid == 8191) || (pid < 16)) + continue; + + cc[pid] = (ptr[3] & 0xf); + cc_ok = (last_cc[pid] < 0) || ((((last_cc[pid] + 1) & 0x0f) == cc[pid])); + mp_msg(MSGT_DEMUX, MSGL_DBG2, "PID %d, COMPARE CC %d AND LAST_CC %d\n", pid, cc[pid], last_cc[pid]); + if(! cc_ok) + //return 0; + bad++; + else + good++; + + last_cc[pid] = cc[pid]; + } + + mp_msg(MSGT_DEMUX, MSGL_V, "GOOD CC: %d, BAD CC: %d\n", good, bad); + + if(good >= bad) + return size; + else + return 0; +} + + +static inline int32_t progid_idx_in_pmt(ts_priv_t *priv, uint16_t progid) +{ + int x; + + if(priv->pmt == NULL) + return -1; + + for(x = 0; x < priv->pmt_cnt; x++) + { + if(priv->pmt[x].progid == progid) + return x; + } + + return -1; +} + + +static inline int32_t progid_for_pid(ts_priv_t *priv, int pid, int32_t req) //finds the first program listing a pid +{ + int i, j; + pmt_t *pmt; + + + if(priv->pmt == NULL) + return -1; + + + for(i=0; i < priv->pmt_cnt; i++) + { + pmt = &(priv->pmt[i]); + + if(pmt->es == NULL) + return -1; + + for(j = 0; j < pmt->es_cnt; j++) + { + if(pmt->es[j].pid == pid) + { + if((req == 0) || (req == pmt->progid)) + return pmt->progid; + } + } + + } + return -1; +} + +static inline int32_t prog_pcr_pid(ts_priv_t *priv, int progid) +{ + int i; + + if(priv->pmt == NULL) + return -1; + for(i=0; i < priv->pmt_cnt; i++) + { + if(priv->pmt[i].progid == progid) + return priv->pmt[i].PCR_PID; + } + return -1; +} + + +static inline int pid_match_lang(ts_priv_t *priv, uint16_t pid, char *lang) +{ + uint16_t i, j; + pmt_t *pmt; + + if(priv->pmt == NULL) + return -1; + + for(i=0; i < priv->pmt_cnt; i++) + { + pmt = &(priv->pmt[i]); + + if(pmt->es == NULL) + return -1; + + for(j = 0; j < pmt->es_cnt; j++) + { + if(pmt->es[j].pid != pid) + continue; + + mp_msg(MSGT_DEMUXER, MSGL_V, "CMP LANG %s AND %s, pids: %d %d\n",pmt->es[j].lang, lang, pmt->es[j].pid, pid); + if(strncmp(pmt->es[j].lang, lang, 3) == 0) + { + return 1; + } + } + + } + + return -1; +} + +typedef struct { + int32_t atype, vtype, stype; //types + int32_t apid, vpid, spid; //stream ids + char alang[4]; //languages + uint16_t prog; + off_t probe; +} tsdemux_init_t; + +//second stage: returns the count of A52 syncwords found +static int a52_check(char *buf, int len) +{ + int cnt, frame_length = 0, ok, srate; + + cnt = ok = 0; + if(len < 8) + return 0; + + while(cnt < len - 7) + { + if(buf[cnt] == 0x0B && buf[cnt+1] == 0x77) + { + frame_length = mp_a52_framesize(&buf[cnt], &srate); + if(frame_length>=7 && frame_length<=3840) + { + cnt += frame_length; + ok++; + } + else + cnt++; + } + else + cnt++; + } + + mp_msg(MSGT_DEMUXER, MSGL_V, "A52_CHECK(%d input bytes), found %d frame syncwords of %d bytes length\n", len, ok, frame_length); + return ok; +} + + +static off_t ts_detect_streams(demuxer_t *demuxer, tsdemux_init_t *param) +{ + int video_found = 0, audio_found = 0, i, num_packets = 0, req_apid, req_vpid, req_spid; + int is_audio, is_video, is_sub, has_tables; + int32_t p, chosen_pid = 0; + off_t pos=0, ret = 0, init_pos, end_pos; + ES_stream_t es; + unsigned char tmp[TS_FEC_PACKET_SIZE]; + ts_priv_t *priv = (ts_priv_t*) demuxer->priv; + struct { + char *buf; + int pos; + } pes_priv1[8192], *pptr; + char *tmpbuf; + + priv->last_pid = 8192; //invalid pid + + req_apid = param->apid; + req_vpid = param->vpid; + req_spid = param->spid; + + has_tables = 0; + memset(pes_priv1, 0, sizeof(pes_priv1)); + init_pos = stream_tell(demuxer->stream); + mp_msg(MSGT_DEMUXER, MSGL_V, "PROBING UP TO %"PRIu64", PROG: %d\n", (uint64_t) param->probe, param->prog); + end_pos = init_pos + (param->probe ? param->probe : TS_MAX_PROBE_SIZE); + while(1) + { + pos = stream_tell(demuxer->stream); + if(pos > end_pos || demuxer->stream->eof) + break; + + if(ts_parse(demuxer, &es, tmp, 1)) + { + //Non PES-aligned A52 audio may escape detection if PMT is not present; + //in this case we try to find at least 3 A52 syncwords + if((es.type == PES_PRIVATE1) && (! audio_found) && req_apid > -2) + { + pptr = &pes_priv1[es.pid]; + if(pptr->pos < 64*1024) + { + tmpbuf = realloc(pptr->buf, pptr->pos + es.size); + if(tmpbuf != NULL) + { + pptr->buf = tmpbuf; + memcpy(&(pptr->buf[ pptr->pos ]), es.start, es.size); + pptr->pos += es.size; + if(a52_check(pptr->buf, pptr->pos) > 2) + { + param->atype = AUDIO_A52; + param->apid = es.pid; + es.type = AUDIO_A52; + } + } + } + } + + 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 = IS_SUB(es.type); + + + if((! is_audio) && (! is_video) && (! is_sub)) + continue; + if(is_audio && req_apid==-2) + continue; + + if(is_video) + { + chosen_pid = (req_vpid == es.pid); + if((! chosen_pid) && (req_vpid > 0)) + continue; + } + else if(is_audio) + { + if(req_apid > 0) + { + chosen_pid = (req_apid == es.pid); + if(! chosen_pid) + continue; + } + else if(param->alang[0] > 0 && es.lang[0] > 0) + { + if(pid_match_lang(priv, es.pid, param->alang) == -1) + continue; + + chosen_pid = 1; + param->apid = req_apid = es.pid; + } + } + else if(is_sub) + { + chosen_pid = (req_spid == es.pid); + if((! chosen_pid) && (req_spid > 0)) + continue; + } + + if(req_apid < 0 && (param->alang[0] == 0) && req_vpid < 0 && req_spid < 0) + chosen_pid = 1; + + if((ret == 0) && chosen_pid) + { + ret = stream_tell(demuxer->stream); + } + + p = progid_for_pid(priv, es.pid, param->prog); + if(p != -1) + { + has_tables++; + if(!param->prog && chosen_pid) + param->prog = p; + } + + if((param->prog > 0) && (param->prog != p)) + { + if(audio_found) + { + if(is_video && (req_vpid == es.pid)) + { + param->vtype = IS_VIDEO(es.type) ? es.type : es.subtype; + param->vpid = es.pid; + video_found = 1; + break; + } + } + + if(video_found) + { + if(is_audio && (req_apid == es.pid)) + { + param->atype = IS_AUDIO(es.type) ? es.type : es.subtype; + param->apid = es.pid; + audio_found = 1; + break; + } + } + + + continue; + } + + + mp_msg(MSGT_DEMUXER, MSGL_DBG2, "TYPE: %x, PID: %d, PROG FOUND: %d\n", es.type, es.pid, param->prog); + + + if(is_video) + { + if((req_vpid == -1) || (req_vpid == es.pid)) + { + param->vtype = IS_VIDEO(es.type) ? es.type : es.subtype; + param->vpid = es.pid; + video_found = 1; + } + } + + + if(((req_vpid == -2) || (num_packets >= NUM_CONSECUTIVE_AUDIO_PACKETS)) && audio_found && !param->probe) + { + //novideo or we have at least 348 audio packets (64 KB) without video (TS with audio only) + param->vtype = 0; + break; + } + + if(is_sub) + { + if((req_spid == -1) || (req_spid == es.pid)) + { + param->stype = es.type; + param->spid = es.pid; + } + } + + if(is_audio) + { + if((req_apid == -1) || (req_apid == es.pid)) + { + param->atype = IS_AUDIO(es.type) ? es.type : es.subtype; + param->apid = es.pid; + audio_found = 1; + } + } + + if(audio_found && (param->apid == es.pid) && (! video_found)) + num_packets++; + + if((has_tables==0) && (video_found && audio_found) && (pos >= 1000000)) + break; + } + } + + for(i=0; i<8192; i++) + { + if(pes_priv1[i].buf != NULL) + { + free(pes_priv1[i].buf); + pes_priv1[i].buf = NULL; + pes_priv1[i].pos = 0; + } + } + + if(video_found) + { + if(param->vtype == VIDEO_MPEG1) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG1(pid=%d) ", param->vpid); + else if(param->vtype == VIDEO_MPEG2) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG2(pid=%d) ", param->vpid); + else if(param->vtype == VIDEO_MPEG4) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG4(pid=%d) ", param->vpid); + else if(param->vtype == VIDEO_H264) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO H264(pid=%d) ", param->vpid); + else if(param->vtype == VIDEO_VC1) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO VC1(pid=%d) ", param->vpid); + else if(param->vtype == VIDEO_AVC) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO AVC(NAL-H264, pid=%d) ", param->vpid); + } + else + { + param->vtype = UNKNOWN; + //WE DIDN'T MATCH ANY VIDEO STREAM + mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO VIDEO! "); + } + + if(param->atype == AUDIO_MP2) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO MPA(pid=%d)", param->apid); + else if(param->atype == AUDIO_A52) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO A52(pid=%d)", param->apid); + else if(param->atype == AUDIO_DTS) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO DTS(pid=%d)", param->apid); + else if(param->atype == AUDIO_LPCM_BE) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO LPCM(pid=%d)", param->apid); + else if(param->atype == AUDIO_AAC) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO AAC(pid=%d)", param->apid); + else if(param->atype == AUDIO_AAC_LATM) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO AAC LATM(pid=%d)", param->apid); + else if(param->atype == AUDIO_TRUEHD) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO TRUEHD(pid=%d)", param->apid); + else if(param->atype == AUDIO_S302M) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO S302M(pid=%d)", param->apid); + else + { + audio_found = 0; + param->atype = UNKNOWN; + //WE DIDN'T MATCH ANY AUDIO STREAM, SO WE FORCE THE DEMUXER TO IGNORE AUDIO + mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO AUDIO! (try increasing -tsprobe)"); + } + + if(IS_SUB(param->stype)) + mp_msg(MSGT_DEMUXER, MSGL_INFO, " SUB %s(pid=%d) ", (param->stype==SPU_DVD ? "DVD" : param->stype==SPU_DVB ? "DVB" : "Teletext"), param->spid); + else + { + param->stype = UNKNOWN; + mp_msg(MSGT_DEMUXER, MSGL_INFO, " NO SUBS (yet)! "); + } + + if(video_found || audio_found) + { + if(!param->prog) + { + p = progid_for_pid(priv, video_found ? param->vpid : param->apid, 0); + if(p != -1) + param->prog = p; + } + + if(demuxer->stream->eof && (ret == 0)) + ret = init_pos; + mp_msg(MSGT_DEMUXER, MSGL_INFO, " PROGRAM N. %d\n", param->prog); + } + else + mp_msg(MSGT_DEMUXER, MSGL_INFO, "\n"); + + + for(i=0; its.pids[i] != NULL) + { + priv->ts.pids[i]->payload_size = 0; + priv->ts.pids[i]->pts = priv->ts.pids[i]->last_pts = 0; + priv->ts.pids[i]->last_cc = -1; + priv->ts.pids[i]->is_synced = 0; + } + } + + return ret; +} + +static int parse_avc_sps(uint8_t *buf, int len, int *w, int *h) +{ + int sps, sps_len; + unsigned char *ptr; + mp_mpeg_header_t picture; + if(len < 6) + return 0; + sps = buf[5] & 0x1f; + if(!sps) + return 0; + sps_len = (buf[6] << 8) | buf[7]; + if(!sps_len || (sps_len > len - 8)) + return 0; + ptr = &(buf[8]); + picture.display_picture_width = picture.display_picture_height = 0; + h264_parse_sps(&picture, ptr, len - 8); + if(!picture.display_picture_width || !picture.display_picture_height) + return 0; + *w = picture.display_picture_width; + *h = picture.display_picture_height; + return 1; +} + +static demuxer_t *demux_open_ts(demuxer_t * demuxer) +{ + int i; + uint8_t packet_size; + sh_video_t *sh_video; + sh_audio_t *sh_audio; + off_t start_pos; + tsdemux_init_t params; + ts_priv_t * priv = demuxer->priv; + + mp_msg(MSGT_DEMUX, MSGL_V, "DEMUX OPEN, AUDIO_ID: %d, VIDEO_ID: %d, SUBTITLE_ID: %d,\n", + demuxer->audio->id, demuxer->video->id, demuxer->sub->id); + + + demuxer->type= DEMUXER_TYPE_MPEG_TS; + + + stream_reset(demuxer->stream); + + packet_size = ts_check_file(demuxer); + if(!packet_size) + return NULL; + + priv = calloc(1, sizeof(ts_priv_t)); + if(priv == NULL) + { + mp_msg(MSGT_DEMUX, MSGL_FATAL, "DEMUX_OPEN_TS, couldn't allocate enough memory for ts->priv, exit\n"); + return NULL; + } + + for(i=0; i < NB_PID_MAX; i++) + { + priv->ts.pids[i] = NULL; + priv->ts.streams[i].id = -3; + } + 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; + + priv->keep_broken = ts_keep_broken; + priv->ts.packet_size = packet_size; + + + demuxer->priv = priv; + if(demuxer->stream->type != STREAMTYPE_FILE) + demuxer->seekable = 1; + else + demuxer->seekable = 1; + + + params.atype = params.vtype = params.stype = UNKNOWN; + params.apid = demuxer->audio->id; + params.vpid = demuxer->video->id; + params.spid = demuxer->sub->id; + params.prog = ts_prog; + params.probe = ts_probe; + + if(demuxer->opts->audio_lang != NULL) + { + strncpy(params.alang, demuxer->opts->audio_lang[0], 3); + params.alang[3] = 0; + } + else + memset(params.alang, 0, 4); + + start_pos = ts_detect_streams(demuxer, ¶ms); + + demuxer->sub->id = params.spid; + priv->prog = params.prog; + + if(params.vtype != UNKNOWN) + { + ts_add_stream(demuxer, priv->ts.pids[params.vpid]); + sh_video = priv->ts.streams[params.vpid].sh; + demuxer->video->id = priv->ts.streams[params.vpid].id; + sh_video->ds = demuxer->video; + sh_video->format = params.vtype; + demuxer->video->sh = sh_video; + } + + if(params.atype != UNKNOWN) + { + ES_stream_t *es = priv->ts.pids[params.apid]; + + if(!IS_AUDIO(es->type) && !IS_AUDIO(es->subtype) && IS_AUDIO(params.atype)) es->subtype = params.atype; + ts_add_stream(demuxer, priv->ts.pids[params.apid]); + sh_audio = priv->ts.streams[params.apid].sh; + demuxer->audio->id = priv->ts.streams[params.apid].id; + sh_audio->ds = demuxer->audio; + sh_audio->format = params.atype; + demuxer->audio->sh = sh_audio; + } + + + mp_msg(MSGT_DEMUXER,MSGL_V, "Opened TS demuxer, audio: %x(pid %d), video: %x(pid %d)...POS=%"PRIu64", PROBE=%"PRIu64"\n", params.atype, demuxer->audio->id, params.vtype, demuxer->video->id, (uint64_t) start_pos, ts_probe); + + + start_pos = start_pos <= priv->ts.packet_size ? + demuxer->stream->start_pos : + start_pos - priv->ts.packet_size; + demuxer->movi_start = start_pos; + demuxer->reference_clock = MP_NOPTS_VALUE; + stream_reset(demuxer->stream); + stream_seek(demuxer->stream, start_pos); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES? + + + priv->last_pid = 8192; //invalid pid + + for(i = 0; i < 3; i++) + { + priv->fifo[i].pack = NULL; + priv->fifo[i].offset = 0; + } + priv->fifo[0].ds = demuxer->audio; + priv->fifo[1].ds = demuxer->video; + priv->fifo[2].ds = demuxer->sub; + + priv->fifo[0].buffer_size = 1536; + priv->fifo[1].buffer_size = 32767; + priv->fifo[2].buffer_size = 32767; + + 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; +} + +static void demux_close_ts(demuxer_t * demuxer) +{ + uint16_t i; + ts_priv_t *priv = (ts_priv_t*) demuxer->priv; + + if(priv) + { + free(priv->pat.section.buffer); + free(priv->pat.progs); + + if(priv->pmt) + { + for(i = 0; i < priv->pmt_cnt; i++) + { + free(priv->pmt[i].section.buffer); + free(priv->pmt[i].es); + } + free(priv->pmt); + } + for (i = 0; i < NB_PID_MAX; i++) + { + free(priv->ts.pids[i]); + priv->ts.pids[i] = NULL; + } + for (i = 0; i < 3; i++) + { + if (priv->fifo[i].pack) + free_demux_packet(priv->fifo[i].pack); + priv->fifo[i].pack = NULL; + } + free(priv); + } + demuxer->priv=NULL; +} + + +#define getbits mp_getbits + +static int mp4_parse_sl_packet(pmt_t *pmt, uint8_t *buf, uint16_t packet_len, int pid, ES_stream_t *pes_es) +{ + int i, n, m, mp4_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, rap_flag = 0, ocr_flag = 0, padding = 0, padding_bits = 0, idle = 0; + + pes_es->is_synced = 0; + mp_msg(MSGT_DEMUXER,MSGL_V, "mp4_parse_sl_packet, pid: %d, pmt: %pm, packet_len: %d\n", pid, pmt, packet_len); + if(! pmt || !packet_len) + return 0; + + for(i = 0; i < pmt->es_cnt; i++) + { + if(pmt->es[i].pid == pid) + mp4_es_id = pmt->es[i].mp4_es_id; + } + if(mp4_es_id < 0) + return -1; + + for(i = 0; i < pmt->mp4es_cnt; i++) + { + if(pmt->mp4es[i].id == mp4_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, subtype: %x\n", es->id, sl->flags, pes_es->subtype); + + 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++, 1); + 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; + + if(sl->random_accesspoint) + rap_flag = getbits(buf, n++, 1); + + //check commented because it seems it's rarely used, and we need this flag set in case of au_start + //the decoder will eventually discard the payload if it can't decode it + //if(rap_flag || sl->random_accesspoint_only) + pes_es->is_synced = 1; + + n += sl->au_seqnum_len; + if(packet_len * 8 <= n+8) + return -1; + if(sl->use_ts) + { + dts_flag = getbits(buf, n++, 1); + cts_flag = getbits(buf, n++, 1); + } + if(sl->instant_bitrate_len) + ib_flag = getbits(buf, n++, 1); + 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 = FFMIN(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 = (double) v / (double) sl->ts_resolution; + mp_msg(MSGT_DEMUXER,MSGL_DBG2, "CTS: %d bits, value: %"PRIu64"/%d = %.3f\n", sl->ts_len, v, sl->ts_resolution, pes_es->pts); + } + + + i = 0; + pl_size = 0; + while(i < sl->au_len) + { + m = FFMIN(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; + if(0 < pl_size && pl_size < pes_es->payload_size) + pes_es->payload_size = pl_size; + + mp_msg(MSGT_DEMUXER,MSGL_V, "mp4_parse_sl_packet, n=%d, m=%d, size from pes hdr: %u, sl hdr size: %u, RAP FLAGS: %d/%d\n", + n, m, pes_es->payload_size, pl_size, (int) rap_flag, (int) sl->random_accesspoint_only); + + return m; +} + +//this function parses the extension fields in the PES header and returns the substream_id, or -1 in case of errors +static int parse_pes_extension_fields(unsigned char *p, int pkt_len) +{ + int skip; + unsigned char flags; + + if(!(p[7] & 0x1)) //no extension_field + return -1; + skip = 9; + if(p[7] & 0x80) + { + skip += 5; + if(p[7] & 0x40) + skip += 5; + } + if(p[7] & 0x20) //escr_flag + skip += 6; + if(p[7] & 0x10) //es_rate_flag + skip += 3; + if(p[7] & 0x08)//dsm_trick_mode is unsupported, skip + { + skip = 0;//don't let's parse the extension fields + } + if(p[7] & 0x04) //additional_copy_info + skip += 1; + if(p[7] & 0x02) //pes_crc_flag + skip += 2; + if(skip >= pkt_len) //too few bytes + return -1; + flags = p[skip]; + skip++; + if(flags & 0x80) //pes_private_data_flag + skip += 16; + if(skip >= pkt_len) + return -1; + if(flags & 0x40) //pack_header_field_flag + { + unsigned char l = p[skip]; + skip += l; + } + if(flags & 0x20) //program_packet_sequence_counter + skip += 2; + if(flags & 0x10) //p_std + skip += 2; + if(skip >= pkt_len) + return -1; + if(flags & 0x01) //finally the long desired pes_extension2 + { + unsigned char l = p[skip]; //ext2 flag+len + skip++; + if((l == 0x81) && (skip < pkt_len)) + { + int ssid = p[skip]; + mp_msg(MSGT_IDENTIFY, MSGL_V, "SUBSTREAM_ID=%d (0x%02X)\n", ssid, ssid); + return ssid; + } + } + + return -1; +} + +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; + int64_t pts; + uint32_t stream_id; + uint32_t pkt_len, pes_is_aligned; + + //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 || packet_len > 184) + { + 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; + + + mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: HEADER %02x %02x %02x %02x\n", p[0], p[1], p[2], p[3]); + if (p[0] || p[1] || (p[2] != 1)) + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: error HEADER %02x %02x %02x (should be 0x000001) \n", p[0], p[1], p[2]); + return 0 ; + } + + packet_len -= 6; + if(packet_len==0) + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: packet too short: %d, exit\n", packet_len); + return 0; + } + + es->payload_size = (p[4] << 8 | p[5]); + pes_is_aligned = (p[6] & 4); + + stream_id = p[3]; + + + if (p[7] & 0x80) + { /* pts available */ + pts = (int64_t)(p[9] & 0x0E) << 29 ; + pts |= p[10] << 22 ; + pts |= (p[11] & 0xFE) << 14 ; + pts |= p[12] << 7 ; + pts |= (p[13] & 0xFE) >> 1 ; + + es->pts = pts / 90000.0; + } + else + es->pts = 0.0; + + + header_len = p[8]; + + + if (header_len + 9 > pkt_len) //9 are the bytes read up to the header_length field + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "demux_ts: illegal value for PES_header_data_length (0x%02x)\n", header_len); + return 0; + } + + if(stream_id==0xfd) + { + int ssid = parse_pes_extension_fields(p, pkt_len); + if((audio_substream_id!=-1) && (ssid != audio_substream_id)) + return 0; + if(ssid == 0x72 && type_from_pmt != AUDIO_DTS && type_from_pmt != SPU_PGS) + es->type = type_from_pmt = AUDIO_TRUEHD; + } + + p += header_len + 9; + packet_len -= header_len + 3; + + if(es->payload_size) + es->payload_size -= header_len + 3; + + + es->is_synced = 1; //only for SL streams we have to make sure it's really true, see below + if (stream_id == 0xbd) + { + mp_msg(MSGT_DEMUX, MSGL_DBG3, "pes_parse2: audio buf = %02X %02X %02X %02X %02X %02X %02X %02X, 80: %d\n", + p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[0] & 0x80); + + + /* + * we check the descriptor tag first because some stations + * do not include any of the A52 header info in their audio tracks + * these "raw" streams may begin with a byte that looks like a stream type. + */ + + + if(type_from_pmt == SPU_PGS) + { + es->start = p; + es->size = packet_len; + es->type = SPU_PGS; + es->payload_size -= packet_len; + return 1; + } + if( + (type_from_pmt == AUDIO_A52) || /* A52 - raw */ + (packet_len >= 2 && p[0] == 0x0B && p[1] == 0x77) /* A52 - syncword */ + ) + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 RAW OR SYNCWORD\n"); + es->start = p; + es->size = packet_len; + es->type = AUDIO_A52; + es->payload_size -= packet_len; + + return 1; + } + /* SPU SUBS */ + else if(type_from_pmt == SPU_DVB || + (packet_len >= 2 && (p[0] == 0x20) && pes_is_aligned)) // && p[1] == 0x00)) + { + // offset/length fiddling to make decoding with lavc possible + es->start = p + 2; + es->size = packet_len - 2; + es->type = SPU_DVB; + es->payload_size -= packet_len; + + return 1; + } + else if (pes_is_aligned && packet_len >= 1 && ((p[0] & 0xE0) == 0x20)) //SPU_DVD + { + //DVD SUBS + es->start = p+1; + es->size = packet_len-1; + es->type = SPU_DVD; + es->payload_size -= packet_len; + + return 1; + } + else if (pes_is_aligned && packet_len >= 4 && (p[0] & 0xF8) == 0x80) + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 WITH HEADER\n"); + es->start = p+4; + es->size = packet_len - 4; + es->type = AUDIO_A52; + es->payload_size -= packet_len; + + return 1; + } + else if (pes_is_aligned && packet_len >= 1 && ((p[0]&0xf0) == 0xa0)) + { + int pcm_offset; + + for (pcm_offset=0; ++pcm_offset < packet_len-1 ; ) + { + if (p[pcm_offset] == 0x01 && p[pcm_offset+1] == 0x80) + { /* START */ + pcm_offset += 2; + break; + } + } + + es->start = p + pcm_offset; + es->size = packet_len - pcm_offset; + es->type = AUDIO_LPCM_BE; + es->payload_size -= packet_len; + + return 1; + } + else + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "PES_PRIVATE1\n"); + es->start = p; + es->size = packet_len; + es->type = (type_from_pmt == UNKNOWN ? PES_PRIVATE1 : type_from_pmt); + es->payload_size -= packet_len; + + return 1; + } + } + else if((stream_id >= 0xe0 && stream_id <= 0xef) || (stream_id == 0xfd && type_from_pmt != UNKNOWN)) + { + es->start = p; + es->size = packet_len; + if(type_from_pmt != UNKNOWN) + es->type = type_from_pmt; + else + es->type = VIDEO_MPEG2; + if(es->payload_size) + es->payload_size -= packet_len; + + mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: M2V size %d\n", es->size); + return 1; + } + else if (stream_id == 0xfa) + { + int l; + + es->is_synced = 0; + if(type_from_pmt != UNKNOWN) //MP4 A/V or SL + { + es->start = p; + es->size = packet_len; + es->type = type_from_pmt; + + if(type_from_pmt == SL_PES_STREAM) + { + //if(pes_is_aligned) + //{ + l = mp4_parse_sl_packet(pmt, p, packet_len, pid, 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; + } + + if(es->payload_size) + es->payload_size -= packet_len; + return 1; + } + } + else if ((stream_id & 0xe0) == 0xc0) + { + es->start = p; + es->size = packet_len; + + if(type_from_pmt != UNKNOWN) + es->type = type_from_pmt; + else + es->type = AUDIO_MP2; + + es->payload_size -= packet_len; + + return 1; + } + else if (type_from_pmt != -1) //as a last resort here we trust the PMT, if present + { + es->start = p; + es->size = packet_len; + es->type = type_from_pmt; + es->payload_size -= packet_len; + + return 1; + } + else + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: unknown packet, id: %x\n", stream_id); + } + + es->is_synced = 0; + return 0; +} + + + + +static int ts_sync(stream_t *stream) +{ + mp_msg(MSGT_DEMUX, MSGL_DBG3, "TS_SYNC \n"); + + while (!stream->eof) + if (stream_read_char(stream) == 0x47) + return 1; + + return 0; +} + + +static void ts_dump_streams(ts_priv_t *priv) +{ + int i; + + for(i = 0; i < 3; i++) + { + if((priv->fifo[i].pack != NULL) && (priv->fifo[i].offset != 0)) + { + resize_demux_packet(priv->fifo[i].pack, priv->fifo[i].offset); + ds_add_packet(priv->fifo[i].ds, priv->fifo[i].pack); + priv->fifo[i].offset = 0; + priv->fifo[i].pack = NULL; + } + } +} + + +static inline int32_t prog_idx_in_pat(ts_priv_t *priv, uint16_t progid) +{ + int x; + + if(priv->pat.progs == NULL) + return -1; + + for(x = 0; x < priv->pat.progs_cnt; x++) + { + if(priv->pat.progs[x].id == progid) + return x; + } + + return -1; +} + + +static inline int32_t prog_id_in_pat(ts_priv_t *priv, uint16_t pid) +{ + int x; + + if(priv->pat.progs == NULL) + return -1; + + for(x = 0; x < priv->pat.progs_cnt; x++) + { + if(priv->pat.progs[x].pmt_pid == pid) + return priv->pat.progs[x].id; + } + + return -1; +} + +static int collect_section(ts_section_t *section, int is_start, unsigned char *buff, int size) +{ + uint8_t *ptr; + uint16_t tlen; + int skip, tid; + + mp_msg(MSGT_DEMUX, MSGL_V, "COLLECT_SECTION, start: %d, size: %d, collected: %d\n", is_start, size, section->buffer_len); + if(! is_start && !section->buffer_len) + return 0; + + if(is_start) + { + if(! section->buffer) + { + section->buffer = malloc(4096 + 256); + if(section->buffer == NULL) + return 0; + } + section->buffer_len = 0; + } + + if(size + section->buffer_len > 4096+256) + { + mp_msg(MSGT_DEMUX, MSGL_V, "COLLECT_SECTION, excessive len: %d + %d\n", section->buffer_len, size); + return 0; + } + + 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, COLLECTED: %d\n", skip, tid, tlen, section->buffer_len); + 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; +} + +static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int size) +{ + int 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 + 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]; + priv->pat.version_number = (ptr[5] >> 1) & 0x1F; + priv->pat.section_length = ((ptr[1] & 0x03) << 8 ) | ptr[2]; + priv->pat.section_number = ptr[6]; + priv->pat.last_section_number = ptr[7]; + + //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; + base = &ptr[8 + i*4]; + progid = (base[0] << 8) | base[1]; + + if((idx = prog_idx_in_pat(priv, progid)) == -1) + { + int sz = sizeof(struct pat_progs_t) * (priv->pat.progs_cnt+1); + tmp = realloc_struct(priv->pat.progs, priv->pat.progs_cnt+1, sizeof(struct pat_progs_t)); + if(tmp == NULL) + { + mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PAT: COULDN'T REALLOC %d bytes, NEXT\n", sz); + break; + } + priv->pat.progs = tmp; + idx = priv->pat.progs_cnt; + priv->pat.progs_cnt++; + } + + priv->pat.progs[idx].id = progid; + priv->pat.progs[idx].pmt_pid = ((base[2] & 0x1F) << 8) | base[3]; + mp_msg(MSGT_DEMUX, MSGL_V, "PROG: %d (%d-th of %d), PMT: %d\n", priv->pat.progs[idx].id, i+1, entries, priv->pat.progs[idx].pmt_pid); + mp_msg(MSGT_IDENTIFY, MSGL_V, "PROGRAM_ID=%d (0x%02X), PMT_PID: %d(0x%02X)\n", + progid, progid, priv->pat.progs[idx].pmt_pid, priv->pat.progs[idx].pmt_pid); + } + + return 1; +} + + +static inline int32_t es_pid_in_pmt(pmt_t * pmt, uint16_t pid) +{ + uint16_t i; + + if(pmt == NULL) + return -1; + + if(pmt->es == NULL) + return -1; + + for(i = 0; i < pmt->es_cnt; i++) + { + if(pmt->es[i].pid == pid) + return (int32_t) i; + } + + return -1; +} + + +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 = FFMIN(*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(uint8_t *buf, int len, void *elem) +{ + int i = 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; + 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; + sl->ts_resolution = 1000; + 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(len=0x%x), predef: %d, flags: %x, use_ts: %d, tslen: %d, timescale: %d, dts: %"PRIu64", cts: %"PRIu64"\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, j; + 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_AVC; + /*else if(dec->object_type == 0x22) + fprintf(stderr, "TYPE 0x22\n");*/ + 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 = UNKNOWN; + } + else + dec->object_type = dec->stream_type = UNKNOWN; + + if(dec->object_type != UNKNOWN) + { + //update the type of the current stream + for(j = 0; j < pmt->es_cnt; j++) + { + if(pmt->es[j].mp4_es_id == es->id) + { + pmt->es[j].type = SL_PES_STREAM; + } + } + } + + if(len > 13) + parse_mp4_descriptors(pmt, &buf[13], len-13, dec); + + 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_decoder_specific_descriptor(uint8_t *buf, int len, void *elem) +{ + int i; + mp4_decoder_config_t *dec; + + mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4_DECODER_SPECIFIC_DESCRIPTOR(%d)\n", len); + dec = (mp4_decoder_config_t *) elem; + if(!dec) + { + mp_msg(MSGT_DEMUX, MSGL_V, "argh! NULL elem passed, skip\n"); + return len; + } + + mp_msg(MSGT_DEMUX, MSGL_DBG2, "MP4 SPECIFIC INFO BYTES: \n"); + for(i=0; i MAX_EXTRADATA_SIZE) + { + mp_msg(MSGT_DEMUX, MSGL_ERR, "DEMUX_TS, EXTRADATA SUSPICIOUSLY BIG: %d, REFUSED\r\n", len); + return len; + } + memcpy(dec->buf, buf, len); + dec->buf_size = len; + + return len; +} + +static uint16_t parse_mp4_es_descriptor(pmt_t *pmt, uint8_t *buf, int len) +{ + int i = 0, j = 0, k, found; + uint8_t flag; + mp4_es_descr_t es, *target_es = NULL, *tmp; + + mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_MP4ES: len=%d\n", len); + memset(&es, 0, sizeof(mp4_es_descr_t)); + 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 = realloc_struct(pmt->mp4es, pmt->mp4es_cnt+1, sizeof(mp4_es_descr_t)); + 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 void parse_mp4_object_descriptor(pmt_t *pmt, uint8_t *buf, int len, void *elem) +{ + int i, j = 0, id; + + i=0; + 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 void 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); + break; + case 0x4: + parse_mp4_decoder_config_descriptor(pmt, &buf[i], descr_len, elem); + break; + case 0x05: + parse_mp4_decoder_specific_descriptor(&buf[i], descr_len, elem); + break; + case 0x6: + parse_mp4_slconfig_descriptor(&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 = calloc(sizeof(*tss), 1); + if(! tss) + return NULL; + tss->pid = pid; + tss->last_cc = -1; + tss->type = UNKNOWN; + tss->subtype = UNKNOWN; + tss->is_synced = 0; + tss->extradata = NULL; + tss->extradata_alloc = tss->extradata_len = 0; + 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; + + j = 0; + len = es->descr_length; + while(len > 2) + { + descr_len = ptr[j+1]; + 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_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 || ptr[j] == 0x7a) //A52 Descriptor + { + if(es->type == 0x6) + { + es->type = AUDIO_A52; + mp_msg(MSGT_DEMUX, MSGL_DBG2, "DVB A52 Descriptor\n"); + } + } + else if(ptr[j] == 0x7b) //DVB DTS Descriptor + { + if(es->type == 0x6) + { + es->type = AUDIO_DTS; + mp_msg(MSGT_DEMUX, MSGL_DBG2, "DVB DTS Descriptor\n"); + } + } + else if(ptr[j] == 0x56) // Teletext + { + if(descr_len >= 5) { + memcpy(es->lang, ptr+2, 3); + es->lang[3] = 0; + } + es->type = SPU_TELETEXT; + } + else if(ptr[j] == 0x59) //Subtitling Descriptor + { + uint8_t subtype; + + mp_msg(MSGT_DEMUX, MSGL_DBG2, "Subtitling Descriptor\n"); + if(descr_len < 8) + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "Descriptor length too short for DVB Subtitle Descriptor: %d, SKIPPING\n", descr_len); + } + else + { + memcpy(es->lang, &ptr[j+2], 3); + es->lang[3] = 0; + subtype = ptr[j+5]; + if( + (subtype >= 0x10 && subtype <= 0x13) || + (subtype >= 0x20 && subtype <= 0x23) + ) + { + es->type = SPU_DVB; + //page parameters: compo page 2 bytes, ancillary page 2 bytes + } + else + es->type = UNKNOWN; + } + } + else if(ptr[j] == 0x50) //Component Descriptor + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "Component Descriptor\n"); + memcpy(es->lang, &ptr[j+5], 3); + es->lang[3] = 0; + } + else if(ptr[j] == 0xa) //Language Descriptor + { + memcpy(es->lang, &ptr[j+2], 3); + es->lang[3] = 0; + mp_msg(MSGT_DEMUX, MSGL_V, "Language Descriptor: %s\n", es->lang); + } + else if(ptr[j] == 0x5) //Registration Descriptor (looks like e fourCC :) ) + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "Registration Descriptor\n"); + if(descr_len < 4) + { + mp_msg(MSGT_DEMUX, MSGL_DBG2, "Registration Descriptor length too short: %d, SKIPPING\n", descr_len); + } + else + { + char *d; + memcpy(es->format_descriptor, &ptr[j+2], 4); + es->format_descriptor[4] = 0; + + d = &ptr[j+2]; + if(d[0] == 'A' && d[1] == 'C' && d[2] == '-' && d[3] == '3') + { + es->type = AUDIO_A52; + } + else if(d[0] == 'D' && d[1] == 'T' && d[2] == 'S' && d[3] == '1') + { + es->type = AUDIO_DTS; + } + else if(d[0] == 'D' && d[1] == 'T' && d[2] == 'S' && d[3] == '2') + { + es->type = AUDIO_DTS; + } + else if(d[0] == 'V' && d[1] == 'C' && d[2] == '-' && d[3] == '1') + { + es->type = VIDEO_VC1; + } + else if(d[0] == 'd' && d[1] == 'r' && d[2] == 'a' && d[3] == 'c') + { + es->type = VIDEO_DIRAC; + } + else if(d[0] == 'B' && d[1] == 'S' && d[2] == 'S' && d[3] == 'D') + { + es->type = AUDIO_S302M; + } + else + es->type = UNKNOWN; + mp_msg(MSGT_DEMUX, MSGL_DBG2, "FORMAT %s\n", es->format_descriptor); + } + } + else if(ptr[j] == 0x1e || ptr[j] == 0x1f) + { + // 0x1f is FMC, but currently it is easiest to handle them the same way + 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]); + + len -= 2 + descr_len; + j += 2 + descr_len; + } + + return 1; +} + +static int parse_sl_section(pmt_t *pmt, ts_section_t *section, 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) +{ + unsigned char *base, *es_base; + pmt_t *pmt; + int32_t idx, es_count, section_bytes; + uint8_t m=0; + int skip; + pmt_t *tmp; + struct pmt_es_t *tmp_es; + ts_section_t *section; + ES_stream_t *tss; + int i; + + idx = progid_idx_in_pmt(priv, progid); + + if(idx == -1) + { + int sz = (priv->pmt_cnt + 1) * sizeof(pmt_t); + tmp = realloc_struct(priv->pmt, priv->pmt_cnt + 1, sizeof(pmt_t)); + if(tmp == NULL) + { + mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT: COULDN'T REALLOC %d bytes, NEXT\n", sz); + return 0; + } + priv->pmt = tmp; + idx = priv->pmt_cnt; + memset(&(priv->pmt[idx]), 0, sizeof(pmt_t)); + priv->pmt_cnt++; + priv->pmt[idx].progid = progid; + } + + pmt = &(priv->pmt[idx]); + + section = &(pmt->section); + skip = collect_section(section, is_start, buff, size); + if(! skip) + return 0; + + base = &(section->buffer[skip]); + + 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->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; + pmt->curr_next = (base[5] & 1); + pmt->section_number = base[6]; + 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->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 + + section_bytes= pmt->section_length - 13 - pmt->prog_descr_length; + es_count = 0; + + while(section_bytes >= 5) + { + int es_pid, es_type; + + es_type = es_base[0]; + es_pid = ((es_base[1] & 0x1f) << 8) | es_base[2]; + + idx = es_pid_in_pmt(pmt, es_pid); + if(idx == -1) + { + int sz = sizeof(struct pmt_es_t) * (pmt->es_cnt + 1); + tmp_es = realloc_struct(pmt->es, pmt->es_cnt + 1, sizeof(struct pmt_es_t)); + if(tmp_es == NULL) + { + mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT, COULDN'T ALLOCATE %d bytes for PMT_ES\n", sz); + continue; + } + pmt->es = tmp_es; + idx = pmt->es_cnt; + memset(&(pmt->es[idx]), 0, sizeof(struct pmt_es_t)); + pmt->es_cnt++; + } + + pmt->es[idx].descr_length = ((es_base[3] & 0xf) << 8) | es_base[4]; + + + if(pmt->es[idx].descr_length > section_bytes - 5) + { + mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, ES_DESCR_LENGTH TOO LARGE %d > %d, EXIT\n", + pmt->es[idx].descr_length, section_bytes - 5); + return -1; + } + + + pmt->es[idx].pid = es_pid; + 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) + { + case 1: + pmt->es[idx].type = VIDEO_MPEG1; + break; + case 2: + pmt->es[idx].type = VIDEO_MPEG2; + break; + case 3: + case 4: + pmt->es[idx].type = AUDIO_MP2; + break; + case 6: + if(pmt->es[idx].type == 0x6) //this could have been ovrwritten by parse_descriptors + pmt->es[idx].type = UNKNOWN; + break; + case 0x10: + pmt->es[idx].type = VIDEO_MPEG4; + break; + case 0x0f: + pmt->es[idx].type = AUDIO_AAC; + break; + case 0x11: + pmt->es[idx