//#define DEBUG
//#define DEBUG_SEEK
+//#define USE_SYNCPOINT_SEARCH
#include "libavutil/crc.h"
#include "libavutil/intreadwrite.h"
#include "avformat.h"
#include "mpegts.h"
#include "internal.h"
+#include "seek.h"
/* 1.0 second at 24Mbit/s */
#define MAX_SCAN_PACKETS 32000
/* maximum size in which we look for synchronisation if
synchronisation is lost */
-#define MAX_RESYNC_SIZE 4096
-#define REGISTRATION_DESCRIPTOR 5
+#define MAX_RESYNC_SIZE 65536
#define MAX_PES_PAYLOAD 200*1024
-typedef struct PESContext PESContext;
-
-static PESContext* add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type);
-static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code);
-
enum MpegTSFilterType {
MPEGTS_PES,
MPEGTS_SECTION,
typedef struct MpegTSFilter MpegTSFilter;
-typedef void PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos);
+typedef int PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos);
typedef struct MpegTSPESFilter {
PESCallback *pes_cb;
enum MpegTSState {
MPEGTS_HEADER = 0,
+ MPEGTS_PESHEADER,
MPEGTS_PESHEADER_FILL,
MPEGTS_PAYLOAD,
MPEGTS_SKIP,
};
/* enough for PES header + length */
-#define PES_START_SIZE 9
+#define PES_START_SIZE 6
+#define PES_HEADER_SIZE 9
#define MAX_PES_HEADER_SIZE (9 + 255)
-struct PESContext {
+typedef struct PESContext {
int pid;
int pcr_pid; /**< if -1 then all packets containing PCR are considered */
int stream_type;
MpegTSContext *ts;
AVFormatContext *stream;
AVStream *st;
+ AVStream *sub_st; /**< stream for the embedded AC3 stream in HDMV TrueHD */
enum MpegTSState state;
/* used to get the format */
int data_index;
int total_size;
int pes_header_size;
+ int extended_stream_id;
int64_t pts, dts;
int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */
uint8_t header[MAX_PES_HEADER_SIZE];
uint8_t *buffer;
-};
+} PESContext;
extern AVInputFormat mpegts_demuxer;
}
static int analyze(const uint8_t *buf, int size, int packet_size, int *index){
- int stat[packet_size];
+ int stat[TS_MAX_PACKET_SIZE];
int i;
int x=0;
int best_score=0;
return 0;
}
+typedef struct {
+ uint32_t stream_type;
+ enum CodecType codec_type;
+ enum CodecID codec_id;
+} StreamType;
+
+static const StreamType ISO_types[] = {
+ { 0x01, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
+ { 0x02, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO },
+ { 0x03, CODEC_TYPE_AUDIO, CODEC_ID_MP3 },
+ { 0x04, CODEC_TYPE_AUDIO, CODEC_ID_MP3 },
+ { 0x0f, CODEC_TYPE_AUDIO, CODEC_ID_AAC },
+ { 0x10, CODEC_TYPE_VIDEO, CODEC_ID_MPEG4 },
+ { 0x11, CODEC_TYPE_AUDIO, CODEC_ID_AAC }, /* LATM syntax */
+ { 0x1b, CODEC_TYPE_VIDEO, CODEC_ID_H264 },
+ { 0xd1, CODEC_TYPE_VIDEO, CODEC_ID_DIRAC },
+ { 0xea, CODEC_TYPE_VIDEO, CODEC_ID_VC1 },
+ { 0 },
+};
+
+static const StreamType HDMV_types[] = {
+ { 0x80, CODEC_TYPE_AUDIO, CODEC_ID_PCM_BLURAY },
+ { 0x81, CODEC_TYPE_AUDIO, CODEC_ID_AC3 },
+ { 0x82, CODEC_TYPE_AUDIO, CODEC_ID_DTS },
+ { 0x83, CODEC_TYPE_AUDIO, CODEC_ID_TRUEHD },
+ { 0x84, CODEC_TYPE_AUDIO, CODEC_ID_EAC3 },
+ { 0x90, CODEC_TYPE_SUBTITLE, CODEC_ID_HDMV_PGS_SUBTITLE },
+ { 0 },
+};
+
+/* ATSC ? */
+static const StreamType MISC_types[] = {
+ { 0x81, CODEC_TYPE_AUDIO, CODEC_ID_AC3 },
+ { 0x8a, CODEC_TYPE_AUDIO, CODEC_ID_DTS },
+ { 0 },
+};
+
+static const StreamType REGD_types[] = {
+ { MKTAG('d','r','a','c'), CODEC_TYPE_VIDEO, CODEC_ID_DIRAC },
+ { MKTAG('A','C','-','3'), CODEC_TYPE_AUDIO, CODEC_ID_AC3 },
+ { 0 },
+};
+
+/* descriptor present */
+static const StreamType DESC_types[] = {
+ { 0x6a, CODEC_TYPE_AUDIO, CODEC_ID_AC3 }, /* AC-3 descriptor */
+ { 0x7a, CODEC_TYPE_AUDIO, CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
+ { 0x7b, CODEC_TYPE_AUDIO, CODEC_ID_DTS },
+ { 0x56, CODEC_TYPE_SUBTITLE, CODEC_ID_DVB_TELETEXT },
+ { 0x59, CODEC_TYPE_SUBTITLE, CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
+ { 0 },
+};
+
+static void mpegts_find_stream_type(AVStream *st,
+ uint32_t stream_type, const StreamType *types)
+{
+ for (; types->stream_type; types++) {
+ if (stream_type == types->stream_type) {
+ st->codec->codec_type = types->codec_type;
+ st->codec->codec_id = types->codec_id;
+ return;
+ }
+ }
+}
+
+static int mpegts_set_stream_info(AVStream *st, PESContext *pes,
+ uint32_t stream_type, uint32_t prog_reg_desc)
+{
+ av_set_pts_info(st, 33, 1, 90000);
+ st->priv_data = pes;
+ st->codec->codec_type = CODEC_TYPE_DATA;
+ st->codec->codec_id = CODEC_ID_NONE;
+ st->need_parsing = AVSTREAM_PARSE_FULL;
+ pes->st = st;
+ pes->stream_type = stream_type;
+
+ av_log(pes->stream, AV_LOG_DEBUG,
+ "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
+ st->index, pes->stream_type, pes->pid, (char*)&prog_reg_desc);
+
+ st->codec->codec_tag = pes->stream_type;
+
+ mpegts_find_stream_type(st, pes->stream_type, ISO_types);
+ if (prog_reg_desc == AV_RL32("HDMV") &&
+ st->codec->codec_id == CODEC_ID_NONE) {
+ mpegts_find_stream_type(st, pes->stream_type, HDMV_types);
+ if (pes->stream_type == 0x83) {
+ // HDMV TrueHD streams also contain an AC3 coded version of the
+ // audio track - add a second stream for this
+ AVStream *sub_st;
+ // priv_data cannot be shared between streams
+ PESContext *sub_pes = av_malloc(sizeof(*sub_pes));
+ if (!sub_pes)
+ return AVERROR(ENOMEM);
+ memcpy(sub_pes, pes, sizeof(*sub_pes));
+
+ sub_st = av_new_stream(pes->stream, pes->pid);
+ if (!sub_st) {
+ av_free(sub_pes);
+ return AVERROR(ENOMEM);
+ }
+
+ av_set_pts_info(sub_st, 33, 1, 90000);
+ sub_st->priv_data = sub_pes;
+ sub_st->codec->codec_type = CODEC_TYPE_AUDIO;
+ sub_st->codec->codec_id = CODEC_ID_AC3;
+ sub_st->need_parsing = AVSTREAM_PARSE_FULL;
+ sub_pes->sub_st = pes->sub_st = sub_st;
+ }
+ }
+ if (st->codec->codec_id == CODEC_ID_NONE)
+ mpegts_find_stream_type(st, pes->stream_type, MISC_types);
+
+ return 0;
+}
+
+static int64_t get_pts(const uint8_t *p)
+{
+ int64_t pts = (int64_t)((p[0] >> 1) & 0x07) << 30;
+ pts |= (AV_RB16(p + 1) >> 1) << 15;
+ pts |= AV_RB16(p + 3) >> 1;
+ return pts;
+}
+
+static void new_pes_packet(PESContext *pes, AVPacket *pkt)
+{
+ av_init_packet(pkt);
+
+ pkt->destruct = av_destruct_packet;
+ pkt->data = pes->buffer;
+ pkt->size = pes->data_index;
+ memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
+
+ // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
+ if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76)
+ pkt->stream_index = pes->sub_st->index;
+ else
+ pkt->stream_index = pes->st->index;
+ pkt->pts = pes->pts;
+ pkt->dts = pes->dts;
+ /* store position of first TS packet of this PES packet */
+ pkt->pos = pes->ts_packet_pos;
+
+ /* reset pts values */
+ pes->pts = AV_NOPTS_VALUE;
+ pes->dts = AV_NOPTS_VALUE;
+ pes->buffer = NULL;
+ pes->data_index = 0;
+}
+
+/* return non zero if a packet could be constructed */
+static int mpegts_push_data(MpegTSFilter *filter,
+ const uint8_t *buf, int buf_size, int is_start,
+ int64_t pos)
+{
+ PESContext *pes = filter->u.pes_filter.opaque;
+ MpegTSContext *ts = pes->ts;
+ const uint8_t *p;
+ int len, code;
+
+ if(!ts->pkt)
+ return 0;
+
+ if (is_start) {
+ if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
+ new_pes_packet(pes, ts->pkt);
+ ts->stop_parse = 1;
+ }
+ pes->state = MPEGTS_HEADER;
+ pes->data_index = 0;
+ pes->ts_packet_pos = pos;
+ }
+ p = buf;
+ while (buf_size > 0) {
+ switch(pes->state) {
+ case MPEGTS_HEADER:
+ len = PES_START_SIZE - pes->data_index;
+ if (len > buf_size)
+ len = buf_size;
+ memcpy(pes->header + pes->data_index, p, len);
+ pes->data_index += len;
+ p += len;
+ buf_size -= len;
+ if (pes->data_index == PES_START_SIZE) {
+ /* we got all the PES or section header. We can now
+ decide */
+#if 0
+ av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index);
+#endif
+ if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
+ pes->header[2] == 0x01) {
+ /* it must be an mpeg2 PES stream */
+ code = pes->header[3] | 0x100;
+ dprintf(pes->stream, "pid=%x pes_code=%#x\n", pes->pid, code);
+
+ if ((!pes->st && pes->stream->nb_streams == MAX_STREAMS) ||
+ (pes->st && pes->st->discard == AVDISCARD_ALL) ||
+ code == 0x1be) /* padding_stream */
+ goto skip;
+
+ /* stream not present in PMT */
+ if (!pes->st) {
+ pes->st = av_new_stream(ts->stream, pes->pid);
+ if (!pes->st)
+ return AVERROR(ENOMEM);
+ mpegts_set_stream_info(pes->st, pes, 0, 0);
+ }
+
+ pes->total_size = AV_RB16(pes->header + 4);
+ /* NOTE: a zero total size means the PES size is
+ unbounded */
+ if (!pes->total_size)
+ pes->total_size = MAX_PES_PAYLOAD;
+
+ /* allocate pes buffer */
+ pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);
+ if (!pes->buffer)
+ return AVERROR(ENOMEM);
+
+ if (code != 0x1bc && code != 0x1bf && /* program_stream_map, private_stream_2 */
+ code != 0x1f0 && code != 0x1f1 && /* ECM, EMM */
+ code != 0x1ff && code != 0x1f2 && /* program_stream_directory, DSMCC_stream */
+ code != 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */
+ pes->state = MPEGTS_PESHEADER;
+ if (pes->st->codec->codec_id == CODEC_ID_NONE) {
+ dprintf(pes->stream, "pid=%x stream_type=%x probing\n",
+ pes->pid, pes->stream_type);
+ pes->st->codec->codec_id = CODEC_ID_PROBE;
+ }
+ } else {
+ pes->state = MPEGTS_PAYLOAD;
+ pes->data_index = 0;
+ }
+ } else {
+ /* otherwise, it should be a table */
+ /* skip packet */
+ skip:
+ pes->state = MPEGTS_SKIP;
+ continue;
+ }
+ }
+ break;
+ /**********************************************/
+ /* PES packing parsing */
+ case MPEGTS_PESHEADER:
+ len = PES_HEADER_SIZE - pes->data_index;
+ if (len < 0)
+ return -1;
+ if (len > buf_size)
+ len = buf_size;
+ memcpy(pes->header + pes->data_index, p, len);
+ pes->data_index += len;
+ p += len;
+ buf_size -= len;
+ if (pes->data_index == PES_HEADER_SIZE) {
+ pes->pes_header_size = pes->header[8] + 9;
+ pes->state = MPEGTS_PESHEADER_FILL;
+ }
+ break;
+ case MPEGTS_PESHEADER_FILL:
+ len = pes->pes_header_size - pes->data_index;
+ if (len < 0)
+ return -1;
+ if (len > buf_size)
+ len = buf_size;
+ memcpy(pes->header + pes->data_index, p, len);
+ pes->data_index += len;
+ p += len;
+ buf_size -= len;
+ if (pes->data_index == pes->pes_header_size) {
+ const uint8_t *r;
+ unsigned int flags, pes_ext, skip;
+
+ flags = pes->header[7];
+ r = pes->header + 9;
+ pes->pts = AV_NOPTS_VALUE;
+ pes->dts = AV_NOPTS_VALUE;
+ if ((flags & 0xc0) == 0x80) {
+ pes->dts = pes->pts = get_pts(r);
+ r += 5;
+ } else if ((flags & 0xc0) == 0xc0) {
+ pes->pts = get_pts(r);
+ r += 5;
+ pes->dts = get_pts(r);
+ r += 5;
+ }
+ pes->extended_stream_id = -1;
+ if (flags & 0x01) { /* PES extension */
+ pes_ext = *r++;
+ /* Skip PES private data, program packet sequence counter and P-STD buffer */
+ skip = (pes_ext >> 4) & 0xb;
+ skip += skip & 0x9;
+ r += skip;
+ if ((pes_ext & 0x41) == 0x01 &&
+ (r + 2) <= (pes->header + pes->pes_header_size)) {
+ /* PES extension 2 */
+ if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)
+ pes->extended_stream_id = r[1];
+ }
+ }
+
+ /* we got the full header. We parse it and get the payload */
+ pes->state = MPEGTS_PAYLOAD;
+ pes->data_index = 0;
+ }
+ break;
+ case MPEGTS_PAYLOAD:
+ if (buf_size > 0 && pes->buffer) {
+ if (pes->data_index+buf_size > pes->total_size) {
+ new_pes_packet(pes, ts->pkt);
+ pes->total_size = MAX_PES_PAYLOAD;
+ pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);
+ if (!pes->buffer)
+ return AVERROR(ENOMEM);
+ ts->stop_parse = 1;
+ }
+ memcpy(pes->buffer+pes->data_index, p, buf_size);
+ pes->data_index += buf_size;
+ }
+ buf_size = 0;
+ break;
+ case MPEGTS_SKIP:
+ buf_size = 0;
+ break;
+ }
+ }
+
+ return 0;
+}
+
+static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
+{
+ MpegTSFilter *tss;
+ PESContext *pes;
+
+ /* if no pid found, then add a pid context */
+ pes = av_mallocz(sizeof(PESContext));
+ if (!pes)
+ return 0;
+ pes->ts = ts;
+ pes->stream = ts->stream;
+ pes->pid = pid;
+ pes->pcr_pid = pcr_pid;
+ pes->state = MPEGTS_SKIP;
+ pes->pts = AV_NOPTS_VALUE;
+ pes->dts = AV_NOPTS_VALUE;
+ tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
+ if (!tss) {
+ av_free(pes);
+ return 0;
+ }
+ return pes;
+}
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
{
const uint8_t *p, *p_end, *desc_list_end, *desc_end;
int program_info_length, pcr_pid, pid, stream_type;
int desc_list_len, desc_len, desc_tag;
- int comp_page = 0, anc_page = 0; /* initialize to kill warnings */
- char language[4] = {0}; /* initialize to kill warnings */
- int has_hdmv_descr = 0;
- int has_dirac_descr = 0;
- uint32_t reg_desc = 0; /* registration descriptor */
+ int comp_page, anc_page;
+ char language[4];
+ uint32_t prog_reg_desc = 0; /* registration descriptor */
#ifdef DEBUG
dprintf(ts->stream, "PMT: len %i\n", section_len);
//something else is broken, exit the program_descriptors_loop
break;
program_info_length -= len + 2;
- if(tag == REGISTRATION_DESCRIPTOR && len >= 4) {
- reg_desc = bytestream_get_le32(&p);
+ if(tag == 0x05 && len >= 4) { // registration descriptor
+ prog_reg_desc = bytestream_get_le32(&p);
len -= 4;
- if(reg_desc == AV_RL32("HDMV"))
- has_hdmv_descr = 1;
}
p += len;
}
p += program_info_length;
if (p >= p_end)
return;
+
+ // stop parsing after pmt, we found header
+ if (!ts->stream->nb_streams)
+ ts->stop_parse = 1;
+
for(;;) {
- language[0] = 0;
st = 0;
stream_type = get8(&p, p_end);
if (stream_type < 0)
pid = get16(&p, p_end) & 0x1fff;
if (pid < 0)
break;
+
+ /* now create ffmpeg stream */
+ if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
+ pes = ts->pids[pid]->u.pes_filter.opaque;
+ st = pes->st;
+ } else {
+ if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably
+ pes = add_pes_stream(ts, pid, pcr_pid);
+ if (pes)
+ st = av_new_stream(pes->stream, pes->pid);
+ }
+
+ if (!st)
+ return;
+
+ if (!pes->stream_type)
+ mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc);
+
+ add_pid_to_pmt(ts, h->id, pid);
+
+ av_program_add_stream_index(ts->stream, h->id, st->index);
+
desc_list_len = get16(&p, p_end) & 0xfff;
if (desc_list_len < 0)
break;
desc_tag = get8(&p, desc_list_end);
if (desc_tag < 0)
break;
- if (stream_type == STREAM_TYPE_PRIVATE_DATA) {
- if((desc_tag == 0x6A) || (desc_tag == 0x7A)) {
- /*assume DVB AC-3 Audio*/
- stream_type = STREAM_TYPE_AUDIO_AC3;
- } else if(desc_tag == 0x7B) {
- /* DVB DTS audio */
- stream_type = STREAM_TYPE_AUDIO_DTS;
- }
- }
desc_len = get8(&p, desc_list_end);
if (desc_len < 0)
break;
dprintf(ts->stream, "tag: 0x%02x len=%d\n",
desc_tag, desc_len);
- switch(desc_tag) {
- case DVB_SUBT_DESCID:
- if (stream_type == STREAM_TYPE_PRIVATE_DATA)
- stream_type = STREAM_TYPE_SUBTITLE_DVB;
+ if (st->codec->codec_id == CODEC_ID_NONE &&
+ stream_type == STREAM_TYPE_PRIVATE_DATA)
+ mpegts_find_stream_type(st, desc_tag, DESC_types);
+ switch(desc_tag) {
+ case 0x56: /* DVB teletext descriptor */
+ language[0] = get8(&p, desc_end);
+ language[1] = get8(&p, desc_end);
+ language[2] = get8(&p, desc_end);
+ language[3] = 0;
+ av_metadata_set(&st->metadata, "language", language);
+ break;
+ case 0x59: /* subtitling descriptor */
language[0] = get8(&p, desc_end);
language[1] = get8(&p, desc_end);
language[2] = get8(&p, desc_end);
get8(&p, desc_end);
comp_page = get16(&p, desc_end);
anc_page = get16(&p, desc_end);
-
+ st->codec->sub_id = (anc_page << 16) | comp_page;
+ av_metadata_set(&st->metadata, "language", language);
break;
case 0x0a: /* ISO 639 language descriptor */
language[0] = get8(&p, desc_end);
language[1] = get8(&p, desc_end);
language[2] = get8(&p, desc_end);
language[3] = 0;
+ av_metadata_set(&st->metadata, "language", language);
break;
- case REGISTRATION_DESCRIPTOR: /*MPEG-2 Registration descriptor */
- reg_desc = bytestream_get_le32(&p);
- if(reg_desc == AV_RL32("drac"))
- has_dirac_descr = 1;
- else if(reg_desc == AV_RL32("AC-3"))
- stream_type = STREAM_TYPE_AUDIO_AC3;
+ case 0x05: /* registration descriptor */
+ st->codec->codec_tag = bytestream_get_le32(&p);
+ dprintf(ts->stream, "reg_desc=%.4s\n", (char*)&st->codec->codec_tag);
+ if (st->codec->codec_id == CODEC_ID_NONE &&
+ stream_type == STREAM_TYPE_PRIVATE_DATA)
+ mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types);
break;
default:
break;
}
p = desc_end;
- }
- p = desc_list_end;
- dprintf(ts->stream, "stream_type=%x pid=0x%x\n",
- stream_type, pid);
-
- /* now create ffmpeg stream */
- switch(stream_type) {
- case STREAM_TYPE_AUDIO_MPEG1:
- case STREAM_TYPE_AUDIO_MPEG2:
- case STREAM_TYPE_VIDEO_MPEG1:
- case STREAM_TYPE_VIDEO_MPEG2:
- case STREAM_TYPE_VIDEO_MPEG4:
- case STREAM_TYPE_VIDEO_H264:
- case STREAM_TYPE_VIDEO_VC1:
- case STREAM_TYPE_VIDEO_DIRAC:
- case STREAM_TYPE_AUDIO_AAC:
- case STREAM_TYPE_AUDIO_AC3:
- case STREAM_TYPE_AUDIO_DTS:
- case STREAM_TYPE_AUDIO_HDMV_DTS:
- case STREAM_TYPE_SUBTITLE_DVB:
- if((stream_type == STREAM_TYPE_AUDIO_HDMV_DTS && !has_hdmv_descr)
- || (stream_type == STREAM_TYPE_VIDEO_DIRAC && !has_dirac_descr))
- break;
- if(ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES){
- pes= ts->pids[pid]->u.pes_filter.opaque;
- st= pes->st;
- }else{
- if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably
- pes = add_pes_stream(ts, pid, pcr_pid, stream_type);
- if (pes)
- st = new_pes_av_stream(pes, 0);
- }
- add_pid_to_pmt(ts, h->id, pid);
- if(st)
- av_program_add_stream_index(ts->stream, h->id, st->index);
- break;
- default:
- /* we ignore the other streams */
- break;
- }
-
- if (st) {
- if (language[0] != 0) {
- av_metadata_set(&st->metadata, "language", language);
- }
-
- if (stream_type == STREAM_TYPE_SUBTITLE_DVB) {
- st->codec->sub_id = (anc_page << 16) | comp_page;
+ if (prog_reg_desc == AV_RL32("HDMV") && stream_type == 0x83 && pes->sub_st) {
+ av_program_add_stream_index(ts->stream, h->id, pes->sub_st->index);
+ pes->sub_st->codec->codec_tag = st->codec->codec_tag;
}
}
+ p = desc_list_end;
}
/* all parameters are there */
- ts->stop_parse++;
mpegts_close_filter(ts, filter);
}
/* NIT info */
} else {
av_new_program(ts->stream, sid);
- ts->stop_parse--;
mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
add_pat_entry(ts, sid);
add_pid_to_pmt(ts, sid, 0); //add pat pid to program
add_pid_to_pmt(ts, sid, pmt_pid);
}
}
- /* not found */
- ts->stop_parse++;
-
- mpegts_close_filter(ts, filter);
}
static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
}
}
-static int64_t get_pts(const uint8_t *p)
-{
- int64_t pts = (int64_t)((p[0] >> 1) & 0x07) << 30;
- pts |= (AV_RB16(p + 1) >> 1) << 15;
- pts |= AV_RB16(p + 3) >> 1;
- return pts;
-}
-
-static void new_pes_packet(PESContext *pes, AVPacket *pkt)
-{
- av_init_packet(pkt);
-
- pkt->destruct = av_destruct_packet;
- pkt->data = pes->buffer;
- pkt->size = pes->data_index;
- memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
-
- pkt->stream_index = pes->st->index;
- pkt->pts = pes->pts;
- pkt->dts = pes->dts;
- /* store position of first TS packet of this PES packet */
- pkt->pos = pes->ts_packet_pos;
-
- /* reset pts values */
- pes->pts = AV_NOPTS_VALUE;
- pes->dts = AV_NOPTS_VALUE;
- pes->buffer = NULL;
- pes->data_index = 0;
-}
-
-/* return non zero if a packet could be constructed */
-static void mpegts_push_data(MpegTSFilter *filter,
- const uint8_t *buf, int buf_size, int is_start,
- int64_t pos)
-{
- PESContext *pes = filter->u.pes_filter.opaque;
- MpegTSContext *ts = pes->ts;
- const uint8_t *p;
- int len, code;
-
- if(!ts->pkt)
- return;
-
- if (is_start) {
- if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
- new_pes_packet(pes, ts->pkt);
- ts->stop_parse = 1;
- }
- pes->state = MPEGTS_HEADER;
- pes->data_index = 0;
- pes->ts_packet_pos = pos;
- }
- p = buf;
- while (buf_size > 0) {
- switch(pes->state) {
- case MPEGTS_HEADER:
- len = PES_START_SIZE - pes->data_index;
- if (len > buf_size)
- len = buf_size;
- memcpy(pes->header + pes->data_index, p, len);
- pes->data_index += len;
- p += len;
- buf_size -= len;
- if (pes->data_index == PES_START_SIZE) {
- /* we got all the PES or section header. We can now
- decide */
-#if 0
- av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index);
-#endif
- if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
- pes->header[2] == 0x01) {
- /* it must be an mpeg2 PES stream */
- code = pes->header[3] | 0x100;
- if (!pes->st ||
- !((code >= 0x1c0 && code <= 0x1df) ||
- (code >= 0x1e0 && code <= 0x1ef) ||
- (code == 0x1bd) || (code == 0x1fd)))
- goto skip;
- pes->state = MPEGTS_PESHEADER_FILL;
- pes->total_size = AV_RB16(pes->header + 4);
- /* NOTE: a zero total size means the PES size is
- unbounded */
- pes->pes_header_size = pes->header[8] + 9;
- } else {
- /* otherwise, it should be a table */
- /* skip packet */
- skip:
- pes->state = MPEGTS_SKIP;
- continue;
- }
- }
- break;
- /**********************************************/
- /* PES packing parsing */
- case MPEGTS_PESHEADER_FILL:
- len = pes->pes_header_size - pes->data_index;
- if (len < 0)
- return;
- if (len > buf_size)
- len = buf_size;
- memcpy(pes->header + pes->data_index, p, len);
- pes->data_index += len;
- p += len;
- buf_size -= len;
- if (pes->data_index == pes->pes_header_size) {
- const uint8_t *r;
- unsigned int flags;
-
- flags = pes->header[7];
- r = pes->header + 9;
- pes->pts = AV_NOPTS_VALUE;
- pes->dts = AV_NOPTS_VALUE;
- if ((flags & 0xc0) == 0x80) {
- pes->dts = pes->pts = get_pts(r);
- r += 5;
- } else if ((flags & 0xc0) == 0xc0) {
- pes->pts = get_pts(r);
- r += 5;
- pes->dts = get_pts(r);
- r += 5;
- }
-
- if (pes->total_size > pes->data_index - 6)
- pes->total_size -= pes->data_index - 6;
- else
- pes->total_size = MAX_PES_PAYLOAD;
- /* allocate pes buffer */
- pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);
- if (!pes->buffer)
- return;
-
- /* we got the full header. We parse it and get the payload */
- pes->state = MPEGTS_PAYLOAD;
- pes->data_index = 0;
- }
- break;
- case MPEGTS_PAYLOAD:
- if (buf_size > 0) {
- if (pes->data_index+buf_size > pes->total_size) {
- new_pes_packet(pes, ts->pkt);
- pes->total_size = MAX_PES_PAYLOAD;
- pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE);
- if (!pes->buffer)
- return;
- ts->stop_parse = 1;
- }
- memcpy(pes->buffer+pes->data_index, p, buf_size);
- pes->data_index += buf_size;
- }
- buf_size = 0;
- break;
- case MPEGTS_SKIP:
- buf_size = 0;
- break;
- }
- }
-}
-
-static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code)
-{
- AVStream *st;
- enum CodecID codec_id;
- enum CodecType codec_type;
-
- switch(pes->stream_type){
- case STREAM_TYPE_AUDIO_MPEG1:
- case STREAM_TYPE_AUDIO_MPEG2:
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_MP3;
- break;
- case STREAM_TYPE_VIDEO_MPEG1:
- case STREAM_TYPE_VIDEO_MPEG2:
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_MPEG2VIDEO;
- break;
- case STREAM_TYPE_VIDEO_MPEG4:
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_MPEG4;
- break;
- case STREAM_TYPE_VIDEO_H264:
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_H264;
- break;
- case STREAM_TYPE_VIDEO_VC1:
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_VC1;
- break;
- case STREAM_TYPE_VIDEO_DIRAC:
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_DIRAC;
- break;
- case STREAM_TYPE_AUDIO_AAC:
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_AAC;
- break;
- case STREAM_TYPE_AUDIO_AC3:
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_AC3;
- break;
- case STREAM_TYPE_AUDIO_DTS:
- case STREAM_TYPE_AUDIO_HDMV_DTS:
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_DTS;
- break;
- case STREAM_TYPE_SUBTITLE_DVB:
- codec_type = CODEC_TYPE_SUBTITLE;
- codec_id = CODEC_ID_DVB_SUBTITLE;
- break;
- default:
- if (code >= 0x1c0 && code <= 0x1df) {
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_MP2;
- } else if (code == 0x1bd) {
- codec_type = CODEC_TYPE_AUDIO;
- codec_id = CODEC_ID_AC3;
- } else {
- codec_type = CODEC_TYPE_VIDEO;
- codec_id = CODEC_ID_PROBE;
- }
- break;
- }
- st = av_new_stream(pes->stream, pes->pid);
- if (st) {
- av_set_pts_info(st, 33, 1, 90000);
- st->priv_data = pes;
- st->codec->codec_type = codec_type;
- st->codec->codec_id = codec_id;
- st->need_parsing = AVSTREAM_PARSE_FULL;
- pes->st = st;
- }
- return st;
-}
-
-
-static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type)
-{
- MpegTSFilter *tss;
- PESContext *pes;
-
- /* if no pid found, then add a pid context */
- pes = av_mallocz(sizeof(PESContext));
- if (!pes)
- return 0;
- pes->ts = ts;
- pes->stream = ts->stream;
- pes->pid = pid;
- pes->pcr_pid = pcr_pid;
- pes->stream_type = stream_type;
- tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
- if (!tss) {
- av_free(pes);
- return 0;
- }
- return pes;
-}
-
/* handle one TS packet */
-static void handle_packet(MpegTSContext *ts, const uint8_t *packet)
+static int handle_packet(MpegTSContext *ts, const uint8_t *packet)
{
AVFormatContext *s = ts->stream;
MpegTSFilter *tss;
pid = AV_RB16(packet + 1) & 0x1fff;
if(pid && discard_pid(ts, pid))
- return;
+ return 0;
is_start = packet[1] & 0x40;
tss = ts->pids[pid];
if (ts->auto_guess && tss == NULL && is_start) {
- add_pes_stream(ts, pid, -1, 0);
+ add_pes_stream(ts, pid, -1);
tss = ts->pids[pid];
}
if (!tss)
- return;
+ return 0;
/* continuity check (currently not used) */
cc = (packet[3] & 0xf);
afc = (packet[3] >> 4) & 3;
p = packet + 4;
if (afc == 0) /* reserved value */
- return;
+ return 0;
if (afc == 2) /* adaptation field only */
- return;
+ return 0;
if (afc == 3) {
/* skip adapation field */
p += p[0] + 1;
/* if past the end of packet, ignore */
p_end = packet + TS_PACKET_SIZE;
if (p >= p_end)
- return;
+ return 0;
pos = url_ftell(ts->stream->pb);
ts->pos47= pos % ts->raw_packet_size;
/* pointer field present */
len = *p++;
if (p + len > p_end)
- return;
+ return 0;
if (len && cc_ok) {
/* write remaining section bytes */
write_section_data(s, tss,
p, len, 0);
/* check whether filter has been closed */
if (!ts->pids[pid])
- return;
+ return 0;
}
p += len;
if (p < p_end) {
}
}
} else {
+ int ret;
// Note: The position here points actually behind the current packet.
- tss->u.pes_filter.pes_cb(tss,
- p, p_end - p, is_start, pos - ts->raw_packet_size);
+ if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
+ pos - ts->raw_packet_size)) < 0)
+ return ret;
}
+
+ return 0;
}
/* XXX: try to find a better synchro over several packets (use
get_packet_size() ?) */
-static int mpegts_resync(ByteIOContext *pb)
+static int mpegts_resync(AVFormatContext *s)
{
+ ByteIOContext *pb = s->pb;
int c, i;
for(i = 0;i < MAX_RESYNC_SIZE; i++) {
return 0;
}
}
+ av_log(s, AV_LOG_ERROR, "max resync size reached, could not find sync byte\n");
/* no sync found */
return -1;
}
/* return -1 if error or EOF. Return 0 if OK. */
-static int read_packet(ByteIOContext *pb, uint8_t *buf, int raw_packet_size)
+static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size)
{
+ ByteIOContext *pb = s->pb;
int skip, len;
for(;;) {
if (buf[0] != 0x47) {
/* find a new packet start */
url_fseek(pb, -TS_PACKET_SIZE, SEEK_CUR);
- if (mpegts_resync(pb) < 0)
- return AVERROR_INVALIDDATA;
+ if (mpegts_resync(s) < 0)
+ return AVERROR(EAGAIN);
else
continue;
} else {
static int handle_packets(MpegTSContext *ts, int nb_packets)
{
AVFormatContext *s = ts->stream;
- ByteIOContext *pb = s->pb;
uint8_t packet[TS_PACKET_SIZE];
int packet_num, ret;
packet_num++;
if (nb_packets != 0 && packet_num >= nb_packets)
break;
- ret = read_packet(pb, packet, ts->raw_packet_size);
+ ret = read_packet(s, packet, ts->raw_packet_size);
+ if (ret != 0)
+ return ret;
+ ret = handle_packet(ts, packet);
if (ret != 0)
return ret;
- handle_packet(ts, packet);
}
return 0;
}
mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);
- handle_packets(ts, s->probesize);
+ handle_packets(ts, s->probesize / ts->raw_packet_size);
/* if could not find service, enable auto_guess */
ts->auto_guess = 1;
nb_pcrs = 0;
nb_packets = 0;
for(;;) {
- ret = read_packet(s->pb, packet, ts->raw_packet_size);
+ ret = read_packet(s, packet, ts->raw_packet_size);
if (ret < 0)
return -1;
pid = AV_RB16(packet + 1) & 0x1fff;
if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
return AVERROR(ENOMEM);
pkt->pos= url_ftell(s->pb);
- ret = read_packet(s->pb, pkt->data, ts->raw_packet_size);
+ ret = read_packet(s, pkt->data, ts->raw_packet_size);
if (ret < 0) {
av_free_packet(pkt);
return ret;
PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
new_pes_packet(pes, pkt);
+ pes->state = MPEGTS_SKIP;
ret = 0;
break;
}
return timestamp;
}
+#ifdef USE_SYNCPOINT_SEARCH
+
+static int read_seek2(AVFormatContext *s,
+ int stream_index,
+ int64_t min_ts,
+ int64_t target_ts,
+ int64_t max_ts,
+ int flags)
+{
+ int64_t pos;
+
+ int64_t ts_ret, ts_adj;
+ int stream_index_gen_search;
+ AVStream *st;
+ AVParserState *backup;
+
+ backup = ff_store_parser_state(s);
+
+ // detect direction of seeking for search purposes
+ flags |= (target_ts - min_ts > (uint64_t)(max_ts - target_ts)) ?
+ AVSEEK_FLAG_BACKWARD : 0;
+
+ if (flags & AVSEEK_FLAG_BYTE) {
+ // use position directly, we will search starting from it
+ pos = target_ts;
+ } else {
+ // search for some position with good timestamp match
+ if (stream_index < 0) {
+ stream_index_gen_search = av_find_default_stream_index(s);
+ if (stream_index_gen_search < 0) {
+ ff_restore_parser_state(s, backup);
+ return -1;
+ }
+
+ st = s->streams[stream_index_gen_search];
+ // timestamp for default must be expressed in AV_TIME_BASE units
+ ts_adj = av_rescale(target_ts,
+ st->time_base.den,
+ AV_TIME_BASE * (int64_t)st->time_base.num);
+ } else {
+ ts_adj = target_ts;
+ stream_index_gen_search = stream_index;
+ }
+ pos = av_gen_search(s, stream_index_gen_search, ts_adj,
+ 0, INT64_MAX, -1,
+ AV_NOPTS_VALUE,
+ AV_NOPTS_VALUE,
+ flags, &ts_ret, mpegts_get_pcr);
+ if (pos < 0) {
+ ff_restore_parser_state(s, backup);
+ return -1;
+ }
+ }
+
+ // search for actual matching keyframe/starting position for all streams
+ if (ff_gen_syncpoint_search(s, stream_index, pos,
+ min_ts, target_ts, max_ts,
+ flags) < 0) {
+ ff_restore_parser_state(s, backup);
+ return -1;
+ }
+
+ ff_free_parser_state(s, backup);
+ return 0;
+}
+
+static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
+{
+ int ret;
+ if (flags & AVSEEK_FLAG_BACKWARD) {
+ flags &= ~AVSEEK_FLAG_BACKWARD;
+ ret = read_seek2(s, stream_index, INT64_MIN, target_ts, target_ts, flags);
+ if (ret < 0)
+ // for compatibility reasons, seek to the best-fitting timestamp
+ ret = read_seek2(s, stream_index, INT64_MIN, target_ts, INT64_MAX, flags);
+ } else {
+ ret = read_seek2(s, stream_index, target_ts, target_ts, INT64_MAX, flags);
+ if (ret < 0)
+ // for compatibility reasons, seek to the best-fitting timestamp
+ ret = read_seek2(s, stream_index, INT64_MIN, target_ts, INT64_MAX, flags);
+ }
+ return ret;
+}
+
+#else
+
static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
MpegTSContext *ts = s->priv_data;
uint8_t buf[TS_PACKET_SIZE];
return 0;
}
+#endif
+
/**************************************************************/
/* parsing functions - called from other demuxers such as RTP */
-MpegTSContext *mpegts_parse_open(AVFormatContext *s)
+MpegTSContext *ff_mpegts_parse_open(AVFormatContext *s)
{
MpegTSContext *ts;
/* return the consumed length if a packet was output, or -1 if no
packet is output */
-int mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt,
+int ff_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt,
const uint8_t *buf, int len)
{
int len1;
return len1 - len;
}
-void mpegts_parse_close(MpegTSContext *ts)
+void ff_mpegts_parse_close(MpegTSContext *ts)
{
int i;
read_seek,
mpegts_get_pcr,
.flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
+#ifdef USE_SYNCPOINT_SEARCH
+ .read_seek2 = read_seek2,
+#endif
};
AVInputFormat mpegtsraw_demuxer = {
read_seek,
mpegts_get_pcr,
.flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
+#ifdef USE_SYNCPOINT_SEARCH
+ .read_seek2 = read_seek2,
+#endif
};
projects / ffmpeg / blobdiff