From b95debe5edbced87ee36bd2f72a6085e382a2f17 Mon Sep 17 00:00:00 2001 From: attila Date: Mon, 20 Oct 2003 13:35:55 +0000 Subject: [PATCH] big demux_ts fix from Nico git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@11191 b3059339-0415-0410-9bf9-f77b7e298cf2 --- cfg-common.h | 11 +- libmpdemux/demux_ts.c | 1039 ++++++++++++++++++++++++++++------------- 2 files changed, 727 insertions(+), 323 deletions(-) diff --git a/cfg-common.h b/cfg-common.h index 5e64467869..c48f86d9ed 100644 --- a/cfg-common.h +++ b/cfg-common.h @@ -76,9 +76,9 @@ {"forceidx", &index_mode, CONF_TYPE_FLAG, 0, -1, 2, NULL}, // select audio/videosubtitle stream - {"aid", &audio_id, CONF_TYPE_INT, CONF_RANGE, 0, 8192, NULL}, - {"vid", &video_id, CONF_TYPE_INT, CONF_RANGE, 0, 8192, NULL}, - {"sid", &dvdsub_id, CONF_TYPE_INT, CONF_RANGE, 0, 31, NULL}, + {"aid", &audio_id, CONF_TYPE_INT, CONF_RANGE, 0, 8190, NULL}, + {"vid", &video_id, CONF_TYPE_INT, CONF_RANGE, 0, 8190, NULL}, + {"sid", &dvdsub_id, CONF_TYPE_INT, CONF_RANGE, 0, 8190, NULL}, {"novideo", &video_id, CONF_TYPE_FLAG, 0, -1, -2, NULL}, { "hr-mp3-seek", &hr_mp3_seek, CONF_TYPE_FLAG, 0, 0, 1, NULL }, @@ -184,6 +184,9 @@ {"tsfastparse", "-tsfastparse isn't a valid option anymore.\n", CONF_TYPE_PRINT, CONF_NOCFG ,0,0, NULL }, {"tsprog", &ts_prog, CONF_TYPE_INT, CONF_RANGE, 0, 65534, NULL}, +#define TS_MAX_PROBE_SIZE 2000000 /* dont forget to change this in libmpdemux/demux_ts.c too */ + {"tsprobe", &ts_probe, CONF_TYPE_POSITION, 0, 0, TS_MAX_PROBE_SIZE, NULL}, + {"tskeepbroken", &ts_keep_broken, CONF_TYPE_FLAG, 0, 0, 1, NULL}, // draw by slices or whole frame (useful with libmpeg2/libavcodec) {"slices", &vd_use_slices, CONF_TYPE_FLAG, 0, 0, 1, NULL}, @@ -286,6 +289,8 @@ extern char* audio_stream; extern char* sub_stream; extern int demuxer_type, audio_demuxer_type, sub_demuxer_type; extern int ts_prog; +extern int ts_keep_broken; +extern off_t ts_probe; #include "libmpdemux/tv.h" diff --git a/libmpdemux/demux_ts.c b/libmpdemux/demux_ts.c index eb46833e03..954326f1ce 100644 --- a/libmpdemux/demux_ts.c +++ b/libmpdemux/demux_ts.c @@ -34,6 +34,7 @@ #include "stheader.h" #include "bswap.h" +#include "../unrarlib.h" #define TS_FEC_PACKET_SIZE 204 @@ -42,12 +43,15 @@ #define MAX_HEADER_SIZE 6 /* enough for PES header + length */ #define MAX_CHECK_SIZE 65535 -#define MAX_PROBE_SIZE 2000000 +#define TS_MAX_PROBE_SIZE 2000000 /* dont forget to change this in cfg-common.h too */ #define NUM_CONSECUTIVE_TS_PACKETS 32 #define NUM_CONSECUTIVE_AUDIO_PACKETS 348 int ts_prog; +int ts_keep_broken=0; +off_t ts_probe = TS_MAX_PROBE_SIZE; +extern char *dvdsub_lang, *audio_lang; //for -alang typedef enum { @@ -58,11 +62,9 @@ typedef enum AUDIO_MP2 = 0x50, AUDIO_A52 = 0x2000, AUDIO_LPCM_BE = 0x10001, - AUDIO_AAC = (('A' << 24) | ('4' << 16) | ('P' << 8) | 'M') - /*, + AUDIO_AAC = mmioFOURCC('M', 'P', '4', 'A'), SPU_DVD = 0x3000000, - SPU_DVB = 0x3000001, - */ + SPU_DVB = 0x3000001 } es_stream_type_t; @@ -73,7 +75,9 @@ typedef struct { es_stream_type_t type; float pts, last_pts; int pid; + char lang[4]; int last_cc; // last cc code (-1 if first packet) + uint64_t seen; } ES_stream_t; @@ -106,8 +110,8 @@ typedef struct { } *progs; uint16_t progs_cnt; char buffer[65535]; - uint8_t buffer_len; - } pat_t; + uint16_t buffer_len; +} pat_t; typedef struct { uint16_t progid; @@ -122,27 +126,26 @@ typedef struct { uint16_t PCR_PID; uint16_t prog_descr_length; char buffer[2048]; - uint8_t buffer_len; + uint16_t buffer_len; 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]; } *es; } pmt_t; typedef struct { MpegTSContext ts; - int is_synced; //synced to the beginning of priv->last_pid PES header - int last_afc; //bytes read from the last adaption field int last_pid; - int is_start; - int eof; - av_fifo_t fifo[2]; //0 for audio, 1 for video + 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; + int keep_broken; } ts_priv_t; @@ -185,9 +188,11 @@ int ts_check_file(demuxer_t * demuxer) 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) { @@ -227,14 +232,14 @@ int ts_check_file(demuxer_t * demuxer) is_ts = 1; } - if(pos >= MAX_CHECK_SIZE) + if(pos - init_pos >= MAX_CHECK_SIZE) { done = 1; is_ts = 0; } } - mp_msg(MSGT_DEMUX, MSGL_V, "TRIED UP TO POSITION %u, FOUND %x, packet_size= %d\n", pos, c, size); + mp_msg(MSGT_DEMUX, MSGL_V, "TRIED UP TO POSITION %llu, 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) @@ -326,36 +331,76 @@ static inline int32_t progid_for_pid(ts_priv_t *priv, int pid, int32_t req) //f } -static void ts_detect_streams(demuxer_t *demuxer, uint32_t *a, uint32_t *v, int *fapid, int *fvpid, int32_t *prog) +static inline int pid_match_lang(ts_priv_t *priv, uint16_t pid, char *lang) { - int video_found = 0, audio_found = 0, i, num_packets = 0, req_apid, req_vpid; - int is_audio, is_video, has_tables; - int32_t p, chosen_pid; - off_t pos=0; + 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 slang[4], alang[4]; //languages + int16_t prog; + off_t probe; +} tsdemux_init_t; + +static off_t ts_detect_streams(demuxer_t *demuxer, tsdemux_init_t *param) +{ + int video_found = 0, audio_found = 0, sub_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; ES_stream_t es; unsigned char tmp[TS_FEC_PACKET_SIZE]; ts_priv_t *priv = (ts_priv_t*) demuxer->priv; - priv->is_synced = 0; - priv->last_afc = 0; priv->last_pid = 8192; //invalid pid - priv->is_start = 0; - priv->eof = 0; - req_apid = *fapid; - req_vpid = *fvpid; + req_apid = param->apid; + req_vpid = param->vpid; + req_spid = param->spid; has_tables = 0; - mp_msg(MSGT_DEMUXER, MSGL_INFO, "PROBING UP TO %u, PROG: %d\n", MAX_PROBE_SIZE, *prog); - while(pos <= MAX_PROBE_SIZE) + init_pos = stream_tell(demuxer->stream); + mp_msg(MSGT_DEMUXER, MSGL_INFO, "PROBING UP TO %llu, PROG: %d\n", (uint64_t) param->probe, param->prog); + while((pos <= init_pos + param->probe) && (! demuxer->stream->eof)) { pos = stream_tell(demuxer->stream); if(ts_parse(demuxer, &es, tmp, 1)) { 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)); + is_sub = ((es.type == SPU_DVD) || (es.type == SPU_DVB)); - if((! is_audio) && (! is_video)) + + if((! is_audio) && (! is_video) && (! is_sub)) continue; if(is_video) @@ -366,32 +411,54 @@ static void ts_detect_streams(demuxer_t *demuxer, uint32_t *a, uint32_t *v, int } else if(is_audio) { - chosen_pid = (req_apid == es.pid); - if((! chosen_pid) && (req_apid > 0)) + if(req_apid > 0) + { + chosen_pid = (req_apid == es.pid); + if(! chosen_pid) + continue; + } + else if(param->alang[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_vpid < 0 && req_apid < 0) + if(req_apid < 0 && (param->alang[0] == 0) && req_vpid < 0 && req_spid < 0) chosen_pid = 1; - p = progid_for_pid(priv, es.pid, *prog); + 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((*prog == 0) && (p != -1)) + if((param->prog == 0) && (p != -1)) { if(chosen_pid) - *prog = p; + param->prog = p; } - if((*prog > 0) && (*prog != p)) + if((param->prog > 0) && (param->prog != p)) { if(audio_found) { if(is_video && (req_vpid == es.pid)) { - *v = es.type; - *fvpid = es.pid; + param->vtype = es.type; + param->vpid = es.pid; video_found = 1; break; } @@ -401,8 +468,8 @@ static void ts_detect_streams(demuxer_t *demuxer, uint32_t *a, uint32_t *v, int { if(is_audio && (req_apid == es.pid)) { - *a = es.type; - *fapid = es.pid; + param->atype = es.type; + param->apid = es.pid; audio_found = 1; break; } @@ -413,15 +480,15 @@ static void ts_detect_streams(demuxer_t *demuxer, uint32_t *a, uint32_t *v, int } - mp_msg(MSGT_DEMUXER, MSGL_DBG2, "TYPE: %x, PID: %d, PROG FOUND: %d\n", es.type, es.pid, *prog); + 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)) { - *v = es.type; - *fvpid = es.pid; + param->vtype = es.type; + param->vpid = es.pid; video_found = 1; } } @@ -430,27 +497,36 @@ static void ts_detect_streams(demuxer_t *demuxer, uint32_t *a, uint32_t *v, int if(((req_vpid == -2) || (num_packets >= NUM_CONSECUTIVE_AUDIO_PACKETS)) && audio_found) { //novideo or we have at least 348 audio packets (64 KB) without video (TS with audio only) - *v = 0; + param->vtype = 0; break; } + if(is_sub) + { + if((req_spid == -1) || (req_spid == es.pid)) + { + param->stype = es.type; + param->spid = es.pid; + sub_found = 1; + } + } if(is_audio) { if((req_apid == -1) || (req_apid == es.pid)) { - *a = es.type; - *fapid = es.pid; + param->atype = es.type; + param->apid = es.pid; audio_found = 1; } } - if(audio_found && (*fapid == es.pid) && (! video_found)) + if(audio_found && (param->apid == es.pid) && (! video_found)) num_packets++; if((req_apid == -2) && video_found) { - *a = 0; + param->atype = 0; break; } @@ -460,28 +536,48 @@ static void ts_detect_streams(demuxer_t *demuxer, uint32_t *a, uint32_t *v, int } if(video_found) - mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG%d(pid=%d)...", (*v == VIDEO_MPEG1 ? 1 : (*v == VIDEO_MPEG2 ? 2 : 4)), *fvpid); + mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG%d(pid=%d)...", (param->vtype == VIDEO_MPEG1 ? 1 : (param->vtype == VIDEO_MPEG2 ? 2 : 4)), param->vpid); else { - //WE DIDN'T MATCH ANY VIDEO STREAM - mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO VIDEO! "); + video_found = 0; + param->vtype = UNKNOWN; + //WE DIDN'T MATCH ANY VIDEO STREAM + mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO VIDEO! "); } - if(*a == AUDIO_MP2) - mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO MP2(pid=%d)", *fapid); - else if(*a == AUDIO_A52) - mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO A52(pid=%d)", *fapid); - else if(*a == AUDIO_LPCM_BE) - mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO LPCM(pid=%d)", *fapid); - else if(*a == AUDIO_AAC) - mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO AAC(pid=%d)", *fapid); + if(param->atype == AUDIO_MP2) + mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO MP2(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_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 { + 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! "); } - mp_msg(MSGT_DEMUXER, MSGL_INFO, " PROGRAM N. %d\n", *prog); + if(param->stype == SPU_DVD || param->stype == SPU_DVB) + mp_msg(MSGT_DEMUXER, MSGL_INFO, " SUB DVx(pid=%d) ", param->spid); + else + { + param->stype = UNKNOWN; + mp_msg(MSGT_DEMUXER, MSGL_INFO, " NO SUBS (yet)! "); + } + + if(video_found || audio_found) + { + 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; i<8192; i++) { @@ -489,11 +585,13 @@ static void ts_detect_streams(demuxer_t *demuxer, uint32_t *a, uint32_t *v, int { priv->ts.pids[i]->payload_size = 0; priv->ts.pids[i]->pts = priv->ts.pids[i]->last_pts = 0; - //priv->ts.pids[i]->type = UNKNOWN; + priv->ts.pids[i]->seen = 0; + priv->ts.pids[i]->last_cc = -1; } } -} + return ret; +} demuxer_t *demux_open_ts(demuxer_t * demuxer) @@ -502,11 +600,11 @@ demuxer_t *demux_open_ts(demuxer_t * demuxer) uint8_t packet_size; sh_video_t *sh_video; sh_audio_t *sh_audio; - uint32_t at = 0, vt = 0; + off_t start_pos; + tsdemux_init_t params; ts_priv_t * priv = (ts_priv_t*) demuxer->priv; - demuxer_t *od; - mp_msg(MSGT_DEMUX, MSGL_DBG2, "DEMUX OPEN, AUDIO_ID: %d, VIDEO_ID: %d, SUBTITLE_ID: %d,\n", + mp_msg(MSGT_DEMUX, MSGL_INFO, "DEMUX OPEN, AUDIO_ID: %d, VIDEO_ID: %d, SUBTITLE_ID: %d,\n", demuxer->audio->id, demuxer->video->id, demuxer->sub->id); @@ -514,7 +612,6 @@ demuxer_t *demux_open_ts(demuxer_t * demuxer) stream_reset(demuxer->stream); - stream_seek(demuxer->stream, 0); packet_size = ts_check_file(demuxer); if(!packet_size) @@ -523,8 +620,7 @@ demuxer_t *demux_open_ts(demuxer_t * demuxer) priv = malloc(sizeof(ts_priv_t)); if(priv == NULL) { - mp_msg(MSGT_DEMUX, MSGL_FATAL, "DEMUX_OPEN_TS, couldn't allocate %lu bytes, exit\n", - sizeof(ts_priv_t)); + mp_msg(MSGT_DEMUX, MSGL_FATAL, "DEMUX_OPEN_TS, couldn't allocate enough memory for ts->priv, exit\n"); return NULL; } @@ -536,61 +632,80 @@ demuxer_t *demux_open_ts(demuxer_t * demuxer) 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 = 0; + demuxer->seekable = 1; else demuxer->seekable = 1; - stream_seek(demuxer->stream, 0); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES? - ts_detect_streams(demuxer, &at, &vt, &demuxer->audio->id, &demuxer->video->id, &ts_prog); - mp_msg(MSGT_DEMUXER,MSGL_INFO, "Opened TS demuxer, audio: %x(pid %d), video: %x(pid %d)...\n", at, demuxer->audio->id, vt, demuxer->video->id); + 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(vt) + if(dvdsub_lang != NULL) { - if(vt == VIDEO_MPEG4) + strncpy(params.slang, dvdsub_lang, 3); + params.slang[3] = 0; + } + else + memset(params.slang, 0, 4); + + if(audio_lang != NULL) + { + strncpy(params.alang, audio_lang, 3); + params.alang[3] = 0; + } + else + memset(params.alang, 0, 4); + + start_pos = ts_detect_streams(demuxer, ¶ms); + + demuxer->audio->id = params.apid; + demuxer->video->id = params.vpid; + demuxer->sub->id = params.spid; + priv->prog = params.prog; + + + if(params.vtype != UNKNOWN) + { + if(params.vtype == VIDEO_MPEG4) demuxer->file_format= DEMUXER_TYPE_MPEG4_IN_TS; sh_video = new_sh_video(demuxer, 0); sh_video->ds = demuxer->video; - sh_video->format = vt; + sh_video->format = params.vtype; demuxer->video->sh = sh_video; - - mp_msg(MSGT_DEMUXER,MSGL_INFO, "OPENED_SH_VIDEO\n"); } - if(at) + if(params.atype != UNKNOWN) { sh_audio = new_sh_audio(demuxer, 0); sh_audio->ds = demuxer->audio; - sh_audio->format = at; + sh_audio->format = params.atype; demuxer->audio->sh = sh_audio; - - mp_msg(MSGT_DEMUXER,MSGL_INFO, "OPENED_SH_AUDIO\n"); } - mp_msg(MSGT_DEMUXER,MSGL_INFO, "Opened TS demuxer2\n"); - - /* - demuxer->movi_start = 0; - demuxer->movi_end = demuxer->stream->end_pos; - */ - - stream_seek(demuxer->stream, 0); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES? + mp_msg(MSGT_DEMUXER,MSGL_INFO, "Opened TS demuxer, audio: %x(pid %d), video: %x(pid %d)...POS=%llu\n", params.atype, demuxer->audio->id, params.vtype, demuxer->video->id, (uint64_t) start_pos); + start_pos = (start_pos <= priv->ts.packet_size ? 0 : start_pos - priv->ts.packet_size); + demuxer->movi_start = start_pos; + stream_reset(demuxer->stream); + stream_seek(demuxer->stream, start_pos); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES? + - priv->is_synced = 0; - priv->last_afc = 0; priv->last_pid = 8192; //invalid pid - priv->is_start = 0; - for(i=0; i< 2; i++) + for(i = 0; i < 3; i++) { priv->fifo[i].pack = NULL; priv->fifo[i].offset = 0; @@ -598,10 +713,11 @@ demuxer_t *demux_open_ts(demuxer_t * demuxer) } 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->eof = 0; + priv->fifo[2].buffer_size = 32767; priv->pat.buffer_len = 0; @@ -609,11 +725,6 @@ demuxer_t *demux_open_ts(demuxer_t * demuxer) return demuxer; } - - - - - void demux_close_ts(demuxer_t * demuxer) { if(demuxer->priv) @@ -623,10 +734,6 @@ void demux_close_ts(demuxer_t * demuxer) } } - - - - static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, int32_t type_from_pmt) { unsigned char *p; @@ -641,7 +748,7 @@ static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, //uint32_t es_rate; //Here we are always at the start of a PES packet - mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(%X, %d): \n", buf, packet_len); + mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(%p, %d): \n", buf, (uint32_t) packet_len); if(packet_len == 0) { @@ -669,7 +776,10 @@ static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, 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]); @@ -729,6 +839,11 @@ static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, p += header_len + 9; packet_len -= header_len + 3; + /* + if(packet_len <= 0) + mp_msg(MSGT_DEMUX, MSGL_INFO, "\n\nNow: %d, prima: %d, ORIG: %d\n\n\n", packet_len, packet_len+3+header_len, pkt_len); + */ + if(es->payload_size) es->payload_size -= header_len + 3; @@ -741,64 +856,59 @@ static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[0] & 0x80); track = p[0] & 0x0F; - mp_msg(MSGT_DEMUX, MSGL_DBG2, "AC3 TRACK: %d\n", track); + mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 TRACK: %d\n", track); /* * we check the descriptor tag first because some stations - * do not include any of the ac3 header info in their audio tracks + * 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 == AUDIO_A52) || /* ac3 - raw */ - (p[0] == 0x0B && p[1] == 0x77) /* ac3 - syncword */ + (type_from_pmt == AUDIO_A52) || /* A52 - raw */ + (p[0] == 0x0B && p[1] == 0x77) /* A52 - syncword */ ) { - mp_msg(MSGT_DEMUX, MSGL_DBG2, "AC3 RAW OR SYNCWORD\n"); + 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 es->size; + return 1; } - /* - SUBS, it seems they are not streams in g1, what to do? - else if (//m->descriptor_tag == 0x06 && - p[0] == 0x20 && p[1] == 0x00) + /* SPU SUBS */ + else if(type_from_pmt == SPU_DVB || + (p[0] == 0x20)) // && p[1] == 0x00)) { - // DVBSUB - long payload_len = ((buf[4] << 8) | buf[5]) - header_len - 3; es->start = p; es->size = packet_len; - es->type = SPU_DVB + payload_len; + es->type = SPU_DVB; es->payload_size -= packet_len; - return es->size; + return 1; } - - else if ((p[0] & 0xE0) == 0x20) + else if ((p[0] & 0xE0) == 0x20) //SPU_DVD { - spu_id = (p[0] & 0x1f); + //DVD SUBS es->start = p+1; es->size = packet_len-1; - es->type = SPU_DVD + spu_id; + es->type = SPU_DVD; es->payload_size -= packet_len; - return es->size; + return 1; } - */ else if ((p[0] & 0xF0) == 0x80) { - mp_msg(MSGT_DEMUX, MSGL_DBG2, "AC3 WITH HEADER\n"); + 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 es->size; + return 1; } else if ((p[0]&0xf0) == 0xa0) { @@ -818,7 +928,7 @@ static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, es->type = AUDIO_LPCM_BE; es->payload_size -= packet_len; - return es->size; + return 1; } } else if ((stream_id >= 0xbc) && ((stream_id & 0xf0) == 0xe0)) @@ -829,7 +939,8 @@ static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, if(es->payload_size) es->payload_size -= packet_len; - return es->size; + mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: M2V size %d\n", es->size); + return 1; } else if ((stream_id == 0xfa)) { @@ -841,20 +952,38 @@ static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, if(es->payload_size) es->payload_size -= packet_len; - return es->size; + return 1; } } else if ((stream_id & 0xe0) == 0xc0) { - int track; + int profile = 0, srate = 0, channels = 0; + uint32_t hdr, l = 0; + + hdr = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; + if((hdr & 0xfff00000) == 0xfff00000) + { + // ADTS AAC shows with MPA layer 4 (00 in the layer bitstream) + l = 4 - ((hdr & 0x00060000) >> 17); + profile = ((hdr & 0x0000C000) >> 14); + srate = ((hdr & 0x00003c00) >> 10); + channels = ((hdr & 0x000001E0) >> 5); + } + mp_msg(MSGT_DEMUX, MSGL_DBG2, "\n\naudio header: %2X %2X %2X %2X\nLAYER: %d, PROFILE: %d, SRATE=%d, CHANNELS=%d\n\n", p[0], p[1], p[3], p[4], l, profile, srate, channels); - track = stream_id & 0x1f; es->start = p; es->size = packet_len; - es->type = AUDIO_MP2; + + + //if((type_from_pmt == 0x0f) || (l == 4)) //see in parse_pmt() + if(l==4) + es->type = AUDIO_AAC; + else + es->type = AUDIO_MP2; + es->payload_size -= packet_len; - return es->size; + return 1; } else if (type_from_pmt != -1) //as a last resort here we trust the PMT, if present { @@ -863,9 +992,8 @@ static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, es->type = type_from_pmt; es->payload_size -= packet_len; - return es->size; + return 1; } - else { mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: unknown packet, id: %x\n", stream_id); @@ -896,16 +1024,17 @@ static void ts_dump_streams(ts_priv_t *priv) { int i; - for(i = 0; i < 2; 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; } + priv->fifo[i].broken = 1; } - - priv->eof = 1; } @@ -942,15 +1071,29 @@ static inline int32_t prog_id_in_pat(ts_priv_t *priv, uint16_t pid) return -1; } +/* +DON'T REMOVE, I'LL NEED IT IN THE (NEAR) FUTURE) +static int check_crc32(uint32_t val, uint8_t *ptr, uint16_t len, uint8_t *vbase) +{ + uint32_t tab_crc32, calc_crc32; + + calc_crc32 = CalcCRC32(val, ptr, len); + + tab_crc32 = (vbase[0] << 24) | (vbase[1] << 16) | (vbase[2] << 8) | vbase[3]; + + printf("CRC32, TAB: %x, CALC: %x, eq: %x\n", tab_crc32, calc_crc32, tab_crc32 == calc_crc32); + return (tab_crc32 == calc_crc32); + +} +*/ static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int size) { uint8_t skip, m = 0; unsigned char *ptr; - unsigned char *base; //, *crc; + unsigned char *base; int entries, i, sections; uint16_t progid; - //uint32_t o_crc, calc_crc; //PRE-FILLING if(! is_start) @@ -996,13 +1139,6 @@ static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int si priv->pat.section_number = ptr[6]; priv->pat.last_section_number = ptr[7]; - /*CRC CHECK - crc = &(priv->pat.buffer[priv->pat.section_length - 4]); - o_crc = (crc[0] << 24) | (crc[1] << 16) | (crc[2] << 8) | crc[3]; - calc_crc = CalcCRC32(0xFFFFFFFFL, priv->pat.buffer, priv->pat.section_length); - printf("CRC ORIGINALE: %x, CALCOLATO: %x\n", o_crc, calc_crc); - */ - if((! priv->pat.curr_next) || (priv->pat.table_id != 0)) // || (! priv->pat.ssi)) return 0; @@ -1020,6 +1156,8 @@ static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int si return -1; //KEEP ON FILLING THE TABLE } + //check_crc32(0xFFFFFFFFL, ptr, priv->pat.buffer_len - 4, &ptr[priv->pat.buffer_len - 4]); + entries = (int) (priv->pat.section_length - 9) / 4; //entries per section @@ -1054,7 +1192,7 @@ static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int si static inline int32_t es_pid_in_pmt(pmt_t * pmt, uint16_t pid) { - int i; + uint16_t i; if(pmt == NULL) return -1; @@ -1065,13 +1203,107 @@ static inline int32_t es_pid_in_pmt(pmt_t * pmt, uint16_t pid) for(i = 0; i < pmt->es_cnt; i++) { if(pmt->es[i].pid == pid) - return i; + return (int32_t) i; } return -1; } +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_DBG2, "...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); + return -1; + } + + + if(ptr[j] == 0x6a) //A52 Descriptor + { + es->type = AUDIO_A52; + mp_msg(MSGT_DEMUX, MSGL_DBG2, "DVB A52 Descriptor\n"); + } + 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 + es->type = UNKNOWN; + mp_msg(MSGT_DEMUX, MSGL_DBG2, "FORMAT %s\n", es->format_descriptor); + } + } + 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_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_start, unsigned char *buff, int size) { @@ -1088,7 +1320,7 @@ static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_sta priv->pmt = (pmt_t *) realloc(priv->pmt, sz); if(priv->pmt == NULL) { - mp_msg(MSGT_DEMUX, MSGL_ERR, "FILL_PMT: COULDN'T REALLOC %d bytes, NEXT\n", sz); + mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT: COULDN'T REALLOC %d bytes, NEXT\n", sz); return NULL; } @@ -1127,13 +1359,20 @@ static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_sta 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; + return NULL; + } + 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, TSPID: %d\n", - progid, pmt->buffer_len, is_start, pid); + 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; @@ -1157,6 +1396,7 @@ static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_sta 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; } @@ -1190,6 +1430,7 @@ static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_sta continue; } idx = pmt->es_cnt; + memset(&(pmt->es[idx]), 0, sizeof(struct pmt_es_t)); pmt->es_cnt++; } @@ -1198,8 +1439,8 @@ static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_sta if(pmt->es[idx].descr_length > section_bytes - 5) { - mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT, ES_DESCR_LENGTH TOO LARGE %d > %d, EXIT %d bytes for PMT_ES\n", - pmt->es[idx].descr_length, section_bytes - 5, section_bytes); + 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; } @@ -1207,6 +1448,8 @@ static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_sta pmt->es[idx].pid = es_pid; pmt->es[idx].type = es_type; + pmt->es[idx].type = UNKNOWN; + switch(es_type) { case 1: @@ -1217,29 +1460,47 @@ static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_sta break; case 3: case 4: + parse_descriptors(&pmt->es[idx], &es_base[5]); pmt->es[idx].type = AUDIO_MP2; break; case 6: - { - int j; - for(j = 5; j < pmt->es[idx].descr_length; j += es_base[j+1] + 2) //possible DVB-AC3 - if(es_base[j] == 0x6a) - pmt->es[idx].type = AUDIO_A52; - } - break; - + parse_descriptors(&pmt->es[idx], &es_base[5]); + if(pmt->es[idx].type == 0x6) + pmt->es[idx].type = UNKNOWN; + break; case 0x10: pmt->es[idx].type = VIDEO_MPEG4; break; case 0x11: + parse_descriptors(&pmt->es[idx], &es_base[5]); pmt->es[idx].type = AUDIO_AAC; break; + /* seems to indicate an AAC in a certain broadcaster's tables, but + it's deceiving, so it's commented out + case 0x0f: + parse_descriptors(&pmt->es[idx], &es_base[5]); + pmt->es[idx].type = 0x0f; + 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; + } + } + } section_bytes -= 5 + pmt->es[idx].descr_length; mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT(%d INDEX %d), STREAM: %d, FOUND pid=0x%x (%d), type=0x%x, ES_DESCR_LENGTH: %d, bytes left: %d\n", @@ -1251,67 +1512,148 @@ static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_sta es_count++; } + mp_msg(MSGT_DEMUX, MSGL_V, "----------------------------\n"); return 1; } +static inline int32_t pid_type_from_pmt(ts_priv_t *priv, int pid) +{ + int32_t pmt_idx, pid_idx, i, j; + + pmt_idx = progid_idx_in_pmt(priv, priv->prog); + + if(pmt_idx != -1) + { + pid_idx = es_pid_in_pmt(&(priv->pmt[pmt_idx]), pid); + if(pid_idx != -1) + return priv->pmt[pmt_idx].es[pid_idx].type; + } + //else + //{ + for(i = 0; i < priv->pmt_cnt; i++) + { + pmt_t *pmt = &(priv->pmt[i]); + for(j = 0; j < pmt->es_cnt; j++) + if(pmt->es[j].pid == pid) + return pmt->es[j].type; + } + //} + + return UNKNOWN; +} + + +static inline uint8_t *pid_lang_from_pmt(ts_priv_t *priv, int pid) +{ + int32_t pmt_idx, pid_idx, i, j; + + pmt_idx = progid_idx_in_pmt(priv, priv->prog); + + if(pmt_idx != -1) + { + pid_idx = es_pid_in_pmt(&(priv->pmt[pmt_idx]), pid); + if(pid_idx != -1) + return priv->pmt[pmt_idx].es[pid_idx].lang; + } + else + { + for(i = 0; i < priv->pmt_cnt; i++) + { + pmt_t *pmt = &(priv->pmt[i]); + for(j = 0; j < pmt->es_cnt; j++) + if(pmt->es[j].pid == pid) + return pmt->es[j].lang; + } + } + + return NULL; +} + + +static int fill_packet(demuxer_t *demuxer, demux_stream_t *ds, demux_packet_t **dp, int *dp_offset, int *broken) +{ + int ret = 0; + + if((*dp != NULL) && (*dp_offset > 0)) + { + if(*broken == 0) + { + ret = *dp_offset; + resize_demux_packet(*dp, ret); //shrinked to the right size + ds_add_packet(ds, *dp); + mp_msg(MSGT_DEMUX, MSGL_V, "ADDED %d bytes to %s fifo, PTS=%f\n", ret, (ds == demuxer->audio ? "audio" : (ds == demuxer->video ? "video" : "sub")), (*dp)->pts); + } + else + { + ret = 0; + mp_msg(MSGT_DEMUX, MSGL_V, "BROKEN PES, DISCARDING\n"); + free_demux_packet(*dp); + } + } + + *broken = 1; + *dp = NULL; + *dp_offset = 0; + + return ret; +} + // 0 = EOF or no stream found // else = [-] number of bytes written to the packet static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, int probe) { ES_stream_t *tss; uint8_t done = 0; - int buf_size, is_start; - int len, pid, cc, cc_ok, afc, _read; + int buf_size, is_start, pid, base; + int len, cc, cc_ok, afc, retv = 0, is_video, is_audio, is_sub; ts_priv_t * priv = (ts_priv_t*) demuxer->priv; stream_t *stream = demuxer->stream; char *p, tmp[TS_FEC_PACKET_SIZE]; demux_stream_t *ds = NULL; demux_packet_t **dp = NULL; int *dp_offset = 0, *buffer_size = 0, *broken = NULL; - int32_t progid, pid_idx, pid_type; + int32_t progid, pid_type; while(! done) { + ds = (demux_stream_t*) NULL; + dp = (demux_packet_t **) NULL; + broken = dp_offset = buffer_size = NULL; + + buf_size = priv->ts.packet_size; + if(stream_eof(stream)) { - if(! priv->eof) + if(! probe) { ts_dump_streams(priv); demuxer->filepos = stream_tell(demuxer->stream); - return -1; - } - else - return 0; - } - - - if(! priv->is_synced) - { - if(! ts_sync(stream)) - { - mp_msg(MSGT_DEMUX, MSGL_V, "TS_PARSE: COULDN'T SYNC\n"); - return 0; } - len = stream_read(stream, &packet[1], 3); - if (len != 3) - return 0; + return 0; } - _read = 4; - if(! priv->is_synced) + + if(! ts_sync(stream)) { - is_start = packet[1] & 0x40; - pid = ((packet[1] & 0x1f) << 8) | packet[2]; - } - else - { - is_start = priv->is_start; - pid = priv->last_pid; + mp_msg(MSGT_DEMUX, MSGL_V, "TS_PARSE: COULDN'T SYNC\n"); + return 0; } + len = stream_read(stream, &packet[1], 3); + if (len != 3) + return 0; + + if((packet[1] >> 7) & 0x01) //transport error + continue; + + buf_size -= 4; + + is_start = packet[1] & 0x40; + pid = ((packet[1] & 0x1f) << 8) | packet[2]; + tss = priv->ts.pids[pid]; //an ES stream if(tss == NULL) { @@ -1323,8 +1665,8 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, tss->last_cc = -1; tss->type = UNKNOWN; tss->payload_size = 0; - priv->ts.pids[pid] = tss; - mp_msg(MSGT_DEMUX, MSGL_INFO, "\nNew TS pid=%u\n", pid); + tss->seen = 0; + priv->ts.pids[pid] = tss; } @@ -1334,17 +1676,12 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, cc = (packet[3] & 0xf); cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc)); - if(! cc_ok) - { - mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse: CCCheck NOT OK: %d -> %d\n", tss->last_cc, cc); - } tss->last_cc = cc; - - if(! priv->is_synced) + if(cc_ok) { - priv->last_afc = 0; - /* skip adaptation field */ + /* skip adaptation field, but only if cc_ok is not corrupt, + otherwise we may throw away good data */ afc = (packet[3] >> 4) & 3; if (afc == 0) /* reserved value */ continue; @@ -1353,38 +1690,46 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, if (afc == 3) { int c; - stream_read(stream, &packet[_read], 1); - c = packet[_read]; - _read++; + c = stream_read_char(stream); + buf_size--; - c = min(c, priv->ts.packet_size - _read); - stream_read(stream, &packet[_read], c); - _read += c; + c = min(c, buf_size); + stream_skip(stream, c); + buf_size -= c; + if(buf_size == 0) + continue; - priv->last_afc = c + 1; - mp_msg(MSGT_DEMUX, MSGL_DBG2, "AFC: %d\n", priv->last_afc); - - if(_read == priv->ts.packet_size) - continue; + afc = c + 1; } + else + afc = 0; } else { - _read += priv->last_afc; - priv->last_afc = 0; + // logically this packet should be dropped, but if I do it + // certain streams play corrupted. Maybe the decoders know + // how to deal with it, but at least I consider the packet + // as "not initial" + mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse: CC Check NOT OK: PID=%d, %d -> %d\n\n", tss->pid, tss->last_cc, cc); + + if(priv->keep_broken == 0) + continue; + + is_start = 0; } - // PES CONTENT STARTS HERE + 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); - buf_size = priv->ts.packet_size - _read; - //LET'S PARSE TABLES + //TABLE PARSING + base = priv->ts.packet_size - buf_size; if(pid == 0) { - stream_read(stream,&packet[_read], buf_size); - parse_pat(priv, is_start, &packet[_read], buf_size); - priv->is_synced = 0; + stream_read(stream,&packet[base], buf_size); + parse_pat(priv, is_start, &packet[base], buf_size); continue; } else @@ -1392,19 +1737,34 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, progid = prog_id_in_pat(priv, pid); if(((progid != -1) || (pid == 16))) { - stream_read(stream,&packet[_read], buf_size); - parse_pmt(priv, progid, pid, is_start, &packet[_read], buf_size); - priv->is_synced = 0; - continue; + if(pid != demuxer->video->id && pid != demuxer->audio->id && pid != demuxer->sub->id) + { + stream_read(stream,&packet[base], buf_size); + parse_pmt(priv, progid, pid, is_start, &packet[base], buf_size); + continue; + } + else + mp_msg(MSGT_DEMUX, MSGL_ERR, "Argh! Data pid used in the PMT, Skipping PMT parsing!\n"); } } + priv->last_pid = pid; + is_video = ((tss->type == VIDEO_MPEG1) || (tss->type == VIDEO_MPEG2) || (tss->type == VIDEO_MPEG4)); + is_audio = ((tss->type == AUDIO_MP2) || (tss->type == AUDIO_A52) || (tss->type == AUDIO_LPCM_BE) || (tss->type == AUDIO_AAC)); + is_sub = ((tss->type == SPU_DVD) || (tss->type == SPU_DVB)); + pid_type = pid_type_from_pmt(priv, pid); + + // PES CONTENT STARTS HERE if(! probe) { - if(((tss->type == VIDEO_MPEG1) || (tss->type == VIDEO_MPEG2) || (tss->type == VIDEO_MPEG4)) - && (demuxer->video->id == tss->pid)) + if((pid == demuxer->sub->id)) //or the lang is right + { + pid_type = SPU_DVD; + } + + if(is_video && (demuxer->video->id == tss->pid)) { ds = demuxer->video; @@ -1413,8 +1773,7 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, buffer_size = &priv->fifo[1].buffer_size; broken = &priv->fifo[1].broken; } - else if(((tss->type == AUDIO_MP2) || (tss->type == AUDIO_A52) || (tss->type == AUDIO_LPCM_BE) || (tss->type == AUDIO_AAC)) - && (demuxer->audio->id == tss->pid)) + else if(is_audio && (demuxer->audio->id == tss->pid)) { ds = demuxer->audio; @@ -1423,47 +1782,71 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, buffer_size = &priv->fifo[0].buffer_size; broken = &priv->fifo[0].broken; } + else if(is_sub + || (pid_type == SPU_DVD) || (pid_type == SPU_DVB)) + { + //SUBS are infrequent, so the initial detection may fail + // and we may need to add them at play-time + if(demuxer->sub->id == -1) + { + uint16_t p; + p = progid_for_pid(priv, tss->pid, priv->prog); + + if(p == priv->prog) + { + int asgn = 0; + uint8_t *lang; + + if(!strcmp(dvdsub_lang, "")) + asgn = 1; + else + { + lang = pid_lang_from_pmt(priv, pid); + if(lang != NULL) + asgn = (strncmp(lang, dvdsub_lang, 3) == 0); + else + asgn = 0; + } + + if(asgn) + { + demuxer->sub->id = tss->pid; + mp_msg(MSGT_DEMUX, MSGL_INFO, "CHOSEN SUBs pid 0x%x (%d) FROM PROG %d\n", tss->pid, tss->pid, priv->prog); + } + } + else + { + mp_msg(MSGT_DEMUX, MSGL_V, "DISCARDED SUBs pid 0x%x (%d) NOT CHOSEN OR NOT IN PROG %d\n", tss->pid, tss->pid, priv->prog); + } + } + + if(demuxer->sub->id == tss->pid) + { + ds = demuxer->sub; + + dp = &priv->fifo[2].pack; + dp_offset = &priv->fifo[2].offset; + buffer_size = &priv->fifo[2].buffer_size; + broken = &priv->fifo[2].broken; + } + else + { + stream_skip(stream, buf_size); + continue; + } + } else { stream_skip(stream, buf_size); - _read += buf_size; continue; } //IS IT TIME TO QUEUE DATA to the dp_packet? - if(is_start && (*dp != NULL) && (*dp_offset > 0)) + if(is_start && (dp != NULL)) { - priv->last_pid = pid; - priv->is_synced = 1; - priv->is_start = is_start; - - if(! *broken) - { - int ret = *dp_offset; - resize_demux_packet(*dp, ret); //shrinked to the right size - - ds_add_packet(ds, *dp); - mp_msg(MSGT_DEMUX, MSGL_V, "ADDED %d bytes to %s fifo, PTS=%f\n", ret, (ds == demuxer->audio ? "audio" : "video"), (*dp)->pts); - - - *dp = NULL; - *dp_offset = 0; - - return -ret; - } - else - { - mp_msg(MSGT_DEMUX, MSGL_V, "BROKEN PES, DISCARDING\n"); - free_demux_packet(*dp); - - *dp = NULL; - *dp_offset = 0; - - continue; - } + retv = fill_packet(demuxer, ds, dp, dp_offset, broken); } - priv->last_pid = pid; if(*dp == NULL) { @@ -1480,29 +1863,18 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, mp_msg(MSGT_DEMUX, MSGL_DBG2, "NOW PACKET_SIZE = %d, DP_OFFSET = %d\n", *buffer_size, *dp_offset); } - priv->is_synced = 0; if(is_start) { mp_msg(MSGT_DEMUX, MSGL_DBG2, "IS_START\n"); - //priv->is_synced = 0; - - p = &packet[_read]; + p = &packet[base]; stream_read(stream, p, buf_size); - _read += buf_size; - - pid_idx = es_pid_in_pmt(priv->pmt, pid); - if(pid_idx == -1) - pid_type = UNKNOWN; - else - pid_type = priv->pmt->es[pid_idx].type; - len = pes_parse2(p, buf_size, es, pid_type); - if(len) + if(len > 0) { if(es->type == UNKNOWN) continue; @@ -1518,36 +1890,38 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, else tss->pts = tss->last_pts = es->pts; - mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse, NEW pid=%d, PSIZE: %u, type=%X, start=%X, len=%d\n", + mp_msg(MSGT_DEMUX, MSGL_V, "ts_parse, NEW pid=%d, PSIZE: %u, type=%X, start=%p, len=%d\n", es->pid, es->payload_size, es->type, es->start, es->size); tss->payload_size = es->payload_size; - mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse, NOW tss->PSIZE=%u\n", tss->payload_size); - demuxer->filepos = stream_tell(demuxer->stream) - es->size; if(probe) - return es->size; + return 1; //es->size; else { *broken = 0; - if(*dp_offset + es->size > *buffer_size) + if(es->size > 0) { - *buffer_size = *dp_offset + es->size + TS_FEC_PACKET_SIZE; - resize_demux_packet(*dp, *buffer_size); - //we'll skip at least one RESIZE() in the next iteration of ts_parse() - mp_msg(MSGT_DEMUX, MSGL_DBG2, "RESIZE DP TO %d\n", *buffer_size); + if(*dp_offset + es->size > *buffer_size) + { + *buffer_size = *dp_offset + es->size + TS_FEC_PACKET_SIZE; + resize_demux_packet(*dp, *buffer_size); + //we'll skip at least one RESIZE() in the next iteration of ts_parse() + mp_msg(MSGT_DEMUX, MSGL_DBG2, "RESIZE DP TO %d\n", *buffer_size); + } + memcpy(&((*dp)->buffer[*dp_offset]), es->start, es->size); + *dp_offset += es->size; + (*dp)->flags = 0; + (*dp)->pos = stream_tell(demuxer->stream); + (*dp)->pts = es->pts; } - memcpy(&((*dp)->buffer[*dp_offset]), es->start, es->size); - *dp_offset += es->size; - (*dp)->flags = 0; - (*dp)->pts = es->pts; - (*dp)->pos = stream_tell(demuxer->stream); - *broken = 0; - mp_msg(MSGT_DEMUX, MSGL_DBG2, "INIT PACKET, TYPE=%x, PTS: %f\n", es->type, es->pts); - continue; + if(retv > 0) + return retv; + else + continue; } } else @@ -1567,10 +1941,10 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, es->pid = tss->pid; es->type = tss->type; es->pts = tss->pts = tss->last_pts; - es->start = &packet[_read]; + es->start = &packet[base]; - if(tss->payload_size) + if(tss->payload_size > 0) { sz = min(tss->payload_size, buf_size); tss->payload_size -= sz; @@ -1578,8 +1952,10 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, } else { - if((es->type == VIDEO_MPEG1) || (es->type == VIDEO_MPEG2) || (es->type == VIDEO_MPEG4)) + if(is_video) + { sz = es->size = buf_size; + } else { stream_skip(stream, buf_size); @@ -1596,14 +1972,16 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, resize_demux_packet(*dp, *buffer_size); //we'll skip at least one RESIZE() in the next iteration of ts_parse() mp_msg(MSGT_DEMUX, MSGL_DBG2, "RESIZE DP TO %d\n", *buffer_size); + //mp_msg(MSGT_DEMUX, MSGL_INFO, "SECOND TYPE=%x, bytes=%d, afc=%d, psize=%d, tell=%llu\n", es->type, sz, afc, tss->payload_size, (uint64_t) stream_tell(demuxer->stream)); } - stream_read(stream, &((*dp)->buffer[*dp_offset]), sz); *dp_offset += sz; - if(buf_size - sz) + if(buf_size - sz > 0) + { stream_skip(stream, buf_size - sz); + } continue; } @@ -1612,8 +1990,6 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, stream_read(stream, es->start, sz); if(buf_size - sz) stream_read(stream, tmp, buf_size-sz); - _read += buf_size; - if(es->size) return es->size; else @@ -1629,47 +2005,76 @@ static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, extern void resync_audio_stream(sh_audio_t *sh_audio); extern void skip_audio_frame(sh_audio_t *sh_audio); -static void reset_fifos(ts_priv_t* priv, int a, int v) +static void reset_fifos(ts_priv_t* priv, int a, int v, int s) { if(a) { - priv->fifo[0].pack = NULL; + if(priv->fifo[0].pack != NULL) + { + free_demux_packet(priv->fifo[0].pack); + priv->fifo[0].pack = NULL; + } priv->fifo[0].offset = 0; - priv->fifo[0].buffer_size = 0; priv->fifo[0].broken = 1; - priv->is_synced = 0; } if(v) { - priv->fifo[1].pack = NULL; + if(priv->fifo[1].pack != NULL) + { + free_demux_packet(priv->fifo[1].pack); + priv->fifo[1].pack = NULL; + } priv->fifo[1].offset = 0; - priv->fifo[1].buffer_size = 0; priv->fifo[1].broken = 1; - priv->is_synced = 0; + } + + if(s) + { + if(priv->fifo[2].pack != NULL) + { + free_demux_packet(priv->fifo[2].pack); + priv->fifo[2].pack = NULL; + } + priv->fifo[2].offset = 0; + priv->fifo[2].broken = 1; } } -void demux_seek_ts(demuxer_t *demuxer,float rel_seek_secs,int flags) +extern int videobuf_code_len; +extern int sync_video_packet(demux_stream_t *); +extern int skip_video_packet(demux_stream_t *); + +void demux_seek_ts(demuxer_t *demuxer, float rel_seek_secs, int flags) { demux_stream_t *d_audio=demuxer->audio; demux_stream_t *d_video=demuxer->video; + demux_stream_t *d_sub=demuxer->sub; sh_audio_t *sh_audio=d_audio->sh; sh_video_t *sh_video=d_video->sh; ts_priv_t * priv = (ts_priv_t*) demuxer->priv; int i, video_stats; + off_t newpos; - //================= seek in MPEG ========================== - off_t newpos = (flags&1)?demuxer->movi_start:demuxer->filepos; + //================= seek in MPEG-TS ========================== ts_dump_streams(demuxer->priv); - reset_fifos(priv, sh_audio != NULL, sh_video != NULL); + reset_fifos(priv, sh_audio != NULL, sh_video != NULL, demuxer->sub->id > 0); + + + if(sh_audio != NULL) + ds_free_packs(d_audio); + if(sh_video != NULL) + ds_free_packs(d_video); + if(demuxer->sub->id > 0) + ds_free_packs(d_sub); video_stats = (sh_video != NULL); if(video_stats) video_stats = sh_video->i_bps; + newpos = (flags & 1) ? demuxer->movi_start : demuxer->filepos; if(flags & 2) // float seek 0..1 newpos+=(demuxer->movi_end-demuxer->movi_start)*rel_seek_secs; else @@ -1683,8 +2088,8 @@ void demux_seek_ts(demuxer_t *demuxer,float rel_seek_secs,int flags) } - if(newposmovi_start) - newpos = demuxer->movi_start = 0; //begininng of stream + if(newpos < demuxer->movi_start) + newpos = demuxer->movi_start; //begininng of stream #ifdef _LARGEFILE_SOURCE newpos &= ~((long long) (STREAM_BUFFER_SIZE - 1)); /* sector boundary */ @@ -1692,15 +2097,9 @@ void demux_seek_ts(demuxer_t *demuxer,float rel_seek_secs,int flags) newpos &= ~(STREAM_BUFFER_SIZE - 1); /* sector boundary */ #endif - reset_fifos(priv, sh_audio != NULL, sh_video != NULL); - - if(sh_audio != NULL) - ds_free_packs(d_audio); - if(sh_video != NULL) - ds_free_packs(d_video); - stream_seek(demuxer->stream, newpos); + videobuf_code_len = 0; if(sh_video != NULL) ds_fill_buffer(d_video); @@ -1717,7 +2116,7 @@ void demux_seek_ts(demuxer_t *demuxer,float rel_seek_secs,int flags) { float a_pts=d_audio->pts; a_pts+=(ds_tell_pts(d_audio)-sh_audio->a_in_buffer_len)/(float)sh_audio->i_bps; - if(d_video->pts>a_pts) + if(d_video->pts > a_pts) { skip_audio_frame(sh_audio); // sync audio continue; @@ -1726,7 +2125,7 @@ void demux_seek_ts(demuxer_t *demuxer,float rel_seek_secs,int flags) i = sync_video_packet(d_video); - if(sh_video->format == VIDEO_MPEG1 || sh_video->format == VIDEO_MPEG2) + if((sh_video->format == VIDEO_MPEG1) || (sh_video->format == VIDEO_MPEG2)) { if(i==0x1B3 || i==0x1B8) break; // found it! }