mpegts.c
Go to the documentation of this file.
1 /*
2  * MPEG2 transport stream (aka DVB) demuxer
3  * Copyright (c) 2002-2003 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/crc.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/log.h"
25 #include "libavutil/dict.h"
26 #include "libavutil/mathematics.h"
27 #include "libavutil/opt.h"
28 #include "libavcodec/bytestream.h"
29 #include "libavcodec/get_bits.h"
30 #include "avformat.h"
31 #include "mpegts.h"
32 #include "internal.h"
33 #include "avio_internal.h"
34 #include "seek.h"
35 #include "mpeg.h"
36 #include "isom.h"
37 
38 /* maximum size in which we look for synchronisation if
39  synchronisation is lost */
40 #define MAX_RESYNC_SIZE 65536
41 
42 #define MAX_PES_PAYLOAD 200*1024
43 
44 #define MAX_MP4_DESCR_COUNT 16
45 
49 };
50 
51 typedef struct MpegTSFilter MpegTSFilter;
52 
53 typedef int PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos);
54 
55 typedef struct MpegTSPESFilter {
57  void *opaque;
59 
60 typedef void SectionCallback(MpegTSFilter *f, const uint8_t *buf, int len);
61 
62 typedef void SetServiceCallback(void *opaque, int ret);
63 
64 typedef struct MpegTSSectionFilter {
68  unsigned int check_crc:1;
69  unsigned int end_of_section_reached:1;
71  void *opaque;
73 
74 struct MpegTSFilter {
75  int pid;
76  int es_id;
77  int last_cc; /* last cc code (-1 if first packet) */
79  union {
82  } u;
83 };
84 
85 #define MAX_PIDS_PER_PROGRAM 64
86 struct Program {
87  unsigned int id; //program id/service id
88  unsigned int nb_pids;
89  unsigned int pids[MAX_PIDS_PER_PROGRAM];
90 };
91 
92 struct MpegTSContext {
93  const AVClass *class;
94  /* user data */
98 
99  int pos47;
100 
103 
106 
107  int64_t cur_pcr;
108  int pcr_incr;
110  /* data needed to handle file based ts */
116  int64_t last_pos;
117 
118  /******************************************/
119  /* private mpegts data */
120  /* scan context */
122  unsigned int nb_prg;
123  struct Program *prg;
124 
125 
128 };
129 
130 static const AVOption options[] = {
131  {"compute_pcr", "Compute exact PCR for each transport stream packet.", offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_INT,
132  {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
133  { NULL },
134 };
135 
136 static const AVClass mpegtsraw_class = {
137  .class_name = "mpegtsraw demuxer",
138  .item_name = av_default_item_name,
139  .option = options,
140  .version = LIBAVUTIL_VERSION_INT,
141 };
142 
143 /* TS stream handling */
144 
151 };
152 
153 /* enough for PES header + length */
154 #define PES_START_SIZE 6
155 #define PES_HEADER_SIZE 9
156 #define MAX_PES_HEADER_SIZE (9 + 255)
157 
158 typedef struct PESContext {
159  int pid;
160  int pcr_pid;
167  /* used to get the format */
169  int flags;
173  int64_t pts, dts;
174  int64_t ts_packet_pos;
178 } PESContext;
179 
181 
182 static void clear_program(MpegTSContext *ts, unsigned int programid)
183 {
184  int i;
185 
186  for(i=0; i<ts->nb_prg; i++)
187  if(ts->prg[i].id == programid)
188  ts->prg[i].nb_pids = 0;
189 }
190 
192 {
193  av_freep(&ts->prg);
194  ts->nb_prg=0;
195 }
196 
197 static void add_pat_entry(MpegTSContext *ts, unsigned int programid)
198 {
199  struct Program *p;
200  void *tmp = av_realloc(ts->prg, (ts->nb_prg+1)*sizeof(struct Program));
201  if(!tmp)
202  return;
203  ts->prg = tmp;
204  p = &ts->prg[ts->nb_prg];
205  p->id = programid;
206  p->nb_pids = 0;
207  ts->nb_prg++;
208 }
209 
210 static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned int pid)
211 {
212  int i;
213  struct Program *p = NULL;
214  for(i=0; i<ts->nb_prg; i++) {
215  if(ts->prg[i].id == programid) {
216  p = &ts->prg[i];
217  break;
218  }
219  }
220  if(!p)
221  return;
222 
223  if(p->nb_pids >= MAX_PIDS_PER_PROGRAM)
224  return;
225  p->pids[p->nb_pids++] = pid;
226 }
227 
236 static int discard_pid(MpegTSContext *ts, unsigned int pid)
237 {
238  int i, j, k;
239  int used = 0, discarded = 0;
240  struct Program *p;
241  for(i=0; i<ts->nb_prg; i++) {
242  p = &ts->prg[i];
243  for(j=0; j<p->nb_pids; j++) {
244  if(p->pids[j] != pid)
245  continue;
246  //is program with id p->id set to be discarded?
247  for(k=0; k<ts->stream->nb_programs; k++) {
248  if(ts->stream->programs[k]->id == p->id) {
249  if(ts->stream->programs[k]->discard == AVDISCARD_ALL)
250  discarded++;
251  else
252  used++;
253  }
254  }
255  }
256  }
257 
258  return !used && discarded;
259 }
260 
266  const uint8_t *buf, int buf_size, int is_start)
267 {
268  MpegTSSectionFilter *tss = &tss1->u.section_filter;
269  int len;
270 
271  if (is_start) {
272  memcpy(tss->section_buf, buf, buf_size);
273  tss->section_index = buf_size;
274  tss->section_h_size = -1;
275  tss->end_of_section_reached = 0;
276  } else {
277  if (tss->end_of_section_reached)
278  return;
279  len = 4096 - tss->section_index;
280  if (buf_size < len)
281  len = buf_size;
282  memcpy(tss->section_buf + tss->section_index, buf, len);
283  tss->section_index += len;
284  }
285 
286  /* compute section length if possible */
287  if (tss->section_h_size == -1 && tss->section_index >= 3) {
288  len = (AV_RB16(tss->section_buf + 1) & 0xfff) + 3;
289  if (len > 4096)
290  return;
291  tss->section_h_size = len;
292  }
293 
294  if (tss->section_h_size != -1 && tss->section_index >= tss->section_h_size) {
295  tss->end_of_section_reached = 1;
296  if (!tss->check_crc ||
298  tss->section_buf, tss->section_h_size) == 0)
299  tss->section_cb(tss1, tss->section_buf, tss->section_h_size);
300  }
301 }
302 
304  SectionCallback *section_cb, void *opaque,
305  int check_crc)
306 
307 {
309  MpegTSSectionFilter *sec;
310 
311  av_dlog(ts->stream, "Filter: pid=0x%x\n", pid);
312 
313  if (pid >= NB_PID_MAX || ts->pids[pid])
314  return NULL;
315  filter = av_mallocz(sizeof(MpegTSFilter));
316  if (!filter)
317  return NULL;
318  ts->pids[pid] = filter;
319  filter->type = MPEGTS_SECTION;
320  filter->pid = pid;
321  filter->es_id = -1;
322  filter->last_cc = -1;
323  sec = &filter->u.section_filter;
324  sec->section_cb = section_cb;
325  sec->opaque = opaque;
327  sec->check_crc = check_crc;
328  if (!sec->section_buf) {
329  av_free(filter);
330  return NULL;
331  }
332  return filter;
333 }
334 
335 static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
336  PESCallback *pes_cb,
337  void *opaque)
338 {
340  MpegTSPESFilter *pes;
341 
342  if (pid >= NB_PID_MAX || ts->pids[pid])
343  return NULL;
344  filter = av_mallocz(sizeof(MpegTSFilter));
345  if (!filter)
346  return NULL;
347  ts->pids[pid] = filter;
348  filter->type = MPEGTS_PES;
349  filter->pid = pid;
350  filter->es_id = -1;
351  filter->last_cc = -1;
352  pes = &filter->u.pes_filter;
353  pes->pes_cb = pes_cb;
354  pes->opaque = opaque;
355  return filter;
356 }
357 
359 {
360  int pid;
361 
362  pid = filter->pid;
363  if (filter->type == MPEGTS_SECTION)
365  else if (filter->type == MPEGTS_PES) {
366  PESContext *pes = filter->u.pes_filter.opaque;
367  av_freep(&pes->buffer);
368  /* referenced private data will be freed later in
369  * avformat_close_input */
370  if (!((PESContext *)filter->u.pes_filter.opaque)->st) {
371  av_freep(&filter->u.pes_filter.opaque);
372  }
373  }
374 
375  av_free(filter);
376  ts->pids[pid] = NULL;
377 }
378 
379 static int analyze(const uint8_t *buf, int size, int packet_size, int *index){
380  int stat[TS_MAX_PACKET_SIZE];
381  int i;
382  int x=0;
383  int best_score=0;
384 
385  memset(stat, 0, packet_size*sizeof(int));
386 
387  for(x=i=0; i<size-3; i++){
388  if(buf[i] == 0x47 && !(buf[i+1] & 0x80) && (buf[i+3] & 0x30)){
389  stat[x]++;
390  if(stat[x] > best_score){
391  best_score= stat[x];
392  if(index) *index= x;
393  }
394  }
395 
396  x++;
397  if(x == packet_size) x= 0;
398  }
399 
400  return best_score;
401 }
402 
403 /* autodetect fec presence. Must have at least 1024 bytes */
404 static int get_packet_size(const uint8_t *buf, int size)
405 {
406  int score, fec_score, dvhs_score;
407 
408  if (size < (TS_FEC_PACKET_SIZE * 5 + 1))
409  return -1;
410 
411  score = analyze(buf, size, TS_PACKET_SIZE, NULL);
412  dvhs_score = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL);
413  fec_score= analyze(buf, size, TS_FEC_PACKET_SIZE, NULL);
414  av_dlog(NULL, "score: %d, dvhs_score: %d, fec_score: %d \n",
415  score, dvhs_score, fec_score);
416 
417  if (score > fec_score && score > dvhs_score) return TS_PACKET_SIZE;
418  else if(dvhs_score > score && dvhs_score > fec_score) return TS_DVHS_PACKET_SIZE;
419  else if(score < fec_score && dvhs_score < fec_score) return TS_FEC_PACKET_SIZE;
420  else return -1;
421 }
422 
423 typedef struct SectionHeader {
425  uint16_t id;
429 } SectionHeader;
430 
431 static inline int get8(const uint8_t **pp, const uint8_t *p_end)
432 {
433  const uint8_t *p;
434  int c;
435 
436  p = *pp;
437  if (p >= p_end)
438  return -1;
439  c = *p++;
440  *pp = p;
441  return c;
442 }
443 
444 static inline int get16(const uint8_t **pp, const uint8_t *p_end)
445 {
446  const uint8_t *p;
447  int c;
448 
449  p = *pp;
450  if ((p + 1) >= p_end)
451  return -1;
452  c = AV_RB16(p);
453  p += 2;
454  *pp = p;
455  return c;
456 }
457 
458 /* read and allocate a DVB string preceded by its length */
459 static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
460 {
461  int len;
462  const uint8_t *p;
463  char *str;
464 
465  p = *pp;
466  len = get8(&p, p_end);
467  if (len < 0)
468  return NULL;
469  if ((p + len) > p_end)
470  return NULL;
471  str = av_malloc(len + 1);
472  if (!str)
473  return NULL;
474  memcpy(str, p, len);
475  str[len] = '\0';
476  p += len;
477  *pp = p;
478  return str;
479 }
480 
482  const uint8_t **pp, const uint8_t *p_end)
483 {
484  int val;
485 
486  val = get8(pp, p_end);
487  if (val < 0)
488  return -1;
489  h->tid = val;
490  *pp += 2;
491  val = get16(pp, p_end);
492  if (val < 0)
493  return -1;
494  h->id = val;
495  val = get8(pp, p_end);
496  if (val < 0)
497  return -1;
498  h->version = (val >> 1) & 0x1f;
499  val = get8(pp, p_end);
500  if (val < 0)
501  return -1;
502  h->sec_num = val;
503  val = get8(pp, p_end);
504  if (val < 0)
505  return -1;
506  h->last_sec_num = val;
507  return 0;
508 }
509 
510 typedef struct {
511  uint32_t stream_type;
514 } StreamType;
515 
516 static const StreamType ISO_types[] = {
523  { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM }, /* LATM syntax */
527  { 0 },
528 };
529 
530 static const StreamType HDMV_types[] = {
536  { 0x85, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD */
537  { 0x86, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD MASTER*/
539  { 0 },
540 };
541 
542 /* ATSC ? */
543 static const StreamType MISC_types[] = {
546  { 0 },
547 };
548 
549 static const StreamType REGD_types[] = {
550  { MKTAG('d','r','a','c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
551  { MKTAG('A','C','-','3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
552  { MKTAG('B','S','S','D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M },
553  { MKTAG('D','T','S','1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
554  { MKTAG('D','T','S','2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
555  { MKTAG('D','T','S','3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
556  { MKTAG('V','C','-','1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },
557  { 0 },
558 };
559 
560 /* descriptor present */
561 static const StreamType DESC_types[] = {
562  { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */
563  { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
566  { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
567  { 0 },
568 };
569 
571  uint32_t stream_type, const StreamType *types)
572 {
573  for (; types->stream_type; types++) {
574  if (stream_type == types->stream_type) {
575  st->codec->codec_type = types->codec_type;
576  st->codec->codec_id = types->codec_id;
577  return;
578  }
579  }
580 }
581 
583  uint32_t stream_type, uint32_t prog_reg_desc)
584 {
585  avpriv_set_pts_info(st, 33, 1, 90000);
586  st->priv_data = pes;
590  pes->st = st;
591  pes->stream_type = stream_type;
592 
593  av_log(pes->stream, AV_LOG_DEBUG,
594  "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
595  st->index, pes->stream_type, pes->pid, (char*)&prog_reg_desc);
596 
597  st->codec->codec_tag = pes->stream_type;
598 
599  mpegts_find_stream_type(st, pes->stream_type, ISO_types);
600  if (prog_reg_desc == AV_RL32("HDMV") &&
601  st->codec->codec_id == AV_CODEC_ID_NONE) {
602  mpegts_find_stream_type(st, pes->stream_type, HDMV_types);
603  if (pes->stream_type == 0x83) {
604  // HDMV TrueHD streams also contain an AC3 coded version of the
605  // audio track - add a second stream for this
606  AVStream *sub_st;
607  // priv_data cannot be shared between streams
608  PESContext *sub_pes = av_malloc(sizeof(*sub_pes));
609  if (!sub_pes)
610  return AVERROR(ENOMEM);
611  memcpy(sub_pes, pes, sizeof(*sub_pes));
612 
613  sub_st = avformat_new_stream(pes->stream, NULL);
614  if (!sub_st) {
615  av_free(sub_pes);
616  return AVERROR(ENOMEM);
617  }
618 
619  sub_st->id = pes->pid;
620  avpriv_set_pts_info(sub_st, 33, 1, 90000);
621  sub_st->priv_data = sub_pes;
623  sub_st->codec->codec_id = AV_CODEC_ID_AC3;
625  sub_pes->sub_st = pes->sub_st = sub_st;
626  }
627  }
628  if (st->codec->codec_id == AV_CODEC_ID_NONE)
629  mpegts_find_stream_type(st, pes->stream_type, MISC_types);
630 
631  return 0;
632 }
633 
634 static void new_pes_packet(PESContext *pes, AVPacket *pkt)
635 {
636  av_init_packet(pkt);
637 
639  pkt->data = pes->buffer;
640  pkt->size = pes->data_index;
641 
642  if(pes->total_size != MAX_PES_PAYLOAD &&
643  pes->pes_header_size + pes->data_index != pes->total_size + PES_START_SIZE) {
644  av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n");
645  pes->flags |= AV_PKT_FLAG_CORRUPT;
646  }
647  memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
648 
649  // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
650  if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76)
651  pkt->stream_index = pes->sub_st->index;
652  else
653  pkt->stream_index = pes->st->index;
654  pkt->pts = pes->pts;
655  pkt->dts = pes->dts;
656  /* store position of first TS packet of this PES packet */
657  pkt->pos = pes->ts_packet_pos;
658  pkt->flags = pes->flags;
659 
660  /* reset pts values */
661  pes->pts = AV_NOPTS_VALUE;
662  pes->dts = AV_NOPTS_VALUE;
663  pes->buffer = NULL;
664  pes->data_index = 0;
665  pes->flags = 0;
666 }
667 
668 static int read_sl_header(PESContext *pes, SLConfigDescr *sl, const uint8_t *buf, int buf_size)
669 {
670  GetBitContext gb;
671  int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;
672  int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;
673  int dts_flag = -1, cts_flag = -1;
674  int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE;
675  init_get_bits(&gb, buf, buf_size*8);
676 
677  if (sl->use_au_start)
678  au_start_flag = get_bits1(&gb);
679  if (sl->use_au_end)
680  au_end_flag = get_bits1(&gb);
681  if (!sl->use_au_start && !sl->use_au_end)
682  au_start_flag = au_end_flag = 1;
683  if (sl->ocr_len > 0)
684  ocr_flag = get_bits1(&gb);
685  if (sl->use_idle)
686  idle_flag = get_bits1(&gb);
687  if (sl->use_padding)
688  padding_flag = get_bits1(&gb);
689  if (padding_flag)
690  padding_bits = get_bits(&gb, 3);
691 
692  if (!idle_flag && (!padding_flag || padding_bits != 0)) {
693  if (sl->packet_seq_num_len)
695  if (sl->degr_prior_len)
696  if (get_bits1(&gb))
697  skip_bits(&gb, sl->degr_prior_len);
698  if (ocr_flag)
699  skip_bits_long(&gb, sl->ocr_len);
700  if (au_start_flag) {
701  if (sl->use_rand_acc_pt)
702  get_bits1(&gb);
703  if (sl->au_seq_num_len > 0)
704  skip_bits_long(&gb, sl->au_seq_num_len);
705  if (sl->use_timestamps) {
706  dts_flag = get_bits1(&gb);
707  cts_flag = get_bits1(&gb);
708  }
709  }
710  if (sl->inst_bitrate_len)
711  inst_bitrate_flag = get_bits1(&gb);
712  if (dts_flag == 1)
713  dts = get_bits64(&gb, sl->timestamp_len);
714  if (cts_flag == 1)
715  cts = get_bits64(&gb, sl->timestamp_len);
716  if (sl->au_len > 0)
717  skip_bits_long(&gb, sl->au_len);
718  if (inst_bitrate_flag)
720  }
721 
722  if (dts != AV_NOPTS_VALUE)
723  pes->dts = dts;
724  if (cts != AV_NOPTS_VALUE)
725  pes->pts = cts;
726 
727  if (sl->timestamp_len && sl->timestamp_res)
729 
730  return (get_bits_count(&gb) + 7) >> 3;
731 }
732 
733 /* return non zero if a packet could be constructed */
735  const uint8_t *buf, int buf_size, int is_start,
736  int64_t pos)
737 {
738  PESContext *pes = filter->u.pes_filter.opaque;
739  MpegTSContext *ts = pes->ts;
740  const uint8_t *p;
741  int len, code;
742 
743  if(!ts->pkt)
744  return 0;
745 
746  if (is_start) {
747  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
748  new_pes_packet(pes, ts->pkt);
749  ts->stop_parse = 1;
750  }
751  pes->state = MPEGTS_HEADER;
752  pes->data_index = 0;
753  pes->ts_packet_pos = pos;
754  }
755  p = buf;
756  while (buf_size > 0) {
757  switch(pes->state) {
758  case MPEGTS_HEADER:
759  len = PES_START_SIZE - pes->data_index;
760  if (len > buf_size)
761  len = buf_size;
762  memcpy(pes->header + pes->data_index, p, len);
763  pes->data_index += len;
764  p += len;
765  buf_size -= len;
766  if (pes->data_index == PES_START_SIZE) {
767  /* we got all the PES or section header. We can now
768  decide */
769  if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
770  pes->header[2] == 0x01) {
771  /* it must be an mpeg2 PES stream */
772  code = pes->header[3] | 0x100;
773  av_dlog(pes->stream, "pid=%x pes_code=%#x\n", pes->pid, code);
774 
775  if ((pes->st && pes->st->discard == AVDISCARD_ALL &&
776  (!pes->sub_st || pes->sub_st->discard == AVDISCARD_ALL)) ||
777  code == 0x1be) /* padding_stream */
778  goto skip;
779 
780  /* stream not present in PMT */
781  if (!pes->st) {
782  pes->st = avformat_new_stream(ts->stream, NULL);
783  if (!pes->st)
784  return AVERROR(ENOMEM);
785  pes->st->id = pes->pid;
786  mpegts_set_stream_info(pes->st, pes, 0, 0);
787  }
788 
789  pes->total_size = AV_RB16(pes->header + 4);
790  /* NOTE: a zero total size means the PES size is
791  unbounded */
792  if (!pes->total_size)
794 
795  /* allocate pes buffer */
797  if (!pes->buffer)
798  return AVERROR(ENOMEM);
799 
800  if (code != 0x1bc && code != 0x1bf && /* program_stream_map, private_stream_2 */
801  code != 0x1f0 && code != 0x1f1 && /* ECM, EMM */
802  code != 0x1ff && code != 0x1f2 && /* program_stream_directory, DSMCC_stream */
803  code != 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */
804  pes->state = MPEGTS_PESHEADER;
805  if (pes->st->codec->codec_id == AV_CODEC_ID_NONE) {
806  av_dlog(pes->stream, "pid=%x stream_type=%x probing\n",
807  pes->pid, pes->stream_type);
809  }
810  } else {
811  pes->state = MPEGTS_PAYLOAD;
812  pes->data_index = 0;
813  }
814  } else {
815  /* otherwise, it should be a table */
816  /* skip packet */
817  skip:
818  pes->state = MPEGTS_SKIP;
819  continue;
820  }
821  }
822  break;
823  /**********************************************/
824  /* PES packing parsing */
825  case MPEGTS_PESHEADER:
826  len = PES_HEADER_SIZE - pes->data_index;
827  if (len < 0)
828  return -1;
829  if (len > buf_size)
830  len = buf_size;
831  memcpy(pes->header + pes->data_index, p, len);
832  pes->data_index += len;
833  p += len;
834  buf_size -= len;
835  if (pes->data_index == PES_HEADER_SIZE) {
836  pes->pes_header_size = pes->header[8] + 9;
838  }
839  break;
841  len = pes->pes_header_size - pes->data_index;
842  if (len < 0)
843  return -1;
844  if (len > buf_size)
845  len = buf_size;
846  memcpy(pes->header + pes->data_index, p, len);
847  pes->data_index += len;
848  p += len;
849  buf_size -= len;
850  if (pes->data_index == pes->pes_header_size) {
851  const uint8_t *r;
852  unsigned int flags, pes_ext, skip;
853 
854  flags = pes->header[7];
855  r = pes->header + 9;
856  pes->pts = AV_NOPTS_VALUE;
857  pes->dts = AV_NOPTS_VALUE;
858  if ((flags & 0xc0) == 0x80) {
859  pes->dts = pes->pts = ff_parse_pes_pts(r);
860  r += 5;
861  } else if ((flags & 0xc0) == 0xc0) {
862  pes->pts = ff_parse_pes_pts(r);
863  r += 5;
864  pes->dts = ff_parse_pes_pts(r);
865  r += 5;
866  }
867  pes->extended_stream_id = -1;
868  if (flags & 0x01) { /* PES extension */
869  pes_ext = *r++;
870  /* Skip PES private data, program packet sequence counter and P-STD buffer */
871  skip = (pes_ext >> 4) & 0xb;
872  skip += skip & 0x9;
873  r += skip;
874  if ((pes_ext & 0x41) == 0x01 &&
875  (r + 2) <= (pes->header + pes->pes_header_size)) {
876  /* PES extension 2 */
877  if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)
878  pes->extended_stream_id = r[1];
879  }
880  }
881 
882  /* we got the full header. We parse it and get the payload */
883  pes->state = MPEGTS_PAYLOAD;
884  pes->data_index = 0;
885  if (pes->stream_type == 0x12 && buf_size > 0) {
886  int sl_header_bytes = read_sl_header(pes, &pes->sl, p, buf_size);
887  pes->pes_header_size += sl_header_bytes;
888  p += sl_header_bytes;
889  buf_size -= sl_header_bytes;
890  }
891  }
892  break;
893  case MPEGTS_PAYLOAD:
894  if (buf_size > 0 && pes->buffer) {
895  if (pes->data_index > 0 && pes->data_index+buf_size > pes->total_size) {
896  new_pes_packet(pes, ts->pkt);
899  if (!pes->buffer)
900  return AVERROR(ENOMEM);
901  ts->stop_parse = 1;
902  } else if (pes->data_index == 0 && buf_size > pes->total_size) {
903  // pes packet size is < ts size packet and pes data is padded with 0xff
904  // not sure if this is legal in ts but see issue #2392
905  buf_size = pes->total_size;
906  }
907  memcpy(pes->buffer+pes->data_index, p, buf_size);
908  pes->data_index += buf_size;
909  }
910  buf_size = 0;
911  /* emit complete packets with known packet size
912  * decreases demuxer delay for infrequent packets like subtitles from
913  * a couple of seconds to milliseconds for properly muxed files.
914  * total_size is the number of bytes following pes_packet_length
915  * in the pes header, i.e. not counting the first PES_START_SIZE bytes */
916  if (!ts->stop_parse && pes->total_size < MAX_PES_PAYLOAD &&
917  pes->pes_header_size + pes->data_index == pes->total_size + PES_START_SIZE) {
918  ts->stop_parse = 1;
919  new_pes_packet(pes, ts->pkt);
920  }
921  break;
922  case MPEGTS_SKIP:
923  buf_size = 0;
924  break;
925  }
926  }
927 
928  return 0;
929 }
930 
931 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
932 {
933  MpegTSFilter *tss;
934  PESContext *pes;
935 
936  /* if no pid found, then add a pid context */
937  pes = av_mallocz(sizeof(PESContext));
938  if (!pes)
939  return 0;
940  pes->ts = ts;
941  pes->stream = ts->stream;
942  pes->pid = pid;
943  pes->pcr_pid = pcr_pid;
944  pes->state = MPEGTS_SKIP;
945  pes->pts = AV_NOPTS_VALUE;
946  pes->dts = AV_NOPTS_VALUE;
947  tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
948  if (!tss) {
949  av_free(pes);
950  return 0;
951  }
952  return pes;
953 }
954 
955 #define MAX_LEVEL 4
956 typedef struct {
963  int level;
965 
967  MP4DescrParseContext *d, AVFormatContext *s, const uint8_t *buf,
968  unsigned size, Mp4Descr *descr, int max_descr_count)
969 {
970  int ret;
971  if (size > (1<<30))
972  return AVERROR_INVALIDDATA;
973 
974  if ((ret = ffio_init_context(&d->pb, (unsigned char*)buf, size, 0,
975  NULL, NULL, NULL, NULL)) < 0)
976  return ret;
977 
978  d->s = s;
979  d->level = 0;
980  d->descr_count = 0;
981  d->descr = descr;
982  d->active_descr = NULL;
983  d->max_descr_count = max_descr_count;
984 
985  return 0;
986 }
987 
988 static void update_offsets(AVIOContext *pb, int64_t *off, int *len) {
989  int64_t new_off = avio_tell(pb);
990  (*len) -= new_off - *off;
991  *off = new_off;
992 }
993 
994 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
995  int target_tag);
996 
997 static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
998 {
999  while (len > 0) {
1000  if (parse_mp4_descr(d, off, len, 0) < 0)
1001  return -1;
1002  update_offsets(&d->pb, &off, &len);
1003  }
1004  return 0;
1005 }
1006 
1007 static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1008 {
1009  avio_rb16(&d->pb); // ID
1010  avio_r8(&d->pb);
1011  avio_r8(&d->pb);
1012  avio_r8(&d->pb);
1013  avio_r8(&d->pb);
1014  avio_r8(&d->pb);
1015  update_offsets(&d->pb, &off, &len);
1016  return parse_mp4_descr_arr(d, off, len);
1017 }
1018 
1019 static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1020 {
1021  int id_flags;
1022  if (len < 2)
1023  return 0;
1024  id_flags = avio_rb16(&d->pb);
1025  if (!(id_flags & 0x0020)) { //URL_Flag
1026  update_offsets(&d->pb, &off, &len);
1027  return parse_mp4_descr_arr(d, off, len); //ES_Descriptor[]
1028  } else {
1029  return 0;
1030  }
1031 }
1032 
1033 static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1034 {
1035  int es_id = 0;
1036  if (d->descr_count >= d->max_descr_count)
1037  return -1;
1038  ff_mp4_parse_es_descr(&d->pb, &es_id);
1039  d->active_descr = d->descr + (d->descr_count++);
1040 
1041  d->active_descr->es_id = es_id;
1042  update_offsets(&d->pb, &off, &len);
1043  parse_mp4_descr(d, off, len, MP4DecConfigDescrTag);
1044  update_offsets(&d->pb, &off, &len);
1045  if (len > 0)
1046  parse_mp4_descr(d, off, len, MP4SLDescrTag);
1047  d->active_descr = NULL;
1048  return 0;
1049 }
1050 
1052 {
1053  Mp4Descr *descr = d->active_descr;
1054  if (!descr)
1055  return -1;
1057  if (!descr->dec_config_descr)
1058  return AVERROR(ENOMEM);
1059  descr->dec_config_descr_len = len;
1060  avio_read(&d->pb, descr->dec_config_descr, len);
1061  return 0;
1062 }
1063 
1064 static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1065 {
1066  Mp4Descr *descr = d->active_descr;
1067  int predefined;
1068  if (!descr)
1069  return -1;
1070 
1071  predefined = avio_r8(&d->pb);
1072  if (!predefined) {
1073  int lengths;
1074  int flags = avio_r8(&d->pb);
1075  descr->sl.use_au_start = !!(flags & 0x80);
1076  descr->sl.use_au_end = !!(flags & 0x40);
1077  descr->sl.use_rand_acc_pt = !!(flags & 0x20);
1078  descr->sl.use_padding = !!(flags & 0x08);
1079  descr->sl.use_timestamps = !!(flags & 0x04);
1080  descr->sl.use_idle = !!(flags & 0x02);
1081  descr->sl.timestamp_res = avio_rb32(&d->pb);
1082  avio_rb32(&d->pb);
1083  descr->sl.timestamp_len = avio_r8(&d->pb);
1084  descr->sl.ocr_len = avio_r8(&d->pb);
1085  descr->sl.au_len = avio_r8(&d->pb);
1086  descr->sl.inst_bitrate_len = avio_r8(&d->pb);
1087  lengths = avio_rb16(&d->pb);
1088  descr->sl.degr_prior_len = lengths >> 12;
1089  descr->sl.au_seq_num_len = (lengths >> 7) & 0x1f;
1090  descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f;
1091  } else {
1092  av_log_missing_feature(d->s, "Predefined SLConfigDescriptor\n", 0);
1093  }
1094  return 0;
1095 }
1096 
1097 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1098  int target_tag) {
1099  int tag;
1100  int len1 = ff_mp4_read_descr(d->s, &d->pb, &tag);
1101  update_offsets(&d->pb, &off, &len);
1102  if (len < 0 || len1 > len || len1 <= 0) {
1103  av_log(d->s, AV_LOG_ERROR, "Tag %x length violation new length %d bytes remaining %d\n", tag, len1, len);
1104  return -1;
1105  }
1106 
1107  if (d->level++ >= MAX_LEVEL) {
1108  av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n");
1109  goto done;
1110  }
1111 
1112  if (target_tag && tag != target_tag) {
1113  av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag, target_tag);
1114  goto done;
1115  }
1116 
1117  switch (tag) {
1118  case MP4IODescrTag:
1119  parse_MP4IODescrTag(d, off, len1);
1120  break;
1121  case MP4ODescrTag:
1122  parse_MP4ODescrTag(d, off, len1);
1123  break;
1124  case MP4ESDescrTag:
1125  parse_MP4ESDescrTag(d, off, len1);
1126  break;
1127  case MP4DecConfigDescrTag:
1128  parse_MP4DecConfigDescrTag(d, off, len1);
1129  break;
1130  case MP4SLDescrTag:
1131  parse_MP4SLDescrTag(d, off, len1);
1132  break;
1133  }
1134 
1135 done:
1136  d->level--;
1137  avio_seek(&d->pb, off + len1, SEEK_SET);
1138  return 0;
1139 }
1140 
1141 static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
1142  Mp4Descr *descr, int *descr_count, int max_descr_count)
1143 {
1145  if (init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count) < 0)
1146  return -1;
1147 
1148  parse_mp4_descr(&d, avio_tell(&d.pb), size, MP4IODescrTag);
1149 
1150  *descr_count = d.descr_count;
1151  return 0;
1152 }
1153 
1154 static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size,
1155  Mp4Descr *descr, int *descr_count, int max_descr_count)
1156 {
1158  if (init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count) < 0)
1159  return -1;
1160 
1161  parse_mp4_descr_arr(&d, avio_tell(&d.pb), size);
1162 
1163  *descr_count = d.descr_count;
1164  return 0;
1165 }
1166 
1167 static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
1168 {
1169  MpegTSContext *ts = filter->u.section_filter.opaque;
1170  SectionHeader h;
1171  const uint8_t *p, *p_end;
1172  AVIOContext pb;
1173  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = {{ 0 }};
1174  int mp4_descr_count = 0;
1175  int i, pid;
1176  AVFormatContext *s = ts->stream;
1177 
1178  p_end = section + section_len - 4;
1179  p = section;
1180  if (parse_section_header(&h, &p, p_end) < 0)
1181  return;
1182  if (h.tid != M4OD_TID)
1183  return;
1184 
1185  mp4_read_od(s, p, (unsigned)(p_end - p), mp4_descr, &mp4_descr_count, MAX_MP4_DESCR_COUNT);
1186 
1187  for (pid = 0; pid < NB_PID_MAX; pid++) {
1188  if (!ts->pids[pid])
1189  continue;
1190  for (i = 0; i < mp4_descr_count; i++) {
1191  PESContext *pes;
1192  AVStream *st;
1193  if (ts->pids[pid]->es_id != mp4_descr[i].es_id)
1194  continue;
1195  if (!(ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES)) {
1196  av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);
1197  continue;
1198  }
1199  pes = ts->pids[pid]->u.pes_filter.opaque;
1200  st = pes->st;
1201  if (!st) {
1202  continue;
1203  }
1204 
1205  pes->sl = mp4_descr[i].sl;
1206 
1207  ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1208  mp4_descr[i].dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
1209  ff_mp4_read_dec_config_descr(s, st, &pb);
1210  if (st->codec->codec_id == AV_CODEC_ID_AAC &&
1211  st->codec->extradata_size > 0)
1212  st->need_parsing = 0;
1213  if (st->codec->codec_id == AV_CODEC_ID_H264 &&
1214  st->codec->extradata_size > 0)
1215  st->need_parsing = 0;
1216 
1217  if (st->codec->codec_id <= AV_CODEC_ID_NONE) {
1218  } else if (st->codec->codec_id < AV_CODEC_ID_FIRST_AUDIO) {
1220  } else if (st->codec->codec_id < AV_CODEC_ID_FIRST_SUBTITLE) {
1222  } else if (st->codec->codec_id < AV_CODEC_ID_FIRST_UNKNOWN) {
1224  }
1225  }
1226  }
1227  for (i = 0; i < mp4_descr_count; i++)
1228  av_free(mp4_descr[i].dec_config_descr);
1229 }
1230 
1232  const uint8_t **pp, const uint8_t *desc_list_end,
1233  Mp4Descr *mp4_descr, int mp4_descr_count, int pid,
1234  MpegTSContext *ts)
1235 {
1236  const uint8_t *desc_end;
1237  int desc_len, desc_tag, desc_es_id;
1238  char language[252];
1239  int i;
1240 
1241  desc_tag = get8(pp, desc_list_end);
1242  if (desc_tag < 0)
1243  return -1;
1244  desc_len = get8(pp, desc_list_end);
1245  if (desc_len < 0)
1246  return -1;
1247  desc_end = *pp + desc_len;
1248  if (desc_end > desc_list_end)
1249  return -1;
1250 
1251  av_dlog(fc, "tag: 0x%02x len=%d\n", desc_tag, desc_len);
1252 
1253  if (st->codec->codec_id == AV_CODEC_ID_NONE &&
1254  stream_type == STREAM_TYPE_PRIVATE_DATA)
1255  mpegts_find_stream_type(st, desc_tag, DESC_types);
1256 
1257  switch(desc_tag) {
1258  case 0x1E: /* SL descriptor */
1259  desc_es_id = get16(pp, desc_end);
1260  if (ts && ts->pids[pid])
1261  ts->pids[pid]->es_id = desc_es_id;
1262  for (i = 0; i < mp4_descr_count; i++)
1263  if (mp4_descr[i].dec_config_descr_len &&
1264  mp4_descr[i].es_id == desc_es_id) {
1265  AVIOContext pb;
1266  ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1267  mp4_descr[i].dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
1268  ff_mp4_read_dec_config_descr(fc, st, &pb);
1269  if (st->codec->codec_id == AV_CODEC_ID_AAC &&
1270  st->codec->extradata_size > 0)
1271  st->need_parsing = 0;
1273  mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);
1274  }
1275  break;
1276  case 0x1F: /* FMC descriptor */
1277  get16(pp, desc_end);
1278  if (mp4_descr_count > 0 && st->codec->codec_id == AV_CODEC_ID_AAC_LATM &&
1279  mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {
1280  AVIOContext pb;
1281  ffio_init_context(&pb, mp4_descr->dec_config_descr,
1282  mp4_descr->dec_config_descr_len, 0, NULL, NULL, NULL, NULL);
1283  ff_mp4_read_dec_config_descr(fc, st, &pb);
1284  if (st->codec->codec_id == AV_CODEC_ID_AAC &&
1285  st->codec->extradata_size > 0)
1286  st->need_parsing = 0;
1287  }
1288  break;
1289  case 0x56: /* DVB teletext descriptor */
1290  language[0] = get8(pp, desc_end);
1291  language[1] = get8(pp, desc_end);
1292  language[2] = get8(pp, desc_end);
1293  language[3] = 0;
1294  av_dict_set(&st->metadata, "language", language, 0);
1295  break;
1296  case 0x59: /* subtitling descriptor */
1297  language[0] = get8(pp, desc_end);
1298  language[1] = get8(pp, desc_end);
1299  language[2] = get8(pp, desc_end);
1300  language[3] = 0;
1301  /* hearing impaired subtitles detection */
1302  switch(get8(pp, desc_end)) {
1303  case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */
1304  case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */
1305  case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */
1306  case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */
1307  case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */
1308  case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */
1310  break;
1311  }
1312  if (st->codec->extradata) {
1313  if (st->codec->extradata_size == 4 && memcmp(st->codec->extradata, *pp, 4))
1314  av_log_ask_for_sample(fc, "DVB sub with multiple IDs\n");
1315  } else {
1317  if (st->codec->extradata) {
1318  st->codec->extradata_size = 4;
1319  memcpy(st->codec->extradata, *pp, 4);
1320  }
1321  }
1322  *pp += 4;
1323  av_dict_set(&st->metadata, "language", language, 0);
1324  break;
1325  case 0x0a: /* ISO 639 language descriptor */
1326  for (i = 0; i + 4 <= desc_len; i += 4) {
1327  language[i + 0] = get8(pp, desc_end);
1328  language[i + 1] = get8(pp, desc_end);
1329  language[i + 2] = get8(pp, desc_end);
1330  language[i + 3] = ',';
1331  switch (get8(pp, desc_end)) {
1332  case 0x01: st->disposition |= AV_DISPOSITION_CLEAN_EFFECTS; break;
1333  case 0x02: st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED; break;
1334  case 0x03: st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED; break;
1335  }
1336  }
1337  if (i) {
1338  language[i - 1] = 0;
1339  av_dict_set(&st->metadata, "language", language, 0);
1340  }
1341  break;
1342  case 0x05: /* registration descriptor */
1343  st->codec->codec_tag = bytestream_get_le32(pp);
1344  av_dlog(fc, "reg_desc=%.4s\n", (char*)&st->codec->codec_tag);
1345  if (st->codec->codec_id == AV_CODEC_ID_NONE)
1346  mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types);
1347  break;
1348  default:
1349  break;
1350  }
1351  *pp = desc_end;
1352  return 0;
1353 }
1354 
1355 static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
1356 {
1357  MpegTSContext *ts = filter->u.section_filter.opaque;
1358  SectionHeader h1, *h = &h1;
1359  PESContext *pes;
1360  AVStream *st;
1361  const uint8_t *p, *p_end, *desc_list_end;
1362  int program_info_length, pcr_pid, pid, stream_type;
1363  int desc_list_len;
1364  uint32_t prog_reg_desc = 0; /* registration descriptor */
1365 
1366  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = {{ 0 }};
1367  int mp4_descr_count = 0;
1368  int i;
1369 
1370  av_dlog(ts->stream, "PMT: len %i\n", section_len);
1371  hex_dump_debug(ts->stream, section, section_len);
1372 
1373  p_end = section + section_len - 4;
1374  p = section;
1375  if (parse_section_header(h, &p, p_end) < 0)
1376  return;
1377 
1378  av_dlog(ts->stream, "sid=0x%x sec_num=%d/%d\n",
1379  h->id, h->sec_num, h->last_sec_num);
1380 
1381  if (h->tid != PMT_TID)
1382  return;
1383 
1384  clear_program(ts, h->id);
1385  pcr_pid = get16(&p, p_end);
1386  if (pcr_pid < 0)
1387  return;
1388  pcr_pid &= 0x1fff;
1389  add_pid_to_pmt(ts, h->id, pcr_pid);
1390 
1391  av_dlog(ts->stream, "pcr_pid=0x%x\n", pcr_pid);
1392 
1393  program_info_length = get16(&p, p_end);
1394  if (program_info_length < 0)
1395  return;
1396  program_info_length &= 0xfff;
1397  while(program_info_length >= 2) {
1398  uint8_t tag, len;
1399  tag = get8(&p, p_end);
1400  len = get8(&p, p_end);
1401 
1402  av_dlog(ts->stream, "program tag: 0x%02x len=%d\n", tag, len);
1403 
1404  if(len > program_info_length - 2)
1405  //something else is broken, exit the program_descriptors_loop
1406  break;
1407  program_info_length -= len + 2;
1408  if (tag == 0x1d) { // IOD descriptor
1409  get8(&p, p_end); // scope
1410  get8(&p, p_end); // label
1411  len -= 2;
1412  mp4_read_iods(ts->stream, p, len, mp4_descr + mp4_descr_count,
1413  &mp4_descr_count, MAX_MP4_DESCR_COUNT);
1414  } else if (tag == 0x05 && len >= 4) { // registration descriptor
1415  prog_reg_desc = bytestream_get_le32(&p);
1416  len -= 4;
1417  }
1418  p += len;
1419  }
1420  p += program_info_length;
1421  if (p >= p_end)
1422  goto out;
1423 
1424  // stop parsing after pmt, we found header
1425  if (!ts->stream->nb_streams)
1426  ts->stop_parse = 1;
1427 
1428  for(;;) {
1429  st = 0;
1430  pes = NULL;
1431  stream_type = get8(&p, p_end);
1432  if (stream_type < 0)
1433  break;
1434  pid = get16(&p, p_end);
1435  if (pid < 0)
1436  break;
1437  pid &= 0x1fff;
1438 
1439  /* now create stream */
1440  if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
1441  pes = ts->pids[pid]->u.pes_filter.opaque;
1442  if (!pes->st) {
1443  pes->st = avformat_new_stream(pes->stream, NULL);
1444  pes->st->id = pes->pid;
1445  }
1446  st = pes->st;
1447  } else if (stream_type != 0x13) {
1448  if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably
1449  pes = add_pes_stream(ts, pid, pcr_pid);
1450  if (pes) {
1451  st = avformat_new_stream(pes->stream, NULL);
1452  st->id = pes->pid;
1453  }
1454  } else {
1455  int idx = ff_find_stream_index(ts->stream, pid);
1456  if (idx >= 0) {
1457  st = ts->stream->streams[idx];
1458  } else {
1459  st = avformat_new_stream(ts->stream, NULL);
1460  st->id = pid;
1462  }
1463  }
1464 
1465  if (!st)
1466  goto out;
1467 
1468  if (pes && !pes->stream_type)
1469  mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc);
1470 
1471  add_pid_to_pmt(ts, h->id, pid);
1472 
1474 
1475  desc_list_len = get16(&p, p_end);
1476  if (desc_list_len < 0)
1477  break;
1478  desc_list_len &= 0xfff;
1479  desc_list_end = p + desc_list_len;
1480  if (desc_list_end > p_end)
1481  break;
1482  for(;;) {
1483  if (ff_parse_mpeg2_descriptor(ts->stream, st, stream_type, &p, desc_list_end,
1484  mp4_descr, mp4_descr_count, pid, ts) < 0)
1485  break;
1486 
1487  if (pes && prog_reg_desc == AV_RL32("HDMV") && stream_type == 0x83 && pes->sub_st) {
1489  pes->sub_st->codec->codec_tag = st->codec->codec_tag;
1490  }
1491  }
1492  p = desc_list_end;
1493  }
1494 
1495  out:
1496  for (i = 0; i < mp4_descr_count; i++)
1497  av_free(mp4_descr[i].dec_config_descr);
1498 }
1499 
1500 static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
1501 {
1502  MpegTSContext *ts = filter->u.section_filter.opaque;
1503  SectionHeader h1, *h = &h1;
1504  const uint8_t *p, *p_end;
1505  int sid, pmt_pid;
1506 
1507  av_dlog(ts->stream, "PAT:\n");
1508  hex_dump_debug(ts->stream, section, section_len);
1509 
1510  p_end = section + section_len - 4;
1511  p = section;
1512  if (parse_section_header(h, &p, p_end) < 0)
1513  return;
1514  if (h->tid != PAT_TID)
1515  return;
1516 
1517  clear_programs(ts);
1518  for(;;) {
1519  sid = get16(&p, p_end);
1520  if (sid < 0)
1521  break;
1522  pmt_pid = get16(&p, p_end);
1523  if (pmt_pid < 0)
1524  break;
1525  pmt_pid &= 0x1fff;
1526 
1527  av_dlog(ts->stream, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
1528 
1529  if (sid == 0x0000) {
1530  /* NIT info */
1531  } else {
1532  av_new_program(ts->stream, sid);
1533  if (ts->pids[pmt_pid])
1534  mpegts_close_filter(ts, ts->pids[pmt_pid]);
1535  mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
1536  add_pat_entry(ts, sid);
1537  add_pid_to_pmt(ts, sid, 0); //add pat pid to program
1538  add_pid_to_pmt(ts, sid, pmt_pid);
1539  }
1540  }
1541 }
1542 
1543 static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
1544 {
1545  MpegTSContext *ts = filter->u.section_filter.opaque;
1546  SectionHeader h1, *h = &h1;
1547  const uint8_t *p, *p_end, *desc_list_end, *desc_end;
1548  int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
1549  char *name, *provider_name;
1550 
1551  av_dlog(ts->stream, "SDT:\n");
1552  hex_dump_debug(ts->stream, section, section_len);
1553 
1554  p_end = section + section_len - 4;
1555  p = section;
1556  if (parse_section_header(h, &p, p_end) < 0)
1557  return;
1558  if (h->tid != SDT_TID)
1559  return;
1560  onid = get16(&p, p_end);
1561  if (onid < 0)
1562  return;
1563  val = get8(&p, p_end);
1564  if (val < 0)
1565  return;
1566  for(;;) {
1567  sid = get16(&p, p_end);
1568  if (sid < 0)
1569  break;
1570  val = get8(&p, p_end);
1571  if (val < 0)
1572  break;
1573  desc_list_len = get16(&p, p_end);
1574  if (desc_list_len < 0)
1575  break;
1576  desc_list_len &= 0xfff;
1577  desc_list_end = p + desc_list_len;
1578  if (desc_list_end > p_end)
1579  break;
1580  for(;;) {
1581  desc_tag = get8(&p, desc_list_end);
1582  if (desc_tag < 0)
1583  break;
1584  desc_len = get8(&p, desc_list_end);
1585  desc_end = p + desc_len;
1586  if (desc_end > desc_list_end)
1587  break;
1588 
1589  av_dlog(ts->stream, "tag: 0x%02x len=%d\n",
1590  desc_tag, desc_len);
1591 
1592  switch(desc_tag) {
1593  case 0x48:
1594  service_type = get8(&p, p_end);
1595  if (service_type < 0)
1596  break;
1597  provider_name = getstr8(&p, p_end);
1598  if (!provider_name)
1599  break;
1600  name = getstr8(&p, p_end);
1601  if (name) {
1602  AVProgram *program = av_new_program(ts->stream, sid);
1603  if(program) {
1604  av_dict_set(&program->metadata, "service_name", name, 0);
1605  av_dict_set(&program->metadata, "service_provider", provider_name, 0);
1606  }
1607  }
1608  av_free(name);
1609  av_free(provider_name);
1610  break;
1611  default:
1612  break;
1613  }
1614  p = desc_end;
1615  }
1616  p = desc_list_end;
1617  }
1618 }
1619 
1620 /* handle one TS packet */
1621 static int handle_packet(MpegTSContext *ts, const uint8_t *packet)
1622 {
1623  AVFormatContext *s = ts->stream;
1624  MpegTSFilter *tss;
1625  int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,
1626  has_adaptation, has_payload;
1627  const uint8_t *p, *p_end;
1628  int64_t pos;
1629 
1630  pid = AV_RB16(packet + 1) & 0x1fff;
1631  if(pid && discard_pid(ts, pid))
1632  return 0;
1633  is_start = packet[1] & 0x40;
1634  tss = ts->pids[pid];
1635  if (ts->auto_guess && tss == NULL && is_start) {
1636  add_pes_stream(ts, pid, -1);
1637  tss = ts->pids[pid];
1638  }
1639  if (!tss)
1640  return 0;
1641 
1642  afc = (packet[3] >> 4) & 3;
1643  if (afc == 0) /* reserved value */
1644  return 0;
1645  has_adaptation = afc & 2;
1646  has_payload = afc & 1;
1647  is_discontinuity = has_adaptation
1648  && packet[4] != 0 /* with length > 0 */
1649  && (packet[5] & 0x80); /* and discontinuity indicated */
1650 
1651  /* continuity check (currently not used) */
1652  cc = (packet[3] & 0xf);
1653  expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc;
1654  cc_ok = pid == 0x1FFF // null packet PID
1655  || is_discontinuity
1656  || tss->last_cc < 0
1657  || expected_cc == cc;
1658 
1659  tss->last_cc = cc;
1660  if (!cc_ok) {
1662  "Continuity check failed for pid %d expected %d got %d\n",
1663  pid, expected_cc, cc);
1664  if(tss->type == MPEGTS_PES) {
1665  PESContext *pc = tss->u.pes_filter.opaque;
1666  pc->flags |= AV_PKT_FLAG_CORRUPT;
1667  }
1668  }
1669 
1670  if (!has_payload)
1671  return 0;
1672  p = packet + 4;
1673  if (has_adaptation) {
1674  /* skip adaptation field */
1675  p += p[0] + 1;
1676  }
1677  /* if past the end of packet, ignore */
1678  p_end = packet + TS_PACKET_SIZE;
1679  if (p >= p_end)
1680  return 0;
1681 
1682  pos = avio_tell(ts->stream->pb);
1683  ts->pos47= pos % ts->raw_packet_size;
1684 
1685  if (tss->type == MPEGTS_SECTION) {
1686  if (is_start) {
1687  /* pointer field present */
1688  len = *p++;
1689  if (p + len > p_end)
1690  return 0;
1691  if (len && cc_ok) {
1692  /* write remaining section bytes */
1693  write_section_data(s, tss,
1694  p, len, 0);
1695  /* check whether filter has been closed */
1696  if (!ts->pids[pid])
1697  return 0;
1698  }
1699  p += len;
1700  if (p < p_end) {
1701  write_section_data(s, tss,
1702  p, p_end - p, 1);
1703  }
1704  } else {
1705  if (cc_ok) {
1706  write_section_data(s, tss,
1707  p, p_end - p, 0);
1708  }
1709  }
1710  } else {
1711  int ret;
1712  // Note: The position here points actually behind the current packet.
1713  if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
1714  pos - ts->raw_packet_size)) < 0)
1715  return ret;
1716  }
1717 
1718  return 0;
1719 }
1720 
1721 /* XXX: try to find a better synchro over several packets (use
1722  get_packet_size() ?) */
1724 {
1725  AVIOContext *pb = s->pb;
1726  int c, i;
1727 
1728  for(i = 0;i < MAX_RESYNC_SIZE; i++) {
1729  c = avio_r8(pb);
1730  if (pb->eof_reached)
1731  return -1;
1732  if (c == 0x47) {
1733  avio_seek(pb, -1, SEEK_CUR);
1734  return 0;
1735  }
1736  }
1737  av_log(s, AV_LOG_ERROR, "max resync size reached, could not find sync byte\n");
1738  /* no sync found */
1739  return -1;
1740 }
1741 
1742 /* return -1 if error or EOF. Return 0 if OK. */
1743 static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size)
1744 {
1745  AVIOContext *pb = s->pb;
1746  int skip, len;
1747 
1748  for(;;) {
1749  len = avio_read(pb, buf, TS_PACKET_SIZE);
1750  if (len != TS_PACKET_SIZE)
1751  return len < 0 ? len : AVERROR_EOF;
1752  /* check packet sync byte */
1753  if (buf[0] != 0x47) {
1754  /* find a new packet start */
1755  avio_seek(pb, -TS_PACKET_SIZE, SEEK_CUR);
1756  if (mpegts_resync(s) < 0)
1757  return AVERROR(EAGAIN);
1758  else
1759  continue;
1760  } else {
1761  skip = raw_packet_size - TS_PACKET_SIZE;
1762  if (skip > 0)
1763  avio_skip(pb, skip);
1764  break;
1765  }
1766  }
1767  return 0;
1768 }
1769 
1770 static int handle_packets(MpegTSContext *ts, int nb_packets)
1771 {
1772  AVFormatContext *s = ts->stream;
1774  int packet_num, ret = 0;
1775 
1776  if (avio_tell(s->pb) != ts->last_pos) {
1777  int i;
1778  av_dlog(ts->stream, "Skipping after seek\n");
1779  /* seek detected, flush pes buffer */
1780  for (i = 0; i < NB_PID_MAX; i++) {
1781  if (ts->pids[i]) {
1782  if (ts->pids[i]->type == MPEGTS_PES) {
1783  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
1784  av_freep(&pes->buffer);
1785  pes->data_index = 0;
1786  pes->state = MPEGTS_SKIP; /* skip until pes header */
1787  }
1788  ts->pids[i]->last_cc = -1;
1789  }
1790  }
1791  }
1792 
1793  ts->stop_parse = 0;
1794  packet_num = 0;
1795  memset(packet + TS_PACKET_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1796  for(;;) {
1797  if (ts->stop_parse>0)
1798  break;
1799  packet_num++;
1800  if (nb_packets != 0 && packet_num >= nb_packets)
1801  break;
1802  ret = read_packet(s, packet, ts->raw_packet_size);
1803  if (ret != 0)
1804  break;
1805  ret = handle_packet(ts, packet);
1806  if (ret != 0)
1807  break;
1808  }
1809  ts->last_pos = avio_tell(s->pb);
1810  return ret;
1811 }
1812 
1814 {
1815  const int size= p->buf_size;
1816  int score, fec_score, dvhs_score;
1817  int check_count= size / TS_FEC_PACKET_SIZE;
1818 #define CHECK_COUNT 10
1819 
1820  if (check_count < CHECK_COUNT)
1821  return -1;
1822 
1823  score = analyze(p->buf, TS_PACKET_SIZE *check_count, TS_PACKET_SIZE , NULL)*CHECK_COUNT/check_count;
1824  dvhs_score= analyze(p->buf, TS_DVHS_PACKET_SIZE*check_count, TS_DVHS_PACKET_SIZE, NULL)*CHECK_COUNT/check_count;
1825  fec_score = analyze(p->buf, TS_FEC_PACKET_SIZE *check_count, TS_FEC_PACKET_SIZE , NULL)*CHECK_COUNT/check_count;
1826  av_dlog(NULL, "score: %d, dvhs_score: %d, fec_score: %d \n",
1827  score, dvhs_score, fec_score);
1828 
1829 // we need a clear definition for the returned score otherwise things will become messy sooner or later
1830  if (score > fec_score && score > dvhs_score && score > 6) return AVPROBE_SCORE_MAX + score - CHECK_COUNT;
1831  else if(dvhs_score > score && dvhs_score > fec_score && dvhs_score > 6) return AVPROBE_SCORE_MAX + dvhs_score - CHECK_COUNT;
1832  else if( fec_score > 6) return AVPROBE_SCORE_MAX + fec_score - CHECK_COUNT;
1833  else return -1;
1834 }
1835 
1836 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
1837  (-1) if not available */
1838 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
1839  const uint8_t *packet)
1840 {
1841  int afc, len, flags;
1842  const uint8_t *p;
1843  unsigned int v;
1844 
1845  afc = (packet[3] >> 4) & 3;
1846  if (afc <= 1)
1847  return -1;
1848  p = packet + 4;
1849  len = p[0];
1850  p++;
1851  if (len == 0)
1852  return -1;
1853  flags = *p++;
1854  len--;
1855  if (!(flags & 0x10))
1856  return -1;
1857  if (len < 6)
1858  return -1;
1859  v = AV_RB32(p);
1860  *ppcr_high = ((int64_t)v << 1) | (p[4] >> 7);
1861  *ppcr_low = ((p[4] & 1) << 8) | p[5];
1862  return 0;
1863 }
1864 
1866 {
1867  MpegTSContext *ts = s->priv_data;
1868  AVIOContext *pb = s->pb;
1869  uint8_t buf[5*1024];
1870  int len;
1871  int64_t pos;
1872 
1873  /* read the first 1024 bytes to get packet size */
1874  pos = avio_tell(pb);
1875  len = avio_read(pb, buf, sizeof(buf));
1876  if (len != sizeof(buf))
1877  goto fail;
1878  ts->raw_packet_size = get_packet_size(buf, sizeof(buf));
1879  if (ts->raw_packet_size <= 0)
1880  goto fail;
1881  ts->stream = s;
1882  ts->auto_guess = 0;
1883 
1884  if (s->iformat == &ff_mpegts_demuxer) {
1885  /* normal demux */
1886 
1887  /* first do a scan to get all the services */
1888  if (avio_seek(pb, pos, SEEK_SET) < 0 && pb->seekable)
1889  av_log(s, AV_LOG_ERROR, "Unable to seek back to the start\n");
1890 
1892 
1894 
1896  /* if could not find service, enable auto_guess */
1897 
1898  ts->auto_guess = 1;
1899 
1900  av_dlog(ts->stream, "tuning done\n");
1901 
1903  } else {
1904  AVStream *st;
1905  int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
1906  int64_t pcrs[2], pcr_h;
1907  int packet_count[2];
1908  uint8_t packet[TS_PACKET_SIZE];
1909 
1910  /* only read packets */
1911 
1912  st = avformat_new_stream(s, NULL);
1913  if (!st)
1914  goto fail;
1915  avpriv_set_pts_info(st, 60, 1, 27000000);
1918 
1919  /* we iterate until we find two PCRs to estimate the bitrate */
1920  pcr_pid = -1;
1921  nb_pcrs = 0;
1922  nb_packets = 0;
1923  for(;;) {
1924  ret = read_packet(s, packet, ts->raw_packet_size);
1925  if (ret < 0)
1926  return -1;
1927  pid = AV_RB16(packet + 1) & 0x1fff;
1928  if ((pcr_pid == -1 || pcr_pid == pid) &&
1929  parse_pcr(&pcr_h, &pcr_l, packet) == 0) {
1930  pcr_pid = pid;
1931  packet_count[nb_pcrs] = nb_packets;
1932  pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
1933  nb_pcrs++;
1934  if (nb_pcrs >= 2)
1935  break;
1936  }
1937  nb_packets++;
1938  }
1939 
1940  /* NOTE1: the bitrate is computed without the FEC */
1941  /* NOTE2: it is only the bitrate of the start of the stream */
1942  ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
1943  ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];
1944  s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;
1945  st->codec->bit_rate = s->bit_rate;
1946  st->start_time = ts->cur_pcr;
1947  av_dlog(ts->stream, "start=%0.3f pcr=%0.3f incr=%d\n",
1948  st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
1949  }
1950 
1951  avio_seek(pb, pos, SEEK_SET);
1952  return 0;
1953  fail:
1954  return -1;
1955 }
1956 
1957 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
1958 
1960  AVPacket *pkt)
1961 {
1962  MpegTSContext *ts = s->priv_data;
1963  int ret, i;
1964  int64_t pcr_h, next_pcr_h, pos;
1965  int pcr_l, next_pcr_l;
1966  uint8_t pcr_buf[12];
1967 
1968  if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
1969  return AVERROR(ENOMEM);
1970  pkt->pos= avio_tell(s->pb);
1971  ret = read_packet(s, pkt->data, ts->raw_packet_size);
1972  if (ret < 0) {
1973  av_free_packet(pkt);
1974  return ret;
1975  }
1976  if (ts->mpeg2ts_compute_pcr) {
1977  /* compute exact PCR for each packet */
1978  if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
1979  /* we read the next PCR (XXX: optimize it by using a bigger buffer */
1980  pos = avio_tell(s->pb);
1981  for(i = 0; i < MAX_PACKET_READAHEAD; i++) {
1982  avio_seek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
1983  avio_read(s->pb, pcr_buf, 12);
1984  if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
1985  /* XXX: not precise enough */
1986  ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
1987  (i + 1);
1988  break;
1989  }
1990  }
1991  avio_seek(s->pb, pos, SEEK_SET);
1992  /* no next PCR found: we use previous increment */
1993  ts->cur_pcr = pcr_h * 300 + pcr_l;
1994  }
1995  pkt->pts = ts->cur_pcr;
1996  pkt->duration = ts->pcr_incr;
1997  ts->cur_pcr += ts->pcr_incr;
1998  }
1999  pkt->stream_index = 0;
2000  return 0;
2001 }
2002 
2004  AVPacket *pkt)
2005 {
2006  MpegTSContext *ts = s->priv_data;
2007  int ret, i;
2008 
2009  pkt->size = -1;
2010  ts->pkt = pkt;
2011  ret = handle_packets(ts, 0);
2012  if (ret < 0) {
2013  /* flush pes data left */
2014  for (i = 0; i < NB_PID_MAX; i++) {
2015  if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
2016  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
2017  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
2018  new_pes_packet(pes, pkt);
2019  pes->state = MPEGTS_SKIP;
2020  ret = 0;
2021  break;
2022  }
2023  }
2024  }
2025  }
2026 
2027  if (!ret && pkt->size < 0)
2028  ret = AVERROR(EINTR);
2029  return ret;
2030 }
2031 
2033 {
2034  MpegTSContext *ts = s->priv_data;
2035  int i;
2036 
2037  clear_programs(ts);
2038 
2039  for(i=0;i<NB_PID_MAX;i++)
2040  if (ts->pids[i]) mpegts_close_filter(ts, ts->pids[i]);
2041 
2042  return 0;
2043 }
2044 
2045 static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
2046  int64_t *ppos, int64_t pos_limit)
2047 {
2048  MpegTSContext *ts = s->priv_data;
2049  int64_t pos, timestamp;
2050  uint8_t buf[TS_PACKET_SIZE];
2051  int pcr_l, pcr_pid = ((PESContext*)s->streams[stream_index]->priv_data)->pcr_pid;
2052  const int find_next= 1;
2053  pos = ((*ppos + ts->raw_packet_size - 1 - ts->pos47) / ts->raw_packet_size) * ts->raw_packet_size + ts->pos47;
2054  if (find_next) {
2055  for(;;) {
2056  avio_seek(s->pb, pos, SEEK_SET);
2057  if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
2058  return AV_NOPTS_VALUE;
2059  if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
2060  parse_pcr(&timestamp, &pcr_l, buf) == 0) {
2061  break;
2062  }
2063  pos += ts->raw_packet_size;
2064  }
2065  } else {
2066  for(;;) {
2067  pos -= ts->raw_packet_size;
2068  if (pos < 0)
2069  return AV_NOPTS_VALUE;
2070  avio_seek(s->pb, pos, SEEK_SET);
2071  if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
2072  return AV_NOPTS_VALUE;
2073  if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
2074  parse_pcr(&timestamp, &pcr_l, buf) == 0) {
2075  break;
2076  }
2077  }
2078  }
2079  *ppos = pos;
2080 
2081  return timestamp;
2082 }
2083 
2084 static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
2085  MpegTSContext *ts = s->priv_data;
2086  uint8_t buf[TS_PACKET_SIZE];
2087  int64_t pos;
2088 
2089  if (ff_seek_frame_binary(s, stream_index, target_ts, flags) < 0)
2090  return -1;
2091 
2092  pos= avio_tell(s->pb);
2093 
2094  for(;;) {
2095  avio_seek(s->pb, pos, SEEK_SET);
2096  if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
2097  return -1;
2098 // pid = AV_RB16(buf + 1) & 0x1fff;
2099  if(buf[1] & 0x40) break;
2100  pos += ts->raw_packet_size;
2101  }
2102  avio_seek(s->pb, pos, SEEK_SET);
2103 
2104  return 0;
2105 }
2106 
2107 /**************************************************************/
2108 /* parsing functions - called from other demuxers such as RTP */
2109 
2111 {
2112  MpegTSContext *ts;
2113 
2114  ts = av_mallocz(sizeof(MpegTSContext));
2115  if (!ts)
2116  return NULL;
2117  /* no stream case, currently used by RTP */
2119  ts->stream = s;
2120  ts->auto_guess = 1;
2121  return ts;
2122 }
2123 
2124 /* return the consumed length if a packet was output, or -1 if no
2125  packet is output */
2127  const uint8_t *buf, int len)
2128 {
2129  int len1;
2130 
2131  len1 = len;
2132  ts->pkt = pkt;
2133  ts->stop_parse = 0;
2134  for(;;) {
2135  if (ts->stop_parse>0)
2136  break;
2137  if (len < TS_PACKET_SIZE)
2138  return -1;
2139  if (buf[0] != 0x47) {
2140  buf++;
2141  len--;
2142  } else {
2143  handle_packet(ts, buf);
2144  buf += TS_PACKET_SIZE;
2145  len -= TS_PACKET_SIZE;
2146  }
2147  }
2148  return len1 - len;
2149 }
2150 
2152 {
2153  int i;
2154 
2155  for(i=0;i<NB_PID_MAX;i++)
2156  av_free(ts->pids[i]);
2157  av_free(ts);
2158 }
2159 
2160 AVInputFormat ff_mpegts_demuxer = {
2161  .name = "mpegts",
2162  .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
2163  .priv_data_size = sizeof(MpegTSContext),
2168  .read_seek = read_seek,
2169  .read_timestamp = mpegts_get_pcr,
2171 };
2172 
2174  .name = "mpegtsraw",
2175  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"),
2176  .priv_data_size = sizeof(MpegTSContext),
2180  .read_seek = read_seek,
2181  .read_timestamp = mpegts_get_pcr,
2183  .priv_class = &mpegtsraw_class,
2184 };
codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it ...
Definition: avcodec.h:428
uint8_t last_sec_num
Definition: mpegts.c:428
#define SDT_PID
Definition: mpegts.h:37
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:61
struct PESContext PESContext
Bytestream IO Context.
Definition: avio.h:68
int es_id
Definition: mpegts.c:76
#define PES_START_SIZE
Definition: mpegts.c:154
#define PMT_TID
Definition: mpegts.h:41
int size
#define MP4ESDescrTag
Definition: isom.h:164
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:153
int total_size
Definition: mpegts.c:170
static int mpegts_resync(AVFormatContext *s)
Definition: mpegts.c:1723
void ff_mp4_parse_es_descr(AVIOContext *pb, int *es_id)
Definition: isom.c:383
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:90
AVOption.
Definition: opt.h:233
A dummy id pointing at the start of audio codecs.
Definition: avcodec.h:270
int64_t cur_pcr
used to estimate the exact PCR
Definition: mpegts.c:107
#define MAX_PACKET_READAHEAD
Definition: mpegts.c:1957
enum AVMediaType codec_type
Definition: mpegts.c:512
int64_t dts
Definition: mpegts.c:173
static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1019
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
static int handle_packet(MpegTSContext *ts, const uint8_t *packet)
Definition: mpegts.c:1621
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:940
static void clear_program(MpegTSContext *ts, unsigned int programid)
Definition: mpegts.c:182
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:3283
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:197
static int mpegts_probe(AVProbeData *p)
Definition: mpegts.c:1813
#define MP4ODescrTag
Definition: isom.h:162
int index
stream index in AVFormatContext
Definition: avformat.h:623
int size
Definition: avcodec.h:916
MpegTSPESFilter pes_filter
Definition: mpegts.c:80
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:186
uint8_t version
Definition: mpegts.c:426
enum AVMediaType codec_type
Definition: rtp.c:39
AVInputFormat ff_mpegts_demuxer
Definition: mpegts.c:2160
static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1543
A dummy ID pointing at the start of various fake codecs.
Definition: avcodec.h:425
void * priv_data
Definition: avformat.h:653
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
#define M4OD_TID
Definition: mpegts.h:42
static int parse_section_header(SectionHeader *h, const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:481
discard all
Definition: avcodec.h:536
enum MpegTSFilterType type
Definition: mpegts.c:78
#define MAX_RESYNC_SIZE
Definition: mpegts.c:40
int pid
Definition: mpegts.c:159
struct Program * prg
Definition: mpegts.c:123
static int mpegts_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegts.c:2003
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:562
int ctx_flags
Format-specific flags, see AVFMTCTX_xx.
Definition: avformat.h:864
int pcr_pid
if -1 then all packets containing PCR are considered
Definition: mpegts.c:160
int id
Definition: avformat.h:801
SLConfigDescr sl
Definition: mpegts.h:89
int packet_seq_num_len
Definition: mpegts.h:82
int es_id
Definition: mpegts.h:86
int inst_bitrate_len
Definition: mpegts.h:79
unsigned int nb_prg
structure to keep track of Program->pids mapping
Definition: mpegts.c:122
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:151
int last_cc
Definition: mpegts.c:77
Format I/O context.
Definition: avformat.h:828
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:38
unsigned int pids[MAX_PIDS_PER_PROGRAM]
Definition: mpegts.c:89
Definition: mpegts.c:86
static void write_section_data(AVFormatContext *s, MpegTSFilter *tss1, const uint8_t *buf, int buf_size, int is_start)
Assemble PES packets out of TS packets, and then call the "section_cb" function when they are complet...
Definition: mpegts.c:265
Public dictionary API.
static int read_sl_header(PESContext *pes, SLConfigDescr *sl, const uint8_t *buf, int buf_size)
Definition: mpegts.c:668
MpegTSFilter * pids[NB_PID_MAX]
filters for various streams specified by PMT + for the PAT and PMT
Definition: mpegts.c:127
static int mpegts_read_header(AVFormatContext *s)
Definition: mpegts.c:1865
AVFormatContext * s
Definition: mpegts.c:957
uint8_t
Opaque data information usually continuous.
Definition: avutil.h:181
enum MpegTSState state
Definition: mpegts.c:166
AVOptions.
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:76
int au_seq_num_len
Definition: mpegts.h:81
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:577
int stop_parse
stop parsing loop
Definition: mpegts.c:112
static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1033
static int discard_pid(MpegTSContext *ts, unsigned int pid)
discard_pid() decides if the pid is to be discarded according to caller's programs selection ...
Definition: mpegts.c:236
#define AV_RB32
Definition: intreadwrite.h:130
static void add_pat_entry(MpegTSContext *ts, unsigned int programid)
Definition: mpegts.c:197
static int mpegts_push_data(MpegTSFilter *filter, const uint8_t *buf, int buf_size, int is_start, int64_t pos)
Definition: mpegts.c:734
int id
Format-specific stream ID.
Definition: avformat.h:629
enum AVStreamParseType need_parsing
Definition: avformat.h:775
int use_au_start
Definition: mpegts.h:69
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
const char * name
AVStream ** streams
Definition: avformat.h:876
#define TS_PACKET_SIZE
Definition: mpegts.h:29
Mp4Descr * descr
Definition: mpegts.c:959
static void update_offsets(AVIOContext *pb, int64_t *off, int *len)
Definition: mpegts.c:988
uint8_t * data
Definition: avcodec.h:915
AVProgram * av_new_program(AVFormatContext *s, int id)
Definition: utils.c:2792
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
MpegTSState
Definition: mpegts.c:145
static int flags
Definition: log.c:42
uint32_t tag
Definition: movenc.c:802
bitstream reader API header.
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
int pid
Definition: mpegts.c:75
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:219
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:803
static PESContext * add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
Definition: mpegts.c:931
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:937
#define PAT_TID
Definition: mpegts.h:40
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:446
#define r
Definition: input.c:51
static MpegTSFilter * mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid, PESCallback *pes_cb, void *opaque)
Definition: mpegts.c:335
AVInputFormat ff_mpegtsraw_demuxer
Definition: mpegts.c:2173
static int init_MP4DescrParseContext(MP4DescrParseContext *d, AVFormatContext *s, const uint8_t *buf, unsigned size, Mp4Descr *descr, int max_descr_count)
Definition: mpegts.c:966
void(* destruct)(struct AVPacket *)
Definition: avcodec.h:938
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:56
static uint64_t get_bits64(GetBitContext *s, int n)
Definition: get_bits.h:319
enum AVCodecID codec_id
Definition: mpegts.c:513
int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext *pb)
Definition: isom.c:408
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:95
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:139
void av_log_ask_for_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message asking for a sample.
static const StreamType HDMV_types[]
Definition: mpegts.c:530
#define AV_RB16
Definition: intreadwrite.h:53
static int mpegts_read_close(AVFormatContext *s)
Definition: mpegts.c:2032
unsigned int check_crc
Definition: mpegts.c:68
static int mpegts_raw_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegts.c:1959
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
unsigned int nb_programs
Definition: avformat.h:930
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:348
int pes_header_size
Definition: mpegts.c:171
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
Definition: utils.c:2839
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
AVStream * avformat_new_stream(AVFormatContext *s, AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:2736
#define TS_FEC_PACKET_SIZE
Definition: mpegts.h:27
enum AVCodecID codec_id
Definition: mov_chan.c:432
New fields can be added to the end with minor version bumps.
Definition: avformat.h:800
static int64_t ff_parse_pes_pts(const uint8_t *buf)
Parse MPEG-PES five-byte timestamp.
Definition: mpeg.h:66
int timestamp_len
Definition: mpegts.h:76
static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1051
int flags
copied to the AVPacket flags
Definition: mpegts.c:169
struct MpegTSPESFilter MpegTSPESFilter
#define MAX_SECTION_SIZE
Definition: mpegts.h:33
int pcr_incr
used to estimate the exact PCR
Definition: mpegts.c:108
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:921
int off
Definition: dsputil_bfin.c:28
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:437
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:641
MpegTSContext * ff_mpegts_parse_open(AVFormatContext *s)
Definition: mpegts.c:2110
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:341
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:340
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
Definition: mpegaudioenc.c:318
unsigned int nb_streams
A list of all streams in the file.
Definition: avformat.h:875
int ff_find_stream_index(AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: utils.c:3417
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:117
int bit_rate
the average bitrate
Definition: avcodec.h:1404
int64_t ts_packet_pos
position of first TS packet of this PES packet
Definition: mpegts.c:174
SectionCallback * section_cb
Definition: mpegts.c:70
static const StreamType REGD_types[]
Definition: mpegts.c:549
int PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos)
Definition: mpegts.c:53
static const StreamType MISC_types[]
Definition: mpegts.c:543
uint16_t id
Definition: mpegts.c:425
static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size, Mp4Descr *descr, int *descr_count, int max_descr_count)
Definition: mpegts.c:1154
#define TS_DVHS_PACKET_SIZE
Definition: mpegts.h:28
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:54
AVStream * st
Definition: mpegts.c:164
#define MP4IODescrTag
Definition: isom.h:163
AVFormatContext * stream
Definition: mpegts.c:95
static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: avio.h:210
struct SectionHeader SectionHeader
StreamType
Definition: avserver.c:189
int ocr_len
Definition: mpegts.h:77
static int handle_packets(MpegTSContext *ts, int nb_packets)
Definition: mpegts.c:1770
static int mpegts_set_stream_info(AVStream *st, PESContext *pes, uint32_t stream_type, uint32_t prog_reg_desc)
Definition: mpegts.c:582
#define AV_RL32
Definition: intreadwrite.h:146
AVDictionary * metadata
Definition: avformat.h:699
static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len, int target_tag)
Definition: mpegts.c:1097
#define CHECK_COUNT
static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1064
int mpeg2ts_compute_pcr
compute exact PCR for each transport stream packet
Definition: mpegts.c:105
static const AVClass mpegtsraw_class
Definition: mpegts.c:136
MpegTSSectionFilter section_filter
Definition: mpegts.c:81
unsigned int probesize
decoding: size of data to probe; encoding: unused.
Definition: avformat.h:919
int ff_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt, const uint8_t *buf, int len)
Definition: mpegts.c:2126
uint8_t sec_num
Definition: mpegts.c:427
int extended_stream_id
Definition: mpegts.c:172
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:100
LIBAVUTIL_VERSION_INT
Definition: eval.c:52
int stream_type
Definition: mpegts.c:161
int auto_guess
if true, all pids are analyzed to find streams
Definition: mpegts.c:102
int raw_packet_size
raw packet size, including FEC if present
Definition: mpegts.c:97
static const StreamType ISO_types[]
Definition: mpegts.c:516
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:536
Stream structure.
Definition: avformat.h:622
FAKE codec to indicate a MPEG-4 Systems stream (only used by libavformat)
Definition: avcodec.h:432
NULL
Definition: eval.c:52
#define TS_MAX_PACKET_SIZE
Definition: mpegts.h:30
uint8_t * dec_config_descr
Definition: mpegts.h:88
enum AVMediaType codec_type
Definition: avcodec.h:1347
unsigned int id
Definition: mpegts.c:87
#define MP4DecConfigDescrTag
Definition: isom.h:165
enum AVCodecID codec_id
Definition: avcodec.h:1350
static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
Definition: mpegts.c:2084
#define hex_dump_debug(class, buf, size)
Definition: internal.h:32
AVIOContext * pb
I/O context.
Definition: avformat.h:861
int pos47
Definition: mpegts.c:99
av_default_item_name
Definition: dnxhdenc.c:43
void av_destruct_packet(AVPacket *pkt)
Default packet destructor.
Definition: avpacket.c:28
int use_au_end
Definition: mpegts.h:70
static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:997
static void new_pes_packet(PESContext *pes, AVPacket *pkt)
Definition: mpegts.c:634
static int get_packet_size(const uint8_t *buf, int size)
Definition: mpegts.c:404
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1365
#define STREAM_TYPE_PRIVATE_DATA
Definition: mpeg.h:53
static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: mpegts.c:2045
#define MAX_PES_HEADER_SIZE
Definition: mpegts.c:156
static int get8(const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:431
int extradata_size
Definition: avcodec.h:1455
#define MAX_LEVEL
Definition: mpegts.c:955
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:63
#define MAX_PIDS_PER_PROGRAM
Definition: mpegts.c:85
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet)
Definition: mpegts.c:1838
int use_timestamps
Definition: mpegts.h:73
Describe the class of an AVClass context structure.
Definition: log.h:33
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
int index
Definition: gxfenc.c:72
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:2005
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1355
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
AVMediaType
Definition: avutil.h:177
static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
Definition: mpegts.c:358
static const StreamType DESC_types[]
Definition: mpegts.c:561
This structure contains the data a format has to probe a file.
Definition: avformat.h:338
int use_idle
Definition: mpegts.h:74
SLConfigDescr sl
Definition: mpegts.c:177
int dec_config_descr_len
Definition: mpegts.h:87
uint8_t * section_buf
Definition: mpegts.c:67
uint8_t tid
Definition: mpegts.c:424
AVDictionary * metadata
Definition: avformat.h:806
unsigned int end_of_section_reached
Definition: mpegts.c:69
int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type, const uint8_t **pp, const uint8_t *desc_list_end, Mp4Descr *mp4_descr, int mp4_descr_count, int pid, MpegTSContext *ts)
Parse an MPEG-2 descriptor.
Definition: mpegts.c:1231
static void clear_programs(MpegTSContext *ts)
Definition: mpegts.c:191
static const AVOption options[]
Definition: mpegts.c:130
full parsing and repack
Definition: avformat.h:576
AVFormatContext * stream
Definition: mpegts.c:163
Main libavformat public API header.
static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1500
int ff_mp4_read_descr(AVFormatContext *fc, AVIOContext *pb, int *tag)
Definition: isom.c:374
void ff_mpegts_parse_close(MpegTSContext *ts)
Definition: mpegts.c:2151
int use_rand_acc_pt
Definition: mpegts.h:71
int data_index
Definition: mpegts.c:168
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:70
void * av_realloc(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:116
int64_t start_time
Decoding: pts of the first frame of the stream, in stream time base.
Definition: avformat.h:677
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:688
uint8_t header[MAX_PES_HEADER_SIZE]
Definition: mpegts.c:175
static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size)
Definition: mpegts.c:1743
#define MAX_PES_PAYLOAD
Definition: mpegts.c:42
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:42
struct AVInputFormat * iformat
Can only be iformat or oformat, not both at the same time.
Definition: avformat.h:841
PESCallback * pes_cb
Definition: mpegts.c:56
struct MpegTSContext MpegTSContext
Definition: mpegts.h:61
struct MpegTSSectionFilter MpegTSSectionFilter
static MpegTSFilter * mpegts_open_section_filter(MpegTSContext *ts, unsigned int pid, SectionCallback *section_cb, void *opaque, int check_crc)
Definition: mpegts.c:303
FAKE codec to indicate a raw MPEG-2 TS stream (only used by libavformat)
Definition: avcodec.h:430
unsigned int nb_pids
Definition: mpegts.c:88
void * opaque
Definition: mpegts.c:57
static int get16(const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:444
int eof_reached
true if eof reached
Definition: avio.h:96
Mp4Descr * active_descr
Definition: mpegts.c:960
AVPacket * pkt
packet containing Audio/Video data
Definition: mpegts.c:114
int len
#define PAT_PID
Definition: mpegts.h:36
void * priv_data
Format private data.
Definition: avformat.h:848
int64_t last_pos
to detect seek
Definition: mpegts.c:116
int timestamp_res
Definition: mpegts.h:75
static int analyze(const uint8_t *buf, int size, int packet_size, int *index)
Definition: mpegts.c:379
#define PES_HEADER_SIZE
Definition: mpegts.c:155
static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned int pid)
Definition: mpegts.c:210
int64_t pts
Definition: mpegts.c:173
int use_padding
Definition: mpegts.h:72
void SetServiceCallback(void *opaque, int ret)
Definition: mpegts.c:62
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:914
int bit_rate
Decoding: total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:900
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:455
int degr_prior_len
Definition: mpegts.h:80
static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1007
static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1167
AVIOContext pb
Definition: mpegts.c:958
int stream_index
Definition: avcodec.h:917
MpegTSFilterType
Definition: mpegts.c:46
union MpegTSFilter::@96 u
#define MAX_MP4_DESCR_COUNT
Definition: mpegts.c:44
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:690
static void mpegts_find_stream_type(AVStream *st, uint32_t stream_type, const StreamType *types)
Definition: mpegts.c:570
int au_len
Definition: mpegts.h:78
This structure stores compressed data.
Definition: avcodec.h:898
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:158
uint32_t stream_type
Definition: mpegts.c:511
static char * getstr8(const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:459
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:908
A dummy ID pointing at the start of subtitle codecs.
Definition: avcodec.h:413
int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
Perform a binary search using av_index_search_timestamp() and AVInputFormat.read_timestamp().
Definition: utils.c:1442
AVProgram ** programs
Definition: avformat.h:931
#define MP4SLDescrTag
Definition: isom.h:167
#define NB_PID_MAX
Definition: mpegts.h:32
#define SDT_TID
Definition: mpegts.h:43
void SectionCallback(MpegTSFilter *f, const uint8_t *buf, int len)
Definition: mpegts.c:60
uint8_t * buffer
Definition: mpegts.c:176
AVStream * sub_st
stream for the embedded AC3 stream in HDMV TrueHD
Definition: mpegts.c:165
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)
MpegTSContext * ts
Definition: mpegts.c:162
static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size, Mp4Descr *descr, int *descr_count, int max_descr_count)
Definition: mpegts.c:1141