FFmpeg
mpegts.c
Go to the documentation of this file.
1 /*
2  * MPEG-2 transport stream (aka DVB) demuxer
3  * Copyright (c) 2002-2003 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg 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  * FFmpeg 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 FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "config_components.h"
23 
24 #include "libavutil/buffer.h"
25 #include "libavutil/crc.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/log.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/mem.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/dovi_meta.h"
34 #include "libavcodec/bytestream.h"
35 #include "libavcodec/defs.h"
36 #include "libavcodec/get_bits.h"
37 #include "libavcodec/opus.h"
38 #include "avformat.h"
39 #include "mpegts.h"
40 #include "internal.h"
41 #include "avio_internal.h"
42 #include "demux.h"
43 #include "mpeg.h"
44 #include "isom.h"
45 #if CONFIG_ICONV
46 #include <iconv.h>
47 #endif
48 
49 /* maximum size in which we look for synchronization if
50  * synchronization is lost */
51 #define MAX_RESYNC_SIZE 65536
52 
53 #define MAX_MP4_DESCR_COUNT 16
54 
55 #define MOD_UNLIKELY(modulus, dividend, divisor, prev_dividend) \
56  do { \
57  if ((prev_dividend) == 0 || (dividend) - (prev_dividend) != (divisor)) \
58  (modulus) = (dividend) % (divisor); \
59  (prev_dividend) = (dividend); \
60  } while (0)
61 
62 #define PROBE_PACKET_MAX_BUF 8192
63 #define PROBE_PACKET_MARGIN 5
64 
69 };
70 
71 typedef struct MpegTSFilter MpegTSFilter;
72 
73 typedef int PESCallback (MpegTSFilter *f, const uint8_t *buf, int len,
74  int is_start, int64_t pos);
75 
76 typedef struct MpegTSPESFilter {
78  void *opaque;
80 
81 typedef void SectionCallback (MpegTSFilter *f, const uint8_t *buf, int len);
82 
83 typedef void SetServiceCallback (void *opaque, int ret);
84 
85 typedef struct MpegTSSectionFilter {
88  int last_ver;
89  unsigned crc;
90  unsigned last_crc;
91  uint8_t *section_buf;
92  unsigned int check_crc : 1;
93  unsigned int end_of_section_reached : 1;
95  void *opaque;
97 
98 struct MpegTSFilter {
99  int pid;
100  int es_id;
101  int last_cc; /* last cc code (-1 if first packet) */
103  int discard;
105  union {
108  } u;
109 };
110 
111 struct Stream {
112  int idx;
114 };
115 
116 #define MAX_STREAMS_PER_PROGRAM 128
117 #define MAX_PIDS_PER_PROGRAM (MAX_STREAMS_PER_PROGRAM + 2)
118 struct Program {
119  unsigned int id; // program id/service id
120  unsigned int nb_pids;
121  unsigned int pids[MAX_PIDS_PER_PROGRAM];
122  unsigned int nb_streams;
124 
125  /** have we found pmt for this program */
127 };
128 
130  const AVClass *class;
131  /* user data */
133  /** raw packet size, including FEC if present */
135 
137 
138  /** if true, all pids are analyzed to find streams */
140 
141  /** compute exact PCR for each transport stream packet */
143 
144  /** fix dvb teletext pts */
146 
147  int64_t cur_pcr; /**< used to estimate the exact PCR */
148  int64_t pcr_incr; /**< used to estimate the exact PCR */
149 
150  /* data needed to handle file based ts */
151  /** stop parsing loop */
153  /** packet containing Audio/Video data */
155  /** to detect seek */
157 
161 
163 
167 
168  int id;
169 
170  /******************************************/
171  /* private mpegts data */
172  /* scan context */
173  /** structure to keep track of Program->pids mapping */
174  unsigned int nb_prg;
175  struct Program *prg;
176 
178  /** filters for various streams specified by PMT + for the PAT and PMT */
181 
184 };
185 
186 #define MPEGTS_OPTIONS \
187  { "resync_size", "set size limit for looking up a new synchronization", \
188  offsetof(MpegTSContext, resync_size), AV_OPT_TYPE_INT, \
189  { .i64 = MAX_RESYNC_SIZE}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM }, \
190  { "ts_id", "transport stream id", \
191  offsetof(MpegTSContext, id), AV_OPT_TYPE_INT, \
192  { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY }, \
193  { "ts_packetsize", "output option carrying the raw packet size", \
194  offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT, \
195  { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY }
196 
197 static const AVOption options[] = {
199  {"fix_teletext_pts", "try to fix pts values of dvb teletext streams", offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_BOOL,
200  {.i64 = 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
201  {"scan_all_pmts", "scan and combine all PMTs", offsetof(MpegTSContext, scan_all_pmts), AV_OPT_TYPE_BOOL,
202  {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM },
203  {"skip_unknown_pmt", "skip PMTs for programs not advertised in the PAT", offsetof(MpegTSContext, skip_unknown_pmt), AV_OPT_TYPE_BOOL,
204  {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
205  {"merge_pmt_versions", "re-use streams when PMT's version/pids change", offsetof(MpegTSContext, merge_pmt_versions), AV_OPT_TYPE_BOOL,
206  {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
207  {"skip_changes", "skip changing / adding streams / programs", offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_BOOL,
208  {.i64 = 0}, 0, 1, 0 },
209  {"skip_clear", "skip clearing programs", offsetof(MpegTSContext, skip_clear), AV_OPT_TYPE_BOOL,
210  {.i64 = 0}, 0, 1, 0 },
211  {"max_packet_size", "maximum size of emitted packet", offsetof(MpegTSContext, max_packet_size), AV_OPT_TYPE_INT,
212  {.i64 = 204800}, 1, INT_MAX/2, AV_OPT_FLAG_DECODING_PARAM },
213  { NULL },
214 };
215 
216 static const AVClass mpegts_class = {
217  .class_name = "mpegts demuxer",
218  .item_name = av_default_item_name,
219  .option = options,
220  .version = LIBAVUTIL_VERSION_INT,
221 };
222 
223 static const AVOption raw_options[] = {
225  { "compute_pcr", "compute exact PCR for each transport stream packet",
226  offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_BOOL,
227  { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
228  { NULL },
229 };
230 
231 static const AVClass mpegtsraw_class = {
232  .class_name = "mpegtsraw demuxer",
233  .item_name = av_default_item_name,
234  .option = raw_options,
235  .version = LIBAVUTIL_VERSION_INT,
236 };
237 
238 /* TS stream handling */
239 
246 };
247 
248 /* enough for PES header + length */
249 #define PES_START_SIZE 6
250 #define PES_HEADER_SIZE 9
251 #define MAX_PES_HEADER_SIZE (9 + 255)
252 
253 typedef struct PESContext {
254  int pid;
255  int pcr_pid; /**< if -1 then all packets containing PCR are considered */
260  AVStream *sub_st; /**< stream for the embedded AC3 stream in HDMV TrueHD */
262  /* used to get the format */
264  int flags; /**< copied to the AVPacket flags */
268  uint8_t stream_id;
270  int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */
275 } PESContext;
276 
277 extern const FFInputFormat ff_mpegts_demuxer;
278 
279 static struct Program * get_program(MpegTSContext *ts, unsigned int programid)
280 {
281  int i;
282  for (i = 0; i < ts->nb_prg; i++) {
283  if (ts->prg[i].id == programid) {
284  return &ts->prg[i];
285  }
286  }
287  return NULL;
288 }
289 
290 static void clear_avprogram(MpegTSContext *ts, unsigned int programid)
291 {
292  AVProgram *prg = NULL;
293  int i;
294 
295  for (i = 0; i < ts->stream->nb_programs; i++)
296  if (ts->stream->programs[i]->id == programid) {
297  prg = ts->stream->programs[i];
298  break;
299  }
300  if (!prg)
301  return;
302  prg->nb_stream_indexes = 0;
303 }
304 
305 static void clear_program(struct Program *p)
306 {
307  if (!p)
308  return;
309  p->nb_pids = 0;
310  p->nb_streams = 0;
311  p->pmt_found = 0;
312 }
313 
315 {
316  av_freep(&ts->prg);
317  ts->nb_prg = 0;
318 }
319 
320 static struct Program * add_program(MpegTSContext *ts, unsigned int programid)
321 {
322  struct Program *p = get_program(ts, programid);
323  if (p)
324  return p;
325  if (av_reallocp_array(&ts->prg, ts->nb_prg + 1, sizeof(*ts->prg)) < 0) {
326  ts->nb_prg = 0;
327  return NULL;
328  }
329  p = &ts->prg[ts->nb_prg];
330  p->id = programid;
331  clear_program(p);
332  ts->nb_prg++;
333  return p;
334 }
335 
336 static void add_pid_to_program(struct Program *p, unsigned int pid)
337 {
338  int i;
339  if (!p)
340  return;
341 
342  if (p->nb_pids >= MAX_PIDS_PER_PROGRAM)
343  return;
344 
345  for (i = 0; i < p->nb_pids; i++)
346  if (p->pids[i] == pid)
347  return;
348 
349  p->pids[p->nb_pids++] = pid;
350 }
351 
352 static void update_av_program_info(AVFormatContext *s, unsigned int programid,
353  unsigned int pid, int version)
354 {
355  int i;
356  for (i = 0; i < s->nb_programs; i++) {
357  AVProgram *program = s->programs[i];
358  if (program->id == programid) {
359  int old_pcr_pid = program->pcr_pid,
360  old_version = program->pmt_version;
361  program->pcr_pid = pid;
362  program->pmt_version = version;
363 
364  if (old_version != -1 && old_version != version) {
366  "detected PMT change (program=%d, version=%d/%d, pcr_pid=0x%x/0x%x)\n",
367  programid, old_version, version, old_pcr_pid, pid);
368  }
369  break;
370  }
371  }
372 }
373 
374 /**
375  * @brief discard_pid() decides if the pid is to be discarded according
376  * to caller's programs selection
377  * @param ts : - TS context
378  * @param pid : - pid
379  * @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
380  * 0 otherwise
381  */
382 static int discard_pid(MpegTSContext *ts, unsigned int pid)
383 {
384  int i, j, k;
385  int used = 0, discarded = 0;
386  struct Program *p;
387 
388  if (pid == PAT_PID)
389  return 0;
390 
391  /* If none of the programs have .discard=AVDISCARD_ALL then there's
392  * no way we have to discard this packet */
393  for (k = 0; k < ts->stream->nb_programs; k++)
394  if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
395  break;
396  if (k == ts->stream->nb_programs)
397  return 0;
398 
399  for (i = 0; i < ts->nb_prg; i++) {
400  p = &ts->prg[i];
401  for (j = 0; j < p->nb_pids; j++) {
402  if (p->pids[j] != pid)
403  continue;
404  // is program with id p->id set to be discarded?
405  for (k = 0; k < ts->stream->nb_programs; k++) {
406  if (ts->stream->programs[k]->id == p->id) {
407  if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
408  discarded++;
409  else
410  used++;
411  }
412  }
413  }
414  }
415 
416  return !used && discarded;
417 }
418 
419 /**
420  * Assemble PES packets out of TS packets, and then call the "section_cb"
421  * function when they are complete.
422  */
424  const uint8_t *buf, int buf_size, int is_start)
425 {
426  MpegTSSectionFilter *tss = &tss1->u.section_filter;
427  uint8_t *cur_section_buf = NULL;
428  int len, offset;
429 
430  if (is_start) {
431  memcpy(tss->section_buf, buf, buf_size);
432  tss->section_index = buf_size;
433  tss->section_h_size = -1;
434  tss->end_of_section_reached = 0;
435  } else {
436  if (tss->end_of_section_reached)
437  return;
439  if (buf_size < len)
440  len = buf_size;
441  memcpy(tss->section_buf + tss->section_index, buf, len);
442  tss->section_index += len;
443  }
444 
445  offset = 0;
446  cur_section_buf = tss->section_buf;
447  while (cur_section_buf - tss->section_buf < MAX_SECTION_SIZE && cur_section_buf[0] != 0xff) {
448  /* compute section length if possible */
449  if (tss->section_h_size == -1 && tss->section_index - offset >= 3) {
450  len = (AV_RB16(cur_section_buf + 1) & 0xfff) + 3;
451  if (len > MAX_SECTION_SIZE)
452  return;
453  tss->section_h_size = len;
454  }
455 
456  if (tss->section_h_size != -1 &&
457  tss->section_index >= offset + tss->section_h_size) {
458  int crc_valid = 1;
459  tss->end_of_section_reached = 1;
460 
461  if (tss->check_crc) {
462  crc_valid = !av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, cur_section_buf, tss->section_h_size);
463  if (tss->section_h_size >= 4)
464  tss->crc = AV_RB32(cur_section_buf + tss->section_h_size - 4);
465 
466  if (crc_valid) {
467  ts->crc_validity[ tss1->pid ] = 100;
468  }else if (ts->crc_validity[ tss1->pid ] > -10) {
469  ts->crc_validity[ tss1->pid ]--;
470  }else
471  crc_valid = 2;
472  }
473  if (crc_valid) {
474  tss->section_cb(tss1, cur_section_buf, tss->section_h_size);
475  if (crc_valid != 1)
476  tss->last_ver = -1;
477  }
478 
479  cur_section_buf += tss->section_h_size;
480  offset += tss->section_h_size;
481  tss->section_h_size = -1;
482  } else {
483  tss->section_h_size = -1;
484  tss->end_of_section_reached = 0;
485  break;
486  }
487  }
488 }
489 
490 static MpegTSFilter *mpegts_open_filter(MpegTSContext *ts, unsigned int pid,
491  enum MpegTSFilterType type)
492 {
494 
495  av_log(ts->stream, AV_LOG_TRACE, "Filter: pid=0x%x type=%d\n", pid, type);
496 
497  if (pid >= NB_PID_MAX || ts->pids[pid])
498  return NULL;
499  filter = av_mallocz(sizeof(MpegTSFilter));
500  if (!filter)
501  return NULL;
502  ts->pids[pid] = filter;
503 
504  filter->type = type;
505  filter->pid = pid;
506  filter->es_id = -1;
507  filter->last_cc = -1;
508  filter->last_pcr= -1;
509 
510  return filter;
511 }
512 
514  unsigned int pid,
515  SectionCallback *section_cb,
516  void *opaque,
517  int check_crc)
518 {
520  MpegTSSectionFilter *sec;
521  uint8_t *section_buf = av_mallocz(MAX_SECTION_SIZE);
522 
523  if (!section_buf)
524  return NULL;
525 
526  if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_SECTION))) {
527  av_free(section_buf);
528  return NULL;
529  }
530  sec = &filter->u.section_filter;
531  sec->section_cb = section_cb;
532  sec->opaque = opaque;
533  sec->section_buf = section_buf;
534  sec->check_crc = check_crc;
535  sec->last_ver = -1;
536 
537  return filter;
538 }
539 
540 static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
541  PESCallback *pes_cb,
542  void *opaque)
543 {
545  MpegTSPESFilter *pes;
546 
547  if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_PES)))
548  return NULL;
549 
550  pes = &filter->u.pes_filter;
551  pes->pes_cb = pes_cb;
552  pes->opaque = opaque;
553  return filter;
554 }
555 
556 static MpegTSFilter *mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid)
557 {
558  return mpegts_open_filter(ts, pid, MPEGTS_PCR);
559 }
560 
562 {
563  int pid;
564 
565  pid = filter->pid;
566  if (filter->type == MPEGTS_SECTION)
567  av_freep(&filter->u.section_filter.section_buf);
568  else if (filter->type == MPEGTS_PES) {
569  PESContext *pes = filter->u.pes_filter.opaque;
570  av_buffer_unref(&pes->buffer);
571  /* referenced private data will be freed later in
572  * avformat_close_input (pes->st->priv_data == pes) */
573  if (!pes->st || pes->merged_st) {
574  av_freep(&filter->u.pes_filter.opaque);
575  }
576  }
577 
578  av_free(filter);
579  ts->pids[pid] = NULL;
580 }
581 
582 static int analyze(const uint8_t *buf, int size, int packet_size,
583  int probe)
584 {
585  int stat[TS_MAX_PACKET_SIZE];
586  int stat_all = 0;
587  int i;
588  int best_score = 0;
589 
590  memset(stat, 0, packet_size * sizeof(*stat));
591 
592  for (i = 0; i < size - 3; i++) {
593  if (buf[i] == 0x47) {
594  int pid = AV_RB16(buf+1) & 0x1FFF;
595  int asc = buf[i + 3] & 0x30;
596  if (!probe || pid == 0x1FFF || asc) {
597  int x = i % packet_size;
598  stat[x]++;
599  stat_all++;
600  if (stat[x] > best_score) {
601  best_score = stat[x];
602  }
603  }
604  }
605  }
606 
607  return best_score - FFMAX(stat_all - 10*best_score, 0)/10;
608 }
609 
610 /* autodetect fec presence */
612 {
613  int score, fec_score, dvhs_score;
614  int margin;
615  int ret;
616 
617  /*init buffer to store stream for probing */
618  uint8_t buf[PROBE_PACKET_MAX_BUF] = {0};
619  int buf_size = 0;
620  int max_iterations = 16;
621 
622  while (buf_size < PROBE_PACKET_MAX_BUF && max_iterations--) {
623  ret = avio_read_partial(s->pb, buf + buf_size, PROBE_PACKET_MAX_BUF - buf_size);
624  if (ret < 0)
625  return AVERROR_INVALIDDATA;
626  buf_size += ret;
627 
628  score = analyze(buf, buf_size, TS_PACKET_SIZE, 0);
629  dvhs_score = analyze(buf, buf_size, TS_DVHS_PACKET_SIZE, 0);
630  fec_score = analyze(buf, buf_size, TS_FEC_PACKET_SIZE, 0);
631  av_log(s, AV_LOG_TRACE, "Probe: %d, score: %d, dvhs_score: %d, fec_score: %d \n",
632  buf_size, score, dvhs_score, fec_score);
633 
634  margin = mid_pred(score, fec_score, dvhs_score);
635 
636  if (buf_size < PROBE_PACKET_MAX_BUF)
637  margin += PROBE_PACKET_MARGIN; /*if buffer not filled */
638 
639  if (score > margin)
640  return TS_PACKET_SIZE;
641  else if (dvhs_score > margin)
642  return TS_DVHS_PACKET_SIZE;
643  else if (fec_score > margin)
644  return TS_FEC_PACKET_SIZE;
645  }
646  return AVERROR_INVALIDDATA;
647 }
648 
649 typedef struct SectionHeader {
650  uint8_t tid;
651  uint16_t id;
652  uint8_t version;
653  uint8_t current_next;
654  uint8_t sec_num;
655  uint8_t last_sec_num;
656 } SectionHeader;
657 
659 {
660  if (h->version == tssf->last_ver && tssf->last_crc == tssf->crc)
661  return 1;
662 
663  tssf->last_ver = h->version;
664  tssf->last_crc = tssf->crc;
665 
666  return 0;
667 }
668 
669 static inline int get8(const uint8_t **pp, const uint8_t *p_end)
670 {
671  const uint8_t *p;
672  int c;
673 
674  p = *pp;
675  if (p >= p_end)
676  return AVERROR_INVALIDDATA;
677  c = *p++;
678  *pp = p;
679  return c;
680 }
681 
682 static inline int get16(const uint8_t **pp, const uint8_t *p_end)
683 {
684  const uint8_t *p;
685  int c;
686 
687  p = *pp;
688  if (1 >= p_end - p)
689  return AVERROR_INVALIDDATA;
690  c = AV_RB16(p);
691  p += 2;
692  *pp = p;
693  return c;
694 }
695 
696 /* read and allocate a DVB string preceded by its length */
697 static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
698 {
699  int len;
700  const uint8_t *p;
701  char *str;
702 
703  p = *pp;
704  len = get8(&p, p_end);
705  if (len < 0)
706  return NULL;
707  if (len > p_end - p)
708  return NULL;
709 #if CONFIG_ICONV
710  if (len) {
711  const char *encodings[] = {
712  "ISO6937", "ISO-8859-5", "ISO-8859-6", "ISO-8859-7",
713  "ISO-8859-8", "ISO-8859-9", "ISO-8859-10", "ISO-8859-11",
714  "", "ISO-8859-13", "ISO-8859-14", "ISO-8859-15", "", "", "", "",
715  "", "UCS-2BE", "KSC_5601", "GB2312", "UCS-2BE", "UTF-8", "", "",
716  "", "", "", "", "", "", "", ""
717  };
718  iconv_t cd;
719  char *in, *out;
720  size_t inlen = len, outlen = inlen * 6 + 1;
721  if (len >= 3 && p[0] == 0x10 && !p[1] && p[2] && p[2] <= 0xf && p[2] != 0xc) {
722  char iso8859[12];
723  snprintf(iso8859, sizeof(iso8859), "ISO-8859-%d", p[2]);
724  inlen -= 3;
725  in = (char *)p + 3;
726  cd = iconv_open("UTF-8", iso8859);
727  } else if (p[0] < 0x20) {
728  inlen -= 1;
729  in = (char *)p + 1;
730  cd = iconv_open("UTF-8", encodings[*p]);
731  } else {
732  in = (char *)p;
733  cd = iconv_open("UTF-8", encodings[0]);
734  }
735  if (cd == (iconv_t)-1)
736  goto no_iconv;
737  str = out = av_malloc(outlen);
738  if (!str) {
739  iconv_close(cd);
740  return NULL;
741  }
742  if (iconv(cd, &in, &inlen, &out, &outlen) == -1) {
743  iconv_close(cd);
744  av_freep(&str);
745  goto no_iconv;
746  }
747  iconv_close(cd);
748  *out = 0;
749  *pp = p + len;
750  return str;
751  }
752 no_iconv:
753 #endif
754  str = av_malloc(len + 1);
755  if (!str)
756  return NULL;
757  memcpy(str, p, len);
758  str[len] = '\0';
759  p += len;
760  *pp = p;
761  return str;
762 }
763 
765  const uint8_t **pp, const uint8_t *p_end)
766 {
767  int val;
768 
769  val = get8(pp, p_end);
770  if (val < 0)
771  return val;
772  h->tid = val;
773  *pp += 2;
774  val = get16(pp, p_end);
775  if (val < 0)
776  return val;
777  h->id = val;
778  val = get8(pp, p_end);
779  if (val < 0)
780  return val;
781  h->version = (val >> 1) & 0x1f;
782  h->current_next = val & 0x01;
783  val = get8(pp, p_end);
784  if (val < 0)
785  return val;
786  h->sec_num = val;
787  val = get8(pp, p_end);
788  if (val < 0)
789  return val;
790  h->last_sec_num = val;
791  return 0;
792 }
793 
794 typedef struct StreamType {
795  uint32_t stream_type;
798 } StreamType;
799 
800 static const StreamType ISO_types[] = {
807  /* Makito encoder sets stream type 0x11 for AAC,
808  * so auto-detect LOAS/LATM instead of hardcoding it. */
809 #if !CONFIG_LOAS_DEMUXER
810  { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM }, /* LATM syntax */
811 #endif
823  { 0 },
824 };
825 
826 static const StreamType HDMV_types[] = {
832  { 0x85, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD */
833  { 0x86, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD MASTER*/
834  { 0xa1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC3 Secondary Audio */
835  { 0xa2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS Express Secondary Audio */
838  { 0 },
839 };
840 
841 /* SCTE types */
842 static const StreamType SCTE_types[] = {
844  { 0 },
845 };
846 
847 /* ATSC ? */
848 static const StreamType MISC_types[] = {
851  { 0 },
852 };
853 
854 /* HLS Sample Encryption Types */
860  { 0 },
861 };
862 
863 static const StreamType REGD_types[] = {
864  { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
865  { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
866  { MKTAG('A', 'C', '-', '4'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC4 },
867  { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M },
868  { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
869  { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
870  { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
871  { MKTAG('E', 'A', 'C', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 },
872  { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC },
873  { MKTAG('V', 'V', 'C', ' '), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VVC },
874  { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
875  { MKTAG('V', 'A', 'N', 'C'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_2038 },
876  { MKTAG('I', 'D', '3', ' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
877  { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },
878  { MKTAG('O', 'p', 'u', 's'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_OPUS },
879  { 0 },
880 };
881 
882 static const StreamType METADATA_types[] = {
883  { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
884  { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
885  { 0 },
886 };
887 
888 /* descriptor present */
889 static const StreamType DESC_types[] = {
890  { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */
891  { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
894  { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
895  { 0 },
896 };
897 
899  uint32_t stream_type,
900  const StreamType *types)
901 {
902  FFStream *const sti = ffstream(st);
903  for (; types->stream_type; types++)
904  if (stream_type == types->stream_type) {
905  if (st->codecpar->codec_type != types->codec_type ||
906  st->codecpar->codec_id != types->codec_id) {
907  st->codecpar->codec_type = types->codec_type;
908  st->codecpar->codec_id = types->codec_id;
909  sti->need_context_update = 1;
910  }
911  sti->request_probe = 0;
912  return;
913  }
914 }
915 
917  uint32_t stream_type, uint32_t prog_reg_desc)
918 {
919  FFStream *const sti = ffstream(st);
920  int old_codec_type = st->codecpar->codec_type;
921  int old_codec_id = st->codecpar->codec_id;
922  int old_codec_tag = st->codecpar->codec_tag;
923 
924  avpriv_set_pts_info(st, 33, 1, 90000);
925  st->priv_data = pes;
929  pes->st = st;
930  pes->stream_type = stream_type;
931 
932  av_log(pes->stream, AV_LOG_DEBUG,
933  "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
934  st->index, pes->stream_type, pes->pid, (char *)&prog_reg_desc);
935 
936  st->codecpar->codec_tag = pes->stream_type;
937 
939  if (pes->stream_type == 4 || pes->stream_type == 0x0f)
940  sti->request_probe = 50;
941  if ((prog_reg_desc == AV_RL32("HDMV") ||
942  prog_reg_desc == AV_RL32("HDPR")) &&
945  if (pes->stream_type == 0x83) {
946  // HDMV TrueHD streams also contain an AC3 coded version of the
947  // audio track - add a second stream for this
948  AVStream *sub_st;
949  // priv_data cannot be shared between streams
950  PESContext *sub_pes = av_memdup(pes, sizeof(*sub_pes));
951  if (!sub_pes)
952  return AVERROR(ENOMEM);
953 
954  sub_st = avformat_new_stream(pes->stream, NULL);
955  if (!sub_st) {
956  av_free(sub_pes);
957  return AVERROR(ENOMEM);
958  }
959 
960  sub_st->id = pes->pid;
961  avpriv_set_pts_info(sub_st, 33, 1, 90000);
962  sub_st->priv_data = sub_pes;
964  sub_st->codecpar->codec_id = AV_CODEC_ID_AC3;
966  sub_pes->sub_st = pes->sub_st = sub_st;
967  }
968  }
969  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
971  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
973  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
974  st->codecpar->codec_id = old_codec_id;
975  st->codecpar->codec_type = old_codec_type;
976  }
977  if ((st->codecpar->codec_id == AV_CODEC_ID_NONE ||
978  (sti->request_probe > 0 && sti->request_probe < AVPROBE_SCORE_STREAM_RETRY / 5)) &&
979  sti->probe_packets > 0 &&
980  stream_type == STREAM_TYPE_PRIVATE_DATA) {
984  }
985 
986  /* queue a context update if properties changed */
987  if (old_codec_type != st->codecpar->codec_type ||
988  old_codec_id != st->codecpar->codec_id ||
989  old_codec_tag != st->codecpar->codec_tag)
990  sti->need_context_update = 1;
991 
992  return 0;
993 }
994 
996 {
997  pes->pts = AV_NOPTS_VALUE;
998  pes->dts = AV_NOPTS_VALUE;
999  pes->data_index = 0;
1000  pes->flags = 0;
1001  av_buffer_unref(&pes->buffer);
1002 }
1003 
1004 static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt)
1005 {
1007  pkt->data = (uint8_t *)buffer;
1008  pkt->size = len;
1009 }
1010 
1012 {
1013  uint8_t *sd;
1014 
1016 
1017  pkt->buf = pes->buffer;
1018  pkt->data = pes->buffer->data;
1019  pkt->size = pes->data_index;
1020 
1021  if (pes->PES_packet_length &&
1022  pes->pes_header_size + pes->data_index != pes->PES_packet_length +
1023  PES_START_SIZE) {
1024  av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n");
1025  pes->flags |= AV_PKT_FLAG_CORRUPT;
1026  }
1027  memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1028 
1029  // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
1030  if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76)
1031  pkt->stream_index = pes->sub_st->index;
1032  else
1033  pkt->stream_index = pes->st->index;
1034  pkt->pts = pes->pts;
1035  pkt->dts = pes->dts;
1036  /* store position of first TS packet of this PES packet */
1037  pkt->pos = pes->ts_packet_pos;
1038  pkt->flags = pes->flags;
1039 
1040  pes->buffer = NULL;
1042 
1044  if (!sd)
1045  return AVERROR(ENOMEM);
1046  *sd = pes->stream_id;
1047 
1048  return 0;
1049 }
1050 
1051 static uint64_t get_ts64(GetBitContext *gb, int bits)
1052 {
1053  if (get_bits_left(gb) < bits)
1054  return AV_NOPTS_VALUE;
1055  return get_bits64(gb, bits);
1056 }
1057 
1059  const uint8_t *buf, int buf_size)
1060 {
1061  GetBitContext gb;
1062  int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;
1063  int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;
1064  int dts_flag = -1, cts_flag = -1;
1065  int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE;
1066  uint8_t buf_padded[128 + AV_INPUT_BUFFER_PADDING_SIZE];
1067  int buf_padded_size = FFMIN(buf_size, sizeof(buf_padded) - AV_INPUT_BUFFER_PADDING_SIZE);
1068 
1069  memcpy(buf_padded, buf, buf_padded_size);
1070 
1071  init_get_bits(&gb, buf_padded, buf_padded_size * 8);
1072 
1073  if (sl->use_au_start)
1074  au_start_flag = get_bits1(&gb);
1075  if (sl->use_au_end)
1076  au_end_flag = get_bits1(&gb);
1077  if (!sl->use_au_start && !sl->use_au_end)
1078  au_start_flag = au_end_flag = 1;
1079  if (sl->ocr_len > 0)
1080  ocr_flag = get_bits1(&gb);
1081  if (sl->use_idle)
1082  idle_flag = get_bits1(&gb);
1083  if (sl->use_padding)
1084  padding_flag = get_bits1(&gb);
1085  if (padding_flag)
1086  padding_bits = get_bits(&gb, 3);
1087 
1088  if (!idle_flag && (!padding_flag || padding_bits != 0)) {
1089  if (sl->packet_seq_num_len)
1091  if (sl->degr_prior_len)
1092  if (get_bits1(&gb))
1093  skip_bits(&gb, sl->degr_prior_len);
1094  if (ocr_flag)
1095  skip_bits_long(&gb, sl->ocr_len);
1096  if (au_start_flag) {
1097  if (sl->use_rand_acc_pt)
1098  get_bits1(&gb);
1099  if (sl->au_seq_num_len > 0)
1100  skip_bits_long(&gb, sl->au_seq_num_len);
1101  if (sl->use_timestamps) {
1102  dts_flag = get_bits1(&gb);
1103  cts_flag = get_bits1(&gb);
1104  }
1105  }
1106  if (sl->inst_bitrate_len)
1107  inst_bitrate_flag = get_bits1(&gb);
1108  if (dts_flag == 1)
1109  dts = get_ts64(&gb, sl->timestamp_len);
1110  if (cts_flag == 1)
1111  cts = get_ts64(&gb, sl->timestamp_len);
1112  if (sl->au_len > 0)
1113  skip_bits_long(&gb, sl->au_len);
1114  if (inst_bitrate_flag)
1115  skip_bits_long(&gb, sl->inst_bitrate_len);
1116  }
1117 
1118  if (dts != AV_NOPTS_VALUE)
1119  pes->dts = dts;
1120  if (cts != AV_NOPTS_VALUE)
1121  pes->pts = cts;
1122 
1123  if (sl->timestamp_len && sl->timestamp_res)
1125 
1126  return (get_bits_count(&gb) + 7) >> 3;
1127 }
1128 
1130 {
1132  if (!ts->pools[index]) {
1133  int pool_size = FFMIN(ts->max_packet_size + AV_INPUT_BUFFER_PADDING_SIZE, 2 << index);
1134  ts->pools[index] = av_buffer_pool_init(pool_size, NULL);
1135  if (!ts->pools[index])
1136  return NULL;
1137  }
1138  return av_buffer_pool_get(ts->pools[index]);
1139 }
1140 
1141 /* return non zero if a packet could be constructed */
1143  const uint8_t *buf, int buf_size, int is_start,
1144  int64_t pos)
1145 {
1146  PESContext *pes = filter->u.pes_filter.opaque;
1147  MpegTSContext *ts = pes->ts;
1148  const uint8_t *p;
1149  int ret, len;
1150 
1151  if (!ts->pkt)
1152  return 0;
1153 
1154  if (is_start) {
1155  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
1156  ret = new_pes_packet(pes, ts->pkt);
1157  if (ret < 0)
1158  return ret;
1159  ts->stop_parse = 1;
1160  } else {
1162  }
1163  pes->state = MPEGTS_HEADER;
1164  pes->ts_packet_pos = pos;
1165  }
1166  p = buf;
1167  while (buf_size > 0) {
1168  switch (pes->state) {
1169  case MPEGTS_HEADER:
1170  len = PES_START_SIZE - pes->data_index;
1171  if (len > buf_size)
1172  len = buf_size;
1173  memcpy(pes->header + pes->data_index, p, len);
1174  pes->data_index += len;
1175  p += len;
1176  buf_size -= len;
1177  if (pes->data_index == PES_START_SIZE) {
1178  /* we got all the PES or section header. We can now
1179  * decide */
1180  if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
1181  pes->header[2] == 0x01) {
1182  /* it must be an MPEG-2 PES stream */
1183  pes->stream_id = pes->header[3];
1184  av_log(pes->stream, AV_LOG_TRACE, "pid=%x stream_id=%#x\n", pes->pid, pes->stream_id);
1185 
1186  if ((pes->st && pes->st->discard == AVDISCARD_ALL &&
1187  (!pes->sub_st ||
1188  pes->sub_st->discard == AVDISCARD_ALL)) ||
1190  goto skip;
1191 
1192  /* stream not present in PMT */
1193  if (!pes->st) {
1194  if (ts->skip_changes)
1195  goto skip;
1196  if (ts->merge_pmt_versions)
1197  goto skip; /* wait for PMT to merge new stream */
1198 
1199  pes->st = avformat_new_stream(ts->stream, NULL);
1200  if (!pes->st)
1201  return AVERROR(ENOMEM);
1202  pes->st->id = pes->pid;
1203  mpegts_set_stream_info(pes->st, pes, 0, 0);
1204  }
1205 
1206  pes->PES_packet_length = AV_RB16(pes->header + 4);
1207  /* NOTE: zero length means the PES size is unbounded */
1208 
1211  pes->stream_id != STREAM_ID_ECM_STREAM &&
1212  pes->stream_id != STREAM_ID_EMM_STREAM &&
1216  FFStream *const pes_sti = ffstream(pes->st);
1217  pes->state = MPEGTS_PESHEADER;
1218  if (pes->st->codecpar->codec_id == AV_CODEC_ID_NONE && !pes_sti->request_probe) {
1219  av_log(pes->stream, AV_LOG_TRACE,
1220  "pid=%x stream_type=%x probing\n",
1221  pes->pid,
1222  pes->stream_type);
1223  pes_sti->request_probe = 1;
1224  }
1225  } else {
1226  pes->pes_header_size = 6;
1227  pes->state = MPEGTS_PAYLOAD;
1228  pes->data_index = 0;
1229  }
1230  } else {
1231  /* otherwise, it should be a table */
1232  /* skip packet */
1233 skip:
1234  pes->state = MPEGTS_SKIP;
1235  continue;
1236  }
1237  }
1238  break;
1239  /**********************************************/
1240  /* PES packing parsing */
1241  case MPEGTS_PESHEADER:
1242  len = PES_HEADER_SIZE - pes->data_index;
1243  if (len < 0)
1244  return AVERROR_INVALIDDATA;
1245  if (len > buf_size)
1246  len = buf_size;
1247  memcpy(pes->header + pes->data_index, p, len);
1248  pes->data_index += len;
1249  p += len;
1250  buf_size -= len;
1251  if (pes->data_index == PES_HEADER_SIZE) {
1252  pes->pes_header_size = pes->header[8] + 9;
1254  }
1255  break;
1256  case MPEGTS_PESHEADER_FILL:
1257  len = pes->pes_header_size - pes->data_index;
1258  if (len < 0)
1259  return AVERROR_INVALIDDATA;
1260  if (len > buf_size)
1261  len = buf_size;
1262  memcpy(pes->header + pes->data_index, p, len);
1263  pes->data_index += len;
1264  p += len;
1265  buf_size -= len;
1266  if (pes->data_index == pes->pes_header_size) {
1267  const uint8_t *r;
1268  unsigned int flags, pes_ext, skip;
1269 
1270  flags = pes->header[7];
1271  r = pes->header + 9;
1272  pes->pts = AV_NOPTS_VALUE;
1273  pes->dts = AV_NOPTS_VALUE;
1274  if ((flags & 0xc0) == 0x80) {
1275  pes->dts = pes->pts = ff_parse_pes_pts(r);
1276  r += 5;
1277  } else if ((flags & 0xc0) == 0xc0) {
1278  pes->pts = ff_parse_pes_pts(r);
1279  r += 5;
1280  pes->dts = ff_parse_pes_pts(r);
1281  r += 5;
1282  }
1283  pes->extended_stream_id = -1;
1284  if (flags & 0x01) { /* PES extension */
1285  pes_ext = *r++;
1286  /* Skip PES private data, program packet sequence counter and P-STD buffer */
1287  skip = (pes_ext >> 4) & 0xb;
1288  skip += skip & 0x9;
1289  r += skip;
1290  if ((pes_ext & 0x41) == 0x01 &&
1291  (r + 2) <= (pes->header + pes->pes_header_size)) {
1292  /* PES extension 2 */
1293  if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)
1294  pes->extended_stream_id = r[1];
1295  }
1296  }
1297 
1298  /* we got the full header. We parse it and get the payload */
1299  pes->state = MPEGTS_PAYLOAD;
1300  pes->data_index = 0;
1301  if (pes->stream_type == 0x12 && buf_size > 0) {
1302  int sl_header_bytes = read_sl_header(pes, &pes->sl, p,
1303  buf_size);
1304  pes->pes_header_size += sl_header_bytes;
1305  p += sl_header_bytes;
1306  buf_size -= sl_header_bytes;
1307  }
1308  if (pes->stream_type == STREAM_TYPE_METADATA &&
1311  buf_size >= 5) {
1312  /* skip metadata access unit header - see MISB ST 1402 */
1313  pes->pes_header_size += 5;
1314  p += 5;
1315  buf_size -= 5;
1316  }
1317  if ( pes->ts->fix_teletext_pts
1320  ) {
1321  AVProgram *p = NULL;
1322  int pcr_found = 0;
1323  while ((p = av_find_program_from_stream(pes->stream, p, pes->st->index))) {
1324  if (p->pcr_pid != -1 && p->discard != AVDISCARD_ALL) {
1325  MpegTSFilter *f = pes->ts->pids[p->pcr_pid];
1326  if (f) {
1327  AVStream *st = NULL;
1328  if (f->type == MPEGTS_PES) {
1329  PESContext *pcrpes = f->u.pes_filter.opaque;
1330  if (pcrpes)
1331  st = pcrpes->st;
1332  } else if (f->type == MPEGTS_PCR) {
1333  int i;
1334  for (i = 0; i < p->nb_stream_indexes; i++) {
1335  AVStream *pst = pes->stream->streams[p->stream_index[i]];
1336  if (pst->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
1337  st = pst;
1338  }
1339  }
1340  if (f->last_pcr != -1 && !f->discard) {
1341  // teletext packets do not always have correct timestamps,
1342  // the standard says they should be handled after 40.6 ms at most,
1343  // and the pcr error to this packet should be no more than 100 ms.
1344  // TODO: we should interpolate the PCR, not just use the last one
1345  int64_t pcr = f->last_pcr / 300;
1346  pcr_found = 1;
1347  if (st) {
1348  const FFStream *const sti = ffstream(st);
1349  FFStream *const pes_sti = ffstream(pes->st);
1350 
1351  pes_sti->pts_wrap_reference = sti->pts_wrap_reference;
1352  pes_sti->pts_wrap_behavior = sti->pts_wrap_behavior;
1353  }
1354  if (pes->dts == AV_NOPTS_VALUE || pes->dts < pcr) {
1355  pes->pts = pes->dts = pcr;
1356  } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT &&
1357  pes->dts > pcr + 3654 + 9000) {
1358  pes->pts = pes->dts = pcr + 3654 + 9000;
1359  } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
1360  pes->dts > pcr + 10*90000) { //10sec
1361  pes->pts = pes->dts = pcr + 3654 + 9000;
1362  }
1363  break;
1364  }
1365  }
1366  }
1367  }
1368 
1369  if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT &&
1370  !pcr_found) {
1372  "Forcing DTS/PTS to be unset for a "
1373  "non-trustworthy PES packet for PID %d as "
1374  "PCR hasn't been received yet.\n",
1375  pes->pid);
1376  pes->dts = pes->pts = AV_NOPTS_VALUE;
1377  }
1378  }
1379  }
1380  break;
1381  case MPEGTS_PAYLOAD:
1382  do {
1383  int max_packet_size = ts->max_packet_size;
1385  max_packet_size = pes->PES_packet_length + PES_START_SIZE - pes->pes_header_size;
1386 
1387  if (pes->data_index > 0 &&
1388  pes->data_index + buf_size > max_packet_size) {
1389  ret = new_pes_packet(pes, ts->pkt);
1390  if (ret < 0)
1391  return ret;
1392  pes->PES_packet_length = 0;
1393  max_packet_size = ts->max_packet_size;
1394  ts->stop_parse = 1;
1395  } else if (pes->data_index == 0 &&
1396  buf_size > max_packet_size) {
1397  // pes packet size is < ts size packet and pes data is padded with 0xff
1398  // not sure if this is legal in ts but see issue #2392
1399  buf_size = max_packet_size;
1400  }
1401 
1402  if (!pes->buffer) {
1403  pes->buffer = buffer_pool_get(ts, max_packet_size);
1404  if (!pes->buffer)
1405  return AVERROR(ENOMEM);
1406  }
1407 
1408  memcpy(pes->buffer->data + pes->data_index, p, buf_size);
1409  pes->data_index += buf_size;
1410  /* emit complete packets with known packet size
1411  * decreases demuxer delay for infrequent packets like subtitles from
1412  * a couple of seconds to milliseconds for properly muxed files. */
1413  if (!ts->stop_parse && pes->PES_packet_length &&
1415  ts->stop_parse = 1;
1416  ret = new_pes_packet(pes, ts->pkt);
1417  pes->state = MPEGTS_SKIP;
1418  if (ret < 0)
1419  return ret;
1420  }
1421  } while (0);
1422  buf_size = 0;
1423  break;
1424  case MPEGTS_SKIP:
1425  buf_size = 0;
1426  break;
1427  }
1428  }
1429 
1430  return 0;
1431 }
1432 
1433 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
1434 {
1435  MpegTSFilter *tss;
1436  PESContext *pes;
1437 
1438  /* if no pid found, then add a pid context */
1439  pes = av_mallocz(sizeof(PESContext));
1440  if (!pes)
1441  return 0;
1442  pes->ts = ts;
1443  pes->stream = ts->stream;
1444  pes->pid = pid;
1445  pes->pcr_pid = pcr_pid;
1446  pes->state = MPEGTS_SKIP;
1447  pes->pts = AV_NOPTS_VALUE;
1448  pes->dts = AV_NOPTS_VALUE;
1449  tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
1450  if (!tss) {
1451  av_free(pes);
1452  return 0;
1453  }
1454  return pes;
1455 }
1456 
1457 #define MAX_LEVEL 4
1458 typedef struct MP4DescrParseContext {
1465  int level;
1468 
1470  const uint8_t *buf, unsigned size,
1471  Mp4Descr *descr, int max_descr_count)
1472 {
1473  if (size > (1 << 30))
1474  return AVERROR_INVALIDDATA;
1475 
1476  ffio_init_read_context(&d->pb, buf, size);
1477 
1478  d->s = s;
1479  d->level = 0;
1480  d->descr_count = 0;
1481  d->descr = descr;
1482  d->active_descr = NULL;
1483  d->max_descr_count = max_descr_count;
1484 
1485  return 0;
1486 }
1487 
1488 static void update_offsets(AVIOContext *pb, int64_t *off, int *len)
1489 {
1490  int64_t new_off = avio_tell(pb);
1491  (*len) -= new_off - *off;
1492  *off = new_off;
1493 }
1494 
1495 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1496  int target_tag);
1497 
1499 {
1500  while (len > 0) {
1501  int ret = parse_mp4_descr(d, off, len, 0);
1502  if (ret < 0)
1503  return ret;
1504  update_offsets(&d->pb.pub, &off, &len);
1505  }
1506  return 0;
1507 }
1508 
1510 {
1511  AVIOContext *const pb = &d->pb.pub;
1512  avio_rb16(pb); // ID
1513  avio_r8(pb);
1514  avio_r8(pb);
1515  avio_r8(pb);
1516  avio_r8(pb);
1517  avio_r8(pb);
1518  update_offsets(pb, &off, &len);
1519  return parse_mp4_descr_arr(d, off, len);
1520 }
1521 
1523 {
1524  int id_flags;
1525  if (len < 2)
1526  return 0;
1527  id_flags = avio_rb16(&d->pb.pub);
1528  if (!(id_flags & 0x0020)) { // URL_Flag
1529  update_offsets(&d->pb.pub, &off, &len);
1530  return parse_mp4_descr_arr(d, off, len); // ES_Descriptor[]
1531  } else {
1532  return 0;
1533  }
1534 }
1535 
1537 {
1538  AVIOContext *const pb = &d->pb.pub;
1539  int es_id = 0;
1540  int ret = 0;
1541 
1542  if (d->descr_count >= d->max_descr_count)
1543  return AVERROR_INVALIDDATA;
1544  ff_mp4_parse_es_descr(pb, &es_id);
1545  d->active_descr = d->descr + (d->descr_count++);
1546 
1547  d->active_descr->es_id = es_id;
1548  update_offsets(pb, &off, &len);
1549  if ((ret = parse_mp4_descr(d, off, len, MP4DecConfigDescrTag)) < 0)
1550  return ret;
1551  update_offsets(pb, &off, &len);
1552  if (len > 0)
1554  d->active_descr = NULL;
1555  return ret;
1556 }
1557 
1559  int len)
1560 {
1561  Mp4Descr *descr = d->active_descr;
1562  if (!descr)
1563  return AVERROR_INVALIDDATA;
1564  d->active_descr->dec_config_descr = av_malloc(len);
1565  if (!descr->dec_config_descr)
1566  return AVERROR(ENOMEM);
1567  descr->dec_config_descr_len = len;
1568  avio_read(&d->pb.pub, descr->dec_config_descr, len);
1569  return 0;
1570 }
1571 
1573 {
1574  Mp4Descr *descr = d->active_descr;
1575  AVIOContext *const pb = &d->pb.pub;
1576  int predefined;
1577  if (!descr)
1578  return AVERROR_INVALIDDATA;
1579 
1580 #define R8_CHECK_CLIP_MAX(dst, maxv) do { \
1581  descr->sl.dst = avio_r8(pb); \
1582  if (descr->sl.dst > maxv) { \
1583  descr->sl.dst = maxv; \
1584  return AVERROR_INVALIDDATA; \
1585  } \
1586 } while (0)
1587 
1588  predefined = avio_r8(pb);
1589  if (!predefined) {
1590  int lengths;
1591  int flags = avio_r8(pb);
1592  descr->sl.use_au_start = !!(flags & 0x80);
1593  descr->sl.use_au_end = !!(flags & 0x40);
1594  descr->sl.use_rand_acc_pt = !!(flags & 0x20);
1595  descr->sl.use_padding = !!(flags & 0x08);
1596  descr->sl.use_timestamps = !!(flags & 0x04);
1597  descr->sl.use_idle = !!(flags & 0x02);
1598  descr->sl.timestamp_res = avio_rb32(pb);
1599  avio_rb32(pb);
1600  R8_CHECK_CLIP_MAX(timestamp_len, 63);
1601  R8_CHECK_CLIP_MAX(ocr_len, 63);
1602  R8_CHECK_CLIP_MAX(au_len, 31);
1603  descr->sl.inst_bitrate_len = avio_r8(pb);
1604  lengths = avio_rb16(pb);
1605  descr->sl.degr_prior_len = lengths >> 12;
1606  descr->sl.au_seq_num_len = (lengths >> 7) & 0x1f;
1607  descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f;
1608  } else if (!d->predefined_SLConfigDescriptor_seen){
1609  avpriv_report_missing_feature(d->s, "Predefined SLConfigDescriptor");
1610  d->predefined_SLConfigDescriptor_seen = 1;
1611  }
1612  return 0;
1613 }
1614 
1616  int target_tag)
1617 {
1618  int tag;
1619  AVIOContext *const pb = &d->pb.pub;
1620  int len1 = ff_mp4_read_descr(d->s, pb, &tag);
1621  int ret = 0;
1622 
1623  update_offsets(pb, &off, &len);
1624  if (len < 0 || len1 > len || len1 <= 0) {
1625  av_log(d->s, AV_LOG_ERROR,
1626  "Tag %x length violation new length %d bytes remaining %d\n",
1627  tag, len1, len);
1628  return AVERROR_INVALIDDATA;
1629  }
1630 
1631  if (d->level++ >= MAX_LEVEL) {
1632  av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n");
1634  goto done;
1635  }
1636 
1637  if (target_tag && tag != target_tag) {
1638  av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag,
1639  target_tag);
1641  goto done;
1642  }
1643 
1644  switch (tag) {
1645  case MP4IODescrTag:
1646  ret = parse_MP4IODescrTag(d, off, len1);
1647  break;
1648  case MP4ODescrTag:
1649  ret = parse_MP4ODescrTag(d, off, len1);
1650  break;
1651  case MP4ESDescrTag:
1652  ret = parse_MP4ESDescrTag(d, off, len1);
1653  break;
1654  case MP4DecConfigDescrTag:
1655  ret = parse_MP4DecConfigDescrTag(d, off, len1);
1656  break;
1657  case MP4SLDescrTag:
1658  ret = parse_MP4SLDescrTag(d, off, len1);
1659  break;
1660  }
1661 
1662 
1663 done:
1664  d->level--;
1665  avio_seek(pb, off + len1, SEEK_SET);
1666  return ret;
1667 }
1668 
1669 static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
1670  Mp4Descr *descr, int *descr_count, int max_descr_count)
1671 {
1673  int ret;
1674 
1675  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1676  if (ret < 0)
1677  return ret;
1678 
1679  ret = parse_mp4_descr(&d, avio_tell(&d.pb.pub), size, MP4IODescrTag);
1680 
1681  *descr_count = d.descr_count;
1682  return ret;
1683 }
1684 
1685 static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size,
1686  Mp4Descr *descr, int *descr_count, int max_descr_count)
1687 {
1689  int ret;
1690 
1691  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1692  if (ret < 0)
1693  return ret;
1694 
1695  ret = parse_mp4_descr_arr(&d, avio_tell(&d.pb.pub), size);
1696 
1697  *descr_count = d.descr_count;
1698  return ret;
1699 }
1700 
1701 static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section,
1702  int section_len)
1703 {
1704  MpegTSContext *ts = filter->u.section_filter.opaque;
1705  MpegTSSectionFilter *tssf = &filter->u.section_filter;
1706  SectionHeader h;
1707  const uint8_t *p, *p_end;
1708  int mp4_descr_count = 0;
1709  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
1710  int i, pid;
1711  AVFormatContext *s = ts->stream;
1712 
1713  p_end = section + section_len - 4;
1714  p = section;
1715  if (parse_section_header(&h, &p, p_end) < 0)
1716  return;
1717  if (h.tid != M4OD_TID)
1718  return;
1719  if (skip_identical(&h, tssf))
1720  return;
1721 
1722  mp4_read_od(s, p, (unsigned) (p_end - p), mp4_descr, &mp4_descr_count,
1724 
1725  for (pid = 0; pid < NB_PID_MAX; pid++) {
1726  if (!ts->pids[pid])
1727  continue;
1728  for (i = 0; i < mp4_descr_count; i++) {
1729  PESContext *pes;
1730  AVStream *st;
1731  FFStream *sti;
1732  FFIOContext pb;
1733  if (ts->pids[pid]->es_id != mp4_descr[i].es_id)
1734  continue;
1735  if (ts->pids[pid]->type != MPEGTS_PES) {
1736  av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);
1737  continue;
1738  }
1739  pes = ts->pids[pid]->u.pes_filter.opaque;
1740  st = pes->st;
1741  if (!st)
1742  continue;
1743  sti = ffstream(st);
1744 
1745  pes->sl = mp4_descr[i].sl;
1746 
1747  ffio_init_read_context(&pb, mp4_descr[i].dec_config_descr,
1748  mp4_descr[i].dec_config_descr_len);
1750  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1751  st->codecpar->extradata_size > 0)
1752  sti->need_parsing = 0;
1753  if (st->codecpar->codec_id == AV_CODEC_ID_H264 &&
1754  st->codecpar->extradata_size > 0)
1755  sti->need_parsing = 0;
1756 
1758  sti->need_context_update = 1;
1759  }
1760  }
1761  for (i = 0; i < mp4_descr_count; i++)
1762  av_free(mp4_descr[i].dec_config_descr);
1763 }
1764 
1765 static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section,
1766  int section_len)
1767 {
1768  AVProgram *prg = NULL;
1769  MpegTSContext *ts = filter->u.section_filter.opaque;
1770 
1771  int idx = ff_find_stream_index(ts->stream, filter->pid);
1772  if (idx < 0)
1773  return;
1774 
1775  /**
1776  * In case we receive an SCTE-35 packet before mpegts context is fully
1777  * initialized.
1778  */
1779  if (!ts->pkt)
1780  return;
1781 
1782  new_data_packet(section, section_len, ts->pkt);
1783  ts->pkt->stream_index = idx;
1784  prg = av_find_program_from_stream(ts->stream, NULL, idx);
1785  if (prg && prg->pcr_pid != -1 && prg->discard != AVDISCARD_ALL) {
1786  MpegTSFilter *f = ts->pids[prg->pcr_pid];
1787  if (f && f->last_pcr != -1)
1788  ts->pkt->pts = ts->pkt->dts = f->last_pcr/300;
1789  }
1790  ts->stop_parse = 1;
1791 
1792 }
1793 
1794 static const uint8_t opus_coupled_stream_cnt[9] = {
1795  1, 0, 1, 1, 2, 2, 2, 3, 3
1796 };
1797 
1798 static const uint8_t opus_stream_cnt[9] = {
1799  1, 1, 1, 2, 2, 3, 4, 4, 5,
1800 };
1801 
1802 static const uint8_t opus_channel_map[8][8] = {
1803  { 0 },
1804  { 0,1 },
1805  { 0,2,1 },
1806  { 0,1,2,3 },
1807  { 0,4,1,2,3 },
1808  { 0,4,1,2,3,5 },
1809  { 0,4,1,2,3,5,6 },
1810  { 0,6,1,2,3,4,5,7 },
1811 };
1812 
1814  const uint8_t **pp, const uint8_t *desc_list_end,
1815  Mp4Descr *mp4_descr, int mp4_descr_count, int pid,
1816  MpegTSContext *ts)
1817 {
1818  FFStream *const sti = ffstream(st);
1819  const uint8_t *desc_end;
1820  int desc_len, desc_tag, desc_es_id, ext_desc_tag, channels, channel_config_code;
1821  char language[252];
1822  int i;
1823 
1824  desc_tag = get8(pp, desc_list_end);
1825  if (desc_tag < 0)
1826  return AVERROR_INVALIDDATA;
1827  desc_len = get8(pp, desc_list_end);
1828  if (desc_len < 0)
1829  return AVERROR_INVALIDDATA;
1830  desc_end = *pp + desc_len;
1831  if (desc_end > desc_list_end)
1832  return AVERROR_INVALIDDATA;
1833 
1834  av_log(fc, AV_LOG_TRACE, "tag: 0x%02x len=%d\n", desc_tag, desc_len);
1835 
1836  if ((st->codecpar->codec_id == AV_CODEC_ID_NONE || sti->request_probe > 0) &&
1837  stream_type == STREAM_TYPE_PRIVATE_DATA)
1838  mpegts_find_stream_type(st, desc_tag, DESC_types);
1839 
1840  switch (desc_tag) {
1842  if (get8(pp, desc_end) & 0x1) {
1844  }
1845  break;
1846  case SL_DESCRIPTOR:
1847  desc_es_id = get16(pp, desc_end);
1848  if (desc_es_id < 0)
1849  break;
1850  if (ts && ts->pids[pid])
1851  ts->pids[pid]->es_id = desc_es_id;
1852  for (i = 0; i < mp4_descr_count; i++)
1853  if (mp4_descr[i].dec_config_descr_len &&
1854  mp4_descr[i].es_id == desc_es_id) {
1855  FFIOContext pb;
1856  ffio_init_read_context(&pb, mp4_descr[i].dec_config_descr,
1857  mp4_descr[i].dec_config_descr_len);
1859  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1860  st->codecpar->extradata_size > 0) {
1861  sti->need_parsing = 0;
1862  sti->need_context_update = 1;
1863  }
1865  mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);
1866  }
1867  break;
1868  case FMC_DESCRIPTOR:
1869  if (get16(pp, desc_end) < 0)
1870  break;
1871  if (mp4_descr_count > 0 &&
1873  (sti->request_probe == 0 && st->codecpar->codec_id == AV_CODEC_ID_NONE) ||
1874  sti->request_probe > 0) &&
1875  mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {
1876  FFIOContext pb;
1877  ffio_init_read_context(&pb, mp4_descr->dec_config_descr,
1878  mp4_descr->dec_config_descr_len);
1880  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1881  st->codecpar->extradata_size > 0) {
1882  sti->request_probe = sti->need_parsing = 0;
1884  sti->need_context_update = 1;
1885  }
1886  }
1887  break;
1888  case 0x56: /* DVB teletext descriptor */
1889  {
1890  uint8_t *extradata = NULL;
1891  int language_count = desc_len / 5, ret;
1892 
1893  if (desc_len > 0 && desc_len % 5 != 0)
1894  return AVERROR_INVALIDDATA;
1895 
1896  if (language_count > 0) {
1897  /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1898  av_assert0(language_count <= sizeof(language) / 4);
1899 
1900  if (st->codecpar->extradata == NULL) {
1901  ret = ff_alloc_extradata(st->codecpar, language_count * 2);
1902  if (ret < 0)
1903  return ret;
1904  }
1905 
1906  if (st->codecpar->extradata_size < language_count * 2)
1907  return AVERROR_INVALIDDATA;
1908 
1909  extradata = st->codecpar->extradata;
1910 
1911  for (i = 0; i < language_count; i++) {
1912  language[i * 4 + 0] = get8(pp, desc_end);
1913  language[i * 4 + 1] = get8(pp, desc_end);
1914  language[i * 4 + 2] = get8(pp, desc_end);
1915  language[i * 4 + 3] = ',';
1916 
1917  memcpy(extradata, *pp, 2);
1918  extradata += 2;
1919 
1920  *pp += 2;
1921  }
1922 
1923  language[i * 4 - 1] = 0;
1924  av_dict_set(&st->metadata, "language", language, 0);
1925  sti->need_context_update = 1;
1926  }
1927  }
1928  break;
1929  case 0x59: /* subtitling descriptor */
1930  {
1931  /* 8 bytes per DVB subtitle substream data:
1932  * ISO_639_language_code (3 bytes),
1933  * subtitling_type (1 byte),
1934  * composition_page_id (2 bytes),
1935  * ancillary_page_id (2 bytes) */
1936  int language_count = desc_len / 8, ret;
1937 
1938  if (desc_len > 0 && desc_len % 8 != 0)
1939  return AVERROR_INVALIDDATA;
1940 
1941  if (language_count > 1) {
1942  avpriv_request_sample(fc, "DVB subtitles with multiple languages");
1943  }
1944 
1945  if (language_count > 0) {
1946  uint8_t *extradata;
1947 
1948  /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1949  av_assert0(language_count <= sizeof(language) / 4);
1950 
1951  if (st->codecpar->extradata == NULL) {
1952  ret = ff_alloc_extradata(st->codecpar, language_count * 5);
1953  if (ret < 0)
1954  return ret;
1955  }
1956 
1957  if (st->codecpar->extradata_size < language_count * 5)
1958  return AVERROR_INVALIDDATA;
1959 
1960  extradata = st->codecpar->extradata;
1961 
1962  for (i = 0; i < language_count; i++) {
1963  language[i * 4 + 0] = get8(pp, desc_end);
1964  language[i * 4 + 1] = get8(pp, desc_end);
1965  language[i * 4 + 2] = get8(pp, desc_end);
1966  language[i * 4 + 3] = ',';
1967 
1968  /* hearing impaired subtitles detection using subtitling_type */
1969  switch (*pp[0]) {
1970  case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */
1971  case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */
1972  case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */
1973  case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */
1974  case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */
1975  case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */
1977  break;
1978  }
1979 
1980  extradata[4] = get8(pp, desc_end); /* subtitling_type */
1981  memcpy(extradata, *pp, 4); /* composition_page_id and ancillary_page_id */
1982  extradata += 5;
1983 
1984  *pp += 4;
1985  }
1986 
1987  language[i * 4 - 1] = 0;
1988  av_dict_set(&st->metadata, "language", language, 0);
1989  sti->need_context_update = 1;
1990  }
1991  }
1992  break;
1994  for (i = 0; i + 4 <= desc_len; i += 4) {
1995  language[i + 0] = get8(pp, desc_end);
1996  language[i + 1] = get8(pp, desc_end);
1997  language[i + 2] = get8(pp, desc_end);
1998  language[i + 3] = ',';
1999  switch (get8(pp, desc_end)) {
2000  case 0x01:
2002  break;
2003  case 0x02:
2005  break;
2006  case 0x03:
2009  break;
2010  }
2011  }
2012  if (i && language[0]) {
2013  language[i - 1] = 0;
2014  /* don't overwrite language, as it may already have been set by
2015  * another, more specific descriptor (e.g. supplementary audio) */
2017  }
2018  break;
2020  st->codecpar->codec_tag = bytestream_get_le32(pp);
2021  av_log(fc, AV_LOG_TRACE, "reg_desc=%.4s\n", (char *)&st->codecpar->codec_tag);
2022  if (st->codecpar->codec_id == AV_CODEC_ID_NONE || sti->request_probe > 0) {
2024  if (st->codecpar->codec_tag == MKTAG('B', 'S', 'S', 'D'))
2025  sti->request_probe = 50;
2026  }
2027  break;
2028  case 0x52: /* stream identifier descriptor */
2029  sti->stream_identifier = 1 + get8(pp, desc_end);
2030  break;
2031  case METADATA_DESCRIPTOR:
2032  if (get16(pp, desc_end) == 0xFFFF)
2033  *pp += 4;
2034  if (get8(pp, desc_end) == 0xFF) {
2035  st->codecpar->codec_tag = bytestream_get_le32(pp);
2036  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2038  }
2039  break;
2040  case 0x7f: /* DVB extension descriptor */
2041  ext_desc_tag = get8(pp, desc_end);
2042  if (ext_desc_tag < 0)
2043  return AVERROR_INVALIDDATA;
2044  if (st->codecpar->codec_id == AV_CODEC_ID_OPUS &&
2045  ext_desc_tag == 0x80) { /* User defined (provisional Opus) */
2046  if (!st->codecpar->extradata) {
2049  if (!st->codecpar->extradata)
2050  return AVERROR(ENOMEM);
2051 
2054 
2055  channel_config_code = get8(pp, desc_end);
2056  if (channel_config_code < 0)
2057  return AVERROR_INVALIDDATA;
2058  if (channel_config_code <= 0x8) {
2059  st->codecpar->extradata[9] = channels = channel_config_code ? channel_config_code : 2;
2060  AV_WL32(&st->codecpar->extradata[12], 48000);
2061  st->codecpar->extradata[18] = channel_config_code ? (channels > 2) : /* Dual Mono */ 255;
2062  st->codecpar->extradata[19] = opus_stream_cnt[channel_config_code];
2063  st->codecpar->extradata[20] = opus_coupled_stream_cnt[channel_config_code];
2064  memcpy(&st->codecpar->extradata[21], opus_channel_map[channels - 1], channels);
2065  st->codecpar->extradata_size = st->codecpar->extradata[18] ? 21 + channels : 19;
2066  } else {
2067  avpriv_request_sample(fc, "Opus in MPEG-TS - channel_config_code > 0x8");
2068  }
2070  sti->need_context_update = 1;
2071  }
2072  }
2073  if (ext_desc_tag == 0x06) { /* supplementary audio descriptor */
2074  int flags;
2075 
2076  if (desc_len < 1)
2077  return AVERROR_INVALIDDATA;
2078  flags = get8(pp, desc_end);
2079 
2080  if ((flags & 0x80) == 0) /* mix_type */
2082 
2083  switch ((flags >> 2) & 0x1F) { /* editorial_classification */
2084  case 0x01:
2087  break;
2088  case 0x02:
2090  break;
2091  case 0x03:
2093  break;
2094  }
2095 
2096  if (flags & 0x01) { /* language_code_present */
2097  if (desc_len < 4)
2098  return AVERROR_INVALIDDATA;
2099  language[0] = get8(pp, desc_end);
2100  language[1] = get8(pp, desc_end);
2101  language[2] = get8(pp, desc_end);
2102  language[3] = 0;
2103 
2104  /* This language always has to override a possible
2105  * ISO 639 language descriptor language */
2106  if (language[0])
2107  av_dict_set(&st->metadata, "language", language, 0);
2108  }
2109  }
2110  break;
2111  case 0x6a: /* ac-3_descriptor */
2112  {
2113  int component_type_flag = get8(pp, desc_end) & (1 << 7);
2114  if (component_type_flag) {
2115  int component_type = get8(pp, desc_end);
2116  int service_type_mask = 0x38; // 0b00111000
2117  int service_type = ((component_type & service_type_mask) >> 3);
2118  if (service_type == 0x02 /* 0b010 */) {
2120  av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition);
2121  }
2122  }
2123  }
2124  break;
2125  case 0x7a: /* enhanced_ac-3_descriptor */
2126  {
2127  int component_type_flag = get8(pp, desc_end) & (1 << 7);
2128  if (component_type_flag) {
2129  int component_type = get8(pp, desc_end);
2130  int service_type_mask = 0x38; // 0b00111000
2131  int service_type = ((component_type & service_type_mask) >> 3);
2132  if (service_type == 0x02 /* 0b010 */) {
2134  av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition);
2135  }
2136  }
2137  }
2138  break;
2139  case 0xfd: /* ARIB data coding type descriptor */
2140  // STD-B24, fascicle 3, chapter 4 defines private_stream_1
2141  // for captions
2142  if (stream_type == STREAM_TYPE_PRIVATE_DATA) {
2143  // This structure is defined in STD-B10, part 1, listing 5.4 and
2144  // part 2, 6.2.20).
2145  // Listing of data_component_ids is in STD-B10, part 2, Annex J.
2146  // Component tag limits are documented in TR-B14, fascicle 2,
2147  // Vol. 3, Section 2, 4.2.8.1
2148  int actual_component_tag = sti->stream_identifier - 1;
2149  int picked_profile = AV_PROFILE_UNKNOWN;
2150  int data_component_id = get16(pp, desc_end);
2151  if (data_component_id < 0)
2152  return AVERROR_INVALIDDATA;
2153 
2154  switch (data_component_id) {
2155  case 0x0008:
2156  // [0x30..0x37] are component tags utilized for
2157  // non-mobile captioning service ("profile A").
2158  if (actual_component_tag >= 0x30 &&
2159  actual_component_tag <= 0x37) {
2160  picked_profile = AV_PROFILE_ARIB_PROFILE_A;
2161  }
2162  break;
2163  case 0x0012:
2164  // component tag 0x87 signifies a mobile/partial reception
2165  // (1seg) captioning service ("profile C").
2166  if (actual_component_tag == 0x87) {
2167  picked_profile = AV_PROFILE_ARIB_PROFILE_C;
2168  }
2169  break;
2170  default:
2171  break;
2172  }
2173 
2174  if (picked_profile == AV_PROFILE_UNKNOWN)
2175  break;
2176 
2179  if (st->codecpar->profile != picked_profile) {
2180  st->codecpar->profile = picked_profile;
2181  sti->need_context_update = 1;
2182  }
2183  sti->request_probe = 0;
2184  sti->need_parsing = 0;
2185  }
2186  break;
2187  case 0xb0: /* DOVI video stream descriptor */
2188  {
2189  uint32_t buf;
2191  size_t dovi_size;
2192  int dependency_pid = -1; // Unset
2193 
2194  if (desc_end - *pp < 4) // (8 + 8 + 7 + 6 + 1 + 1 + 1) / 8
2195  return AVERROR_INVALIDDATA;
2196 
2197  dovi = av_dovi_alloc(&dovi_size);
2198  if (!dovi)
2199  return AVERROR(ENOMEM);
2200 
2201  dovi->dv_version_major = get8(pp, desc_end);
2202  dovi->dv_version_minor = get8(pp, desc_end);
2203  buf = get16(pp, desc_end);
2204  dovi->dv_profile = (buf >> 9) & 0x7f; // 7 bits
2205  dovi->dv_level = (buf >> 3) & 0x3f; // 6 bits
2206  dovi->rpu_present_flag = (buf >> 2) & 0x01; // 1 bit
2207  dovi->el_present_flag = (buf >> 1) & 0x01; // 1 bit
2208  dovi->bl_present_flag = buf & 0x01; // 1 bit
2209  if (!dovi->bl_present_flag && desc_end - *pp >= 2) {
2210  buf = get16(pp, desc_end);
2211  dependency_pid = buf >> 3; // 13 bits
2212  }
2213  if (desc_end - *pp >= 1) { // 8 bits
2214  buf = get8(pp, desc_end);
2215  dovi->dv_bl_signal_compatibility_id = (buf >> 4) & 0x0f; // 4 bits
2216  } else {
2217  // 0 stands for None
2218  // Dolby Vision V1.2.93 profiles and levels
2220  }
2221 
2225  (uint8_t *)dovi, dovi_size, 0)) {
2226  av_free(dovi);
2227  return AVERROR(ENOMEM);
2228  }
2229 
2230  av_log(fc, AV_LOG_TRACE, "DOVI, version: %d.%d, profile: %d, level: %d, "
2231  "rpu flag: %d, el flag: %d, bl flag: %d, dependency_pid: %d, compatibility id: %d\n",
2232  dovi->dv_version_major, dovi->dv_version_minor,
2233  dovi->dv_profile, dovi->dv_level,
2234  dovi->rpu_present_flag,
2235  dovi->el_present_flag,
2236  dovi->bl_present_flag,
2237  dependency_pid,
2238  dovi->dv_bl_signal_compatibility_id);
2239  }
2240  break;
2241  default:
2242  break;
2243  }
2244  *pp = desc_end;
2245  return 0;
2246 }
2247 
2248 static AVStream *find_matching_stream(MpegTSContext *ts, int pid, unsigned int programid,
2249  int stream_identifier, int pmt_stream_idx, struct Program *p)
2250 {
2251  AVFormatContext *s = ts->stream;
2252  AVStream *found = NULL;
2253 
2254  if (stream_identifier) { /* match based on "stream identifier descriptor" if present */
2255  for (int i = 0; i < p->nb_streams; i++) {
2256  if (p->streams[i].stream_identifier == stream_identifier)
2257  if (!found || pmt_stream_idx == i) /* fallback to idx based guess if multiple streams have the same identifier */
2258  found = s->streams[p->streams[i].idx];
2259  }
2260  } else if (pmt_stream_idx < p->nb_streams) { /* match based on position within the PMT */
2261  found = s->streams[p->streams[pmt_stream_idx].idx];
2262  }
2263 
2264  if (found) {
2266  "re-using existing %s stream %d (pid=0x%x) for new pid=0x%x\n",
2268  found->index, found->id, pid);
2269  }
2270 
2271  return found;
2272 }
2273 
2274 static int parse_stream_identifier_desc(const uint8_t *p, const uint8_t *p_end)
2275 {
2276  const uint8_t **pp = &p;
2277  const uint8_t *desc_list_end;
2278  const uint8_t *desc_end;
2279  int desc_list_len;
2280  int desc_len, desc_tag;
2281 
2282  desc_list_len = get16(pp, p_end);
2283  if (desc_list_len < 0)
2284  return -1;
2285  desc_list_len &= 0xfff;
2286  desc_list_end = p + desc_list_len;
2287  if (desc_list_end > p_end)
2288  return -1;
2289 
2290  while (1) {
2291  desc_tag = get8(pp, desc_list_end);
2292  if (desc_tag < 0)
2293  return -1;
2294  desc_len = get8(pp, desc_list_end);
2295  if (desc_len < 0)
2296  return -1;
2297  desc_end = *pp + desc_len;
2298  if (desc_end > desc_list_end)
2299  return -1;
2300 
2301  if (desc_tag == 0x52) {
2302  return get8(pp, desc_end);
2303  }
2304  *pp = desc_end;
2305  }
2306 
2307  return -1;
2308 }
2309 
2310 static int is_pes_stream(int stream_type, uint32_t prog_reg_desc)
2311 {
2312  return !(stream_type == 0x13 ||
2313  (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) );
2314 }
2315 
2316 static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2317 {
2318  MpegTSContext *ts = filter->u.section_filter.opaque;
2319  MpegTSSectionFilter *tssf = &filter->u.section_filter;
2320  struct Program old_program;
2321  SectionHeader h1, *h = &h1;
2322  PESContext *pes;
2323  AVStream *st;
2324  const uint8_t *p, *p_end, *desc_list_end;
2325  int program_info_length, pcr_pid, pid, stream_type;
2326  int desc_list_len;
2327  uint32_t prog_reg_desc = 0; /* registration descriptor */
2328  int stream_identifier = -1;
2329  struct Program *prg;
2330 
2331  int mp4_descr_count = 0;
2332  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
2333  int i;
2334 
2335  av_log(ts->stream, AV_LOG_TRACE, "PMT: len %i\n", section_len);
2336  hex_dump_debug(ts->stream, section, section_len);
2337 
2338  p_end = section + section_len - 4;
2339  p = section;
2340  if (parse_section_header(h, &p, p_end) < 0)
2341  return;
2342  if (h->tid != PMT_TID)
2343  return;
2344  if (!h->current_next)
2345  return;
2346  if (skip_identical(h, tssf))
2347  return;
2348 
2349  av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x sec_num=%d/%d version=%d tid=%d\n",
2350  h->id, h->sec_num, h->last_sec_num, h->version, h->tid);
2351 
2352  if (!ts->scan_all_pmts && ts->skip_changes)
2353  return;
2354 
2355  prg = get_program(ts, h->id);
2356  if (prg)
2357  old_program = *prg;
2358  else
2359  clear_program(&old_program);
2360 
2361  if (ts->skip_unknown_pmt && !prg)
2362  return;
2363  if (prg && prg->nb_pids && prg->pids[0] != ts->current_pid)
2364  return;
2365  if (!ts->skip_clear)
2366  clear_avprogram(ts, h->id);
2367  clear_program(prg);
2368  add_pid_to_program(prg, ts->current_pid);
2369 
2370  pcr_pid = get16(&p, p_end);
2371  if (pcr_pid < 0)
2372  return;
2373  pcr_pid &= 0x1fff;
2374  add_pid_to_program(prg, pcr_pid);
2375  update_av_program_info(ts->stream, h->id, pcr_pid, h->version);
2376 
2377  av_log(ts->stream, AV_LOG_TRACE, "pcr_pid=0x%x\n", pcr_pid);
2378 
2379  program_info_length = get16(&p, p_end);
2380  if (program_info_length < 0)
2381  return;
2382  program_info_length &= 0xfff;
2383  while (program_info_length >= 2) {
2384  uint8_t tag, len;
2385  tag = get8(&p, p_end);
2386  len = get8(&p, p_end);
2387 
2388  av_log(ts->stream, AV_LOG_TRACE, "program tag: 0x%02x len=%d\n", tag, len);
2389 
2390  program_info_length -= 2;
2391  if (len > program_info_length)
2392  // something else is broken, exit the program_descriptors_loop
2393  break;
2394  program_info_length -= len;
2395  if (tag == IOD_DESCRIPTOR) {
2396  get8(&p, p_end); // scope
2397  get8(&p, p_end); // label
2398  len -= 2;
2399  mp4_read_iods(ts->stream, p, len, mp4_descr + mp4_descr_count,
2400  &mp4_descr_count, MAX_MP4_DESCR_COUNT);
2401  } else if (tag == REGISTRATION_DESCRIPTOR && len >= 4) {
2402  prog_reg_desc = bytestream_get_le32(&p);
2403  len -= 4;
2404  }
2405  p += len;
2406  }
2407  p += program_info_length;
2408  if (p >= p_end)
2409  goto out;
2410 
2411  // stop parsing after pmt, we found header
2412  if (!ts->pkt)
2413  ts->stop_parse = 2;
2414 
2415  if (prg)
2416  prg->pmt_found = 1;
2417 
2418  for (i = 0; i < MAX_STREAMS_PER_PROGRAM; i++) {
2419  st = 0;
2420  pes = NULL;
2421  stream_type = get8(&p, p_end);
2422  if (stream_type < 0)
2423  break;
2424  pid = get16(&p, p_end);
2425  if (pid < 0)
2426  goto out;
2427  pid &= 0x1fff;
2428  if (pid == ts->current_pid)
2429  goto out;
2430 
2431  stream_identifier = parse_stream_identifier_desc(p, p_end) + 1;
2432 
2433  /* now create stream */
2434  if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
2435  pes = ts->pids[pid]->u.pes_filter.opaque;
2436  if (ts->merge_pmt_versions && !pes->st) {
2437  st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program);
2438  if (st) {
2439  pes->st = st;
2440  pes->stream_type = stream_type;
2441  pes->merged_st = 1;
2442  }
2443  }
2444  if (!pes->st) {
2445  pes->st = avformat_new_stream(pes->stream, NULL);
2446  if (!pes->st)
2447  goto out;
2448  pes->st->id = pes->pid;
2449  }
2450  st = pes->st;
2451  } else if (is_pes_stream(stream_type, prog_reg_desc)) {
2452  if (ts->pids[pid])
2453  mpegts_close_filter(ts, ts->pids[pid]); // wrongly added sdt filter probably
2454  pes = add_pes_stream(ts, pid, pcr_pid);
2455  if (ts->merge_pmt_versions && pes && !pes->st) {
2456  st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program);
2457  if (st) {
2458  pes->st = st;
2459  pes->stream_type = stream_type;
2460  pes->merged_st = 1;
2461  }
2462  }
2463  if (pes && !pes->st) {
2464  st = avformat_new_stream(pes->stream, NULL);
2465  if (!st)
2466  goto out;
2467  st->id = pes->pid;
2468  }
2469  } else {
2470  int idx = ff_find_stream_index(ts->stream, pid);
2471  if (idx >= 0) {
2472  st = ts->stream->streams[idx];
2473  }
2474  if (ts->merge_pmt_versions && !st) {
2475  st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program);
2476  }
2477  if (!st) {
2478  st = avformat_new_stream(ts->stream, NULL);
2479  if (!st)
2480  goto out;
2481  st->id = pid;
2483  if (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) {
2484  mpegts_find_stream_type(st, stream_type, SCTE_types);
2485  mpegts_open_section_filter(ts, pid, scte_data_cb, ts, 1);
2486  }
2487  }
2488  }
2489 
2490  if (!st)
2491  goto out;
2492 
2493  if (pes && !pes->stream_type)
2494  mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc);
2495 
2496  add_pid_to_program(prg, pid);
2497  if (prg) {
2498  prg->streams[i].idx = st->index;
2499  prg->streams[i].stream_identifier = stream_identifier;
2500  prg->nb_streams++;
2501  }
2502 
2503  av_program_add_stream_index(ts->stream, h->id, st->index);
2504 
2505  desc_list_len = get16(&p, p_end);
2506  if (desc_list_len < 0)
2507  goto out;
2508  desc_list_len &= 0xfff;
2509  desc_list_end = p + desc_list_len;
2510  if (desc_list_end > p_end)
2511  goto out;
2512  for (;;) {
2513  if (ff_parse_mpeg2_descriptor(ts->stream, st, stream_type, &p,
2514  desc_list_end, mp4_descr,
2515  mp4_descr_count, pid, ts) < 0)
2516  break;
2517 
2518  if (pes && prog_reg_desc == AV_RL32("HDMV") &&
2519  stream_type == 0x83 && pes->sub_st) {
2521  pes->sub_st->index);
2522  pes->sub_st->codecpar->codec_tag = st->codecpar->codec_tag;
2523  }
2524  }
2525  p = desc_list_end;
2526  }
2527 
2528  if (!ts->pids[pcr_pid])
2529  mpegts_open_pcr_filter(ts, pcr_pid);
2530 
2531 out:
2532  for (i = 0; i < mp4_descr_count; i++)
2533  av_free(mp4_descr[i].dec_config_descr);
2534 }
2535 
2536 static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2537 {
2538  MpegTSContext *ts = filter->u.section_filter.opaque;
2539  MpegTSSectionFilter *tssf = &filter->u.section_filter;
2540  SectionHeader h1, *h = &h1;
2541  const uint8_t *p, *p_end;
2542  int sid, pmt_pid;
2543  int nb_prg = 0;
2544  AVProgram *program;
2545 
2546  av_log(ts->stream, AV_LOG_TRACE, "PAT:\n");
2547  hex_dump_debug(ts->stream, section, section_len);
2548 
2549  p_end = section + section_len - 4;
2550  p = section;
2551  if (parse_section_header(h, &p, p_end) < 0)
2552  return;
2553  if (h->tid != PAT_TID)
2554  return;
2555  if (!h->current_next)
2556  return;
2557  if (ts->skip_changes)
2558  return;
2559 
2560  if (skip_identical(h, tssf))
2561  return;
2562  ts->id = h->id;
2563 
2564  for (;;) {
2565  sid = get16(&p, p_end);
2566  if (sid < 0)
2567  break;
2568  pmt_pid = get16(&p, p_end);
2569  if (pmt_pid < 0)
2570  break;
2571  pmt_pid &= 0x1fff;
2572 
2573  if (pmt_pid == ts->current_pid)
2574  break;
2575 
2576  av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
2577 
2578  if (sid == 0x0000) {
2579  /* NIT info */
2580  } else {
2581  MpegTSFilter *fil = ts->pids[pmt_pid];
2582  struct Program *prg;
2583  program = av_new_program(ts->stream, sid);
2584  if (program) {
2585  program->program_num = sid;
2586  program->pmt_pid = pmt_pid;
2587  }
2588  if (fil)
2589  if ( fil->type != MPEGTS_SECTION
2590  || fil->pid != pmt_pid
2591  || fil->u.section_filter.section_cb != pmt_cb)
2592  mpegts_close_filter(ts, ts->pids[pmt_pid]);
2593 
2594  if (!ts->pids[pmt_pid])
2595  mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
2596  prg = add_program(ts, sid);
2597  if (prg) {
2598  unsigned prg_idx = prg - ts->prg;
2599  if (prg->nb_pids && prg->pids[0] != pmt_pid)
2600  clear_program(prg);
2601  add_pid_to_program(prg, pmt_pid);
2602  if (prg_idx > nb_prg)
2603  FFSWAP(struct Program, ts->prg[nb_prg], ts->prg[prg_idx]);
2604  if (prg_idx >= nb_prg)
2605  nb_prg++;
2606  } else
2607  nb_prg = 0;
2608  }
2609  }
2610  ts->nb_prg = nb_prg;
2611 
2612  if (sid < 0) {
2613  int i,j;
2614  for (j=0; j<ts->stream->nb_programs; j++) {
2615  for (i = 0; i < ts->nb_prg; i++)
2616  if (ts->prg[i].id == ts->stream->programs[j]->id)
2617  break;
2618  if (i==ts->nb_prg && !ts->skip_clear)
2619  clear_avprogram(ts, ts->stream->programs[j]->id);
2620  }
2621  }
2622 }
2623 
2624 static void eit_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2625 {
2626  MpegTSContext *ts = filter->u.section_filter.opaque;
2627  const uint8_t *p, *p_end;
2628  SectionHeader h1, *h = &h1;
2629 
2630  /*
2631  * Sometimes we receive EPG packets but SDT table do not have
2632  * eit_pres_following or eit_sched turned on, so we open EPG
2633  * stream directly here.
2634  */
2635  if (!ts->epg_stream) {
2637  if (!ts->epg_stream)
2638  return;
2639  ts->epg_stream->id = EIT_PID;
2642  }
2643 
2644  if (ts->epg_stream->discard == AVDISCARD_ALL)
2645  return;
2646 
2647  p_end = section + section_len - 4;
2648  p = section;
2649 
2650  if (parse_section_header(h, &p, p_end) < 0)
2651  return;
2652  if (h->tid < EIT_TID || h->tid > OEITS_END_TID)
2653  return;
2654 
2655  av_log(ts->stream, AV_LOG_TRACE, "EIT: tid received = %.02x\n", h->tid);
2656 
2657  /**
2658  * Service_id 0xFFFF is reserved, it indicates that the current EIT table
2659  * is scrambled.
2660  */
2661  if (h->id == 0xFFFF) {
2662  av_log(ts->stream, AV_LOG_TRACE, "Scrambled EIT table received.\n");
2663  return;
2664  }
2665 
2666  /**
2667  * In case we receive an EPG packet before mpegts context is fully
2668  * initialized.
2669  */
2670  if (!ts->pkt)
2671  return;
2672 
2673  new_data_packet(section, section_len, ts->pkt);
2674  ts->pkt->stream_index = ts->epg_stream->index;
2675  ts->stop_parse = 1;
2676 }
2677 
2678 static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2679 {
2680  MpegTSContext *ts = filter->u.section_filter.opaque;
2681  MpegTSSectionFilter *tssf = &filter->u.section_filter;
2682  SectionHeader h1, *h = &h1;
2683  const uint8_t *p, *p_end, *desc_list_end, *desc_end;
2684  int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
2685  char *name, *provider_name;
2686 
2687  av_log(ts->stream, AV_LOG_TRACE, "SDT:\n");
2688  hex_dump_debug(ts->stream, section, section_len);
2689 
2690  p_end = section + section_len - 4;
2691  p = section;
2692  if (parse_section_header(h, &p, p_end) < 0)
2693  return;
2694  if (h->tid != SDT_TID)
2695  return;
2696  if (!h->current_next)
2697  return;
2698  if (ts->skip_changes)
2699  return;
2700  if (skip_identical(h, tssf))
2701  return;
2702 
2703  onid = get16(&p, p_end);
2704  if (onid < 0)
2705  return;
2706  val = get8(&p, p_end);
2707  if (val < 0)
2708  return;
2709  for (;;) {
2710  sid = get16(&p, p_end);
2711  if (sid < 0)
2712  break;
2713  val = get8(&p, p_end);
2714  if (val < 0)
2715  break;
2716  desc_list_len = get16(&p, p_end);
2717  if (desc_list_len < 0)
2718  break;
2719  desc_list_len &= 0xfff;
2720  desc_list_end = p + desc_list_len;
2721  if (desc_list_end > p_end)
2722  break;
2723  for (;;) {
2724  desc_tag = get8(&p, desc_list_end);
2725  if (desc_tag < 0)
2726  break;
2727  desc_len = get8(&p, desc_list_end);
2728  desc_end = p + desc_len;
2729  if (desc_len < 0 || desc_end > desc_list_end)
2730  break;
2731 
2732  av_log(ts->stream, AV_LOG_TRACE, "tag: 0x%02x len=%d\n",
2733  desc_tag, desc_len);
2734 
2735  switch (desc_tag) {
2736  case 0x48:
2737  service_type = get8(&p, desc_end);
2738  if (service_type < 0)
2739  break;
2740  provider_name = getstr8(&p, desc_end);
2741  if (!provider_name)
2742  break;
2743  name = getstr8(&p, desc_end);
2744  if (name) {
2745  AVProgram *program = av_new_program(ts->stream, sid);
2746  if (program) {
2747  av_dict_set(&program->metadata, "service_name", name, 0);
2748  av_dict_set(&program->metadata, "service_provider",
2749  provider_name, 0);
2750  }
2751  }
2752  av_free(name);
2753  av_free(provider_name);
2754  break;
2755  default:
2756  break;
2757  }
2758  p = desc_end;
2759  }
2760  p = desc_list_end;
2761  }
2762 }
2763 
2764 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
2765  const uint8_t *packet);
2766 
2767 /* handle one TS packet */
2768 static int handle_packet(MpegTSContext *ts, const uint8_t *packet, int64_t pos)
2769 {
2770  MpegTSFilter *tss;
2771  int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,
2772  has_adaptation, has_payload;
2773  const uint8_t *p, *p_end;
2774 
2775  pid = AV_RB16(packet + 1) & 0x1fff;
2776  is_start = packet[1] & 0x40;
2777  tss = ts->pids[pid];
2778  if (ts->auto_guess && !tss && is_start) {
2779  add_pes_stream(ts, pid, -1);
2780  tss = ts->pids[pid];
2781  }
2782  if (!tss)
2783  return 0;
2784  if (is_start)
2785  tss->discard = discard_pid(ts, pid);
2786  if (tss->discard)
2787  return 0;
2788  ts->current_pid = pid;
2789 
2790  afc = (packet[3] >> 4) & 3;
2791  if (afc == 0) /* reserved value */
2792  return 0;
2793  has_adaptation = afc & 2;
2794  has_payload = afc & 1;
2795  is_discontinuity = has_adaptation &&
2796  packet[4] != 0 && /* with length > 0 */
2797  (packet[5] & 0x80); /* and discontinuity indicated */
2798 
2799  /* continuity check (currently not used) */
2800  cc = (packet[3] & 0xf);
2801  expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc;
2802  cc_ok = pid == 0x1FFF || // null packet PID
2803  is_discontinuity ||
2804  tss->last_cc < 0 ||
2805  expected_cc == cc;
2806 
2807  tss->last_cc = cc;
2808  if (!cc_ok) {
2809  av_log(ts->stream, AV_LOG_DEBUG,
2810  "Continuity check failed for pid %d expected %d got %d\n",
2811  pid, expected_cc, cc);
2812  if (tss->type == MPEGTS_PES) {
2813  PESContext *pc = tss->u.pes_filter.opaque;
2814  pc->flags |= AV_PKT_FLAG_CORRUPT;
2815  }
2816  }
2817 
2818  if (packet[1] & 0x80) {
2819  av_log(ts->stream, AV_LOG_DEBUG, "Packet had TEI flag set; marking as corrupt\n");
2820  if (tss->type == MPEGTS_PES) {
2821  PESContext *pc = tss->u.pes_filter.opaque;
2822  pc->flags |= AV_PKT_FLAG_CORRUPT;
2823  }
2824  }
2825 
2826  p = packet + 4;
2827  if (has_adaptation) {
2828  int64_t pcr_h;
2829  int pcr_l;
2830  if (parse_pcr(&pcr_h, &pcr_l, packet) == 0)
2831  tss->last_pcr = pcr_h * 300 + pcr_l;
2832  /* skip adaptation field */
2833  p += p[0] + 1;
2834  }
2835  /* if past the end of packet, ignore */
2836  p_end = packet + TS_PACKET_SIZE;
2837  if (p >= p_end || !has_payload)
2838  return 0;
2839 
2840  if (pos >= 0) {
2842  ts->pos47_full = pos - TS_PACKET_SIZE;
2843  }
2844 
2845  if (tss->type == MPEGTS_SECTION) {
2846  if (is_start) {
2847  /* pointer field present */
2848  len = *p++;
2849  if (len > p_end - p)
2850  return 0;
2851  if (len && cc_ok) {
2852  /* write remaining section bytes */
2853  write_section_data(ts, tss,
2854  p, len, 0);
2855  /* check whether filter has been closed */
2856  if (!ts->pids[pid])
2857  return 0;
2858  }
2859  p += len;
2860  if (p < p_end) {
2861  write_section_data(ts, tss,
2862  p, p_end - p, 1);
2863  }
2864  } else {
2865  if (cc_ok) {
2866  write_section_data(ts, tss,
2867  p, p_end - p, 0);
2868  }
2869  }
2870 
2871  // stop find_stream_info from waiting for more streams
2872  // when all programs have received a PMT
2873  if (ts->stream->ctx_flags & AVFMTCTX_NOHEADER && ts->scan_all_pmts <= 0) {
2874  int i;
2875  for (i = 0; i < ts->nb_prg; i++) {
2876  if (!ts->prg[i].pmt_found)
2877  break;
2878  }
2879  if (i == ts->nb_prg && ts->nb_prg > 0) {
2880  av_log(ts->stream, AV_LOG_DEBUG, "All programs have pmt, headers found\n");
2882  }
2883  }
2884 
2885  } else {
2886  int ret;
2887  // Note: The position here points actually behind the current packet.
2888  if (tss->type == MPEGTS_PES) {
2889  if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
2890  pos - ts->raw_packet_size)) < 0)
2891  return ret;
2892  }
2893  }
2894 
2895  return 0;
2896 }
2897 
2898 static int mpegts_resync(AVFormatContext *s, int seekback, const uint8_t *current_packet)
2899 {
2900  MpegTSContext *ts = s->priv_data;
2901  AVIOContext *pb = s->pb;
2902  int c, i;
2903  uint64_t pos = avio_tell(pb);
2904  int64_t back = FFMIN(seekback, pos);
2905 
2906  //Special case for files like 01c56b0dc1.ts
2907  if (current_packet[0] == 0x80 && current_packet[12] == 0x47 && pos >= TS_PACKET_SIZE) {
2908  avio_seek(pb, 12 - TS_PACKET_SIZE, SEEK_CUR);
2909  return 0;
2910  }
2911 
2912  avio_seek(pb, -back, SEEK_CUR);
2913 
2914  for (i = 0; i < ts->resync_size; i++) {
2915  c = avio_r8(pb);
2916  if (avio_feof(pb))
2917  return AVERROR_EOF;
2918  if (c == 0x47) {
2919  int new_packet_size, ret;
2920  avio_seek(pb, -1, SEEK_CUR);
2921  pos = avio_tell(pb);
2923  if (ret < 0)
2924  return ret;
2925  new_packet_size = get_packet_size(s);
2926  if (new_packet_size > 0 && new_packet_size != ts->raw_packet_size) {
2927  av_log(ts->stream, AV_LOG_WARNING, "changing packet size to %d\n", new_packet_size);
2928  ts->raw_packet_size = new_packet_size;
2929  }
2930  avio_seek(pb, pos, SEEK_SET);
2931  return 0;
2932  }
2933  }
2935  "max resync size reached, could not find sync byte\n");
2936  /* no sync found */
2937  return AVERROR_INVALIDDATA;
2938 }
2939 
2940 /* return AVERROR_something if error or EOF. Return 0 if OK. */
2941 static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size,
2942  const uint8_t **data)
2943 {
2944  AVIOContext *pb = s->pb;
2945  int len;
2946 
2947  for (;;) {
2949  if (len != TS_PACKET_SIZE)
2950  return len < 0 ? len : AVERROR_EOF;
2951  /* check packet sync byte */
2952  if ((*data)[0] != 0x47) {
2953  /* find a new packet start */
2954 
2955  if (mpegts_resync(s, raw_packet_size, *data) < 0)
2956  return AVERROR(EAGAIN);
2957  else
2958  continue;
2959  } else {
2960  break;
2961  }
2962  }
2963  return 0;
2964 }
2965 
2966 static void finished_reading_packet(AVFormatContext *s, int raw_packet_size)
2967 {
2968  AVIOContext *pb = s->pb;
2969  int skip = raw_packet_size - TS_PACKET_SIZE;
2970  if (skip > 0)
2971  avio_skip(pb, skip);
2972 }
2973 
2974 static int handle_packets(MpegTSContext *ts, int64_t nb_packets)
2975 {
2976  AVFormatContext *s = ts->stream;
2977  uint8_t packet[TS_PACKET_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
2978  const uint8_t *data;
2979  int64_t packet_num;
2980  int ret = 0;
2981 
2982  if (avio_tell(s->pb) != ts->last_pos) {
2983  int i;
2984  av_log(ts->stream, AV_LOG_TRACE, "Skipping after seek\n");
2985  /* seek detected, flush pes buffer */
2986  for (i = 0; i < NB_PID_MAX; i++) {
2987  if (ts->pids[i]) {
2988  if (ts->pids[i]->type == MPEGTS_PES) {
2989  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
2990  av_buffer_unref(&pes->buffer);
2991  pes->data_index = 0;
2992  pes->state = MPEGTS_SKIP; /* skip until pes header */
2993  } else if (ts->pids[i]->type == MPEGTS_SECTION) {
2994  ts->pids[i]->u.section_filter.last_ver = -1;
2995  }
2996  ts->pids[i]->last_cc = -1;
2997  ts->pids[i]->last_pcr = -1;
2998  }
2999  }
3000  }
3001 
3002  ts->stop_parse = 0;
3003  packet_num = 0;
3004  memset(packet + TS_PACKET_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3005  for (;;) {
3006  packet_num++;
3007  if (nb_packets != 0 && packet_num >= nb_packets ||
3008  ts->stop_parse > 1) {
3009  ret = AVERROR(EAGAIN);
3010  break;
3011  }
3012  if (ts->stop_parse > 0)
3013  break;
3014 
3015  ret = read_packet(s, packet, ts->raw_packet_size, &data);
3016  if (ret != 0)
3017  break;
3018  ret = handle_packet(ts, data, avio_tell(s->pb));
3020  if (ret != 0)
3021  break;
3022  }
3023  ts->last_pos = avio_tell(s->pb);
3024  return ret;
3025 }
3026 
3027 static int mpegts_probe(const AVProbeData *p)
3028 {
3029  const int size = p->buf_size;
3030  int maxscore = 0;
3031  int sumscore = 0;
3032  int i;
3033  int check_count = size / TS_FEC_PACKET_SIZE;
3034 #define CHECK_COUNT 10
3035 #define CHECK_BLOCK 100
3036 
3037  if (!check_count)
3038  return 0;
3039 
3040  for (i = 0; i<check_count; i+=CHECK_BLOCK) {
3041  int left = FFMIN(check_count - i, CHECK_BLOCK);
3042  int score = analyze(p->buf + TS_PACKET_SIZE *i, TS_PACKET_SIZE *left, TS_PACKET_SIZE , 1);
3045  score = FFMAX3(score, dvhs_score, fec_score);
3046  sumscore += score;
3047  maxscore = FFMAX(maxscore, score);
3048  }
3049 
3050  sumscore = sumscore * CHECK_COUNT / check_count;
3051  maxscore = maxscore * CHECK_COUNT / CHECK_BLOCK;
3052 
3053  ff_dlog(0, "TS score: %d %d\n", sumscore, maxscore);
3054 
3055  if (check_count > CHECK_COUNT && sumscore > 6) {
3056  return AVPROBE_SCORE_MAX + sumscore - CHECK_COUNT;
3057  } else if (check_count >= CHECK_COUNT && sumscore > 6) {
3058  return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT;
3059  } else if (check_count >= CHECK_COUNT && maxscore > 6) {
3060  return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT;
3061  } else if (sumscore > 6) {
3062  return 2;
3063  } else {
3064  return 0;
3065  }
3066 }
3067 
3068 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
3069  * (-1) if not available */
3070 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet)
3071 {
3072  int afc, len, flags;
3073  const uint8_t *p;
3074  unsigned int v;
3075 
3076  afc = (packet[3] >> 4) & 3;
3077  if (afc <= 1)
3078  return AVERROR_INVALIDDATA;
3079  p = packet + 4;
3080  len = p[0];
3081  p++;
3082  if (len == 0)
3083  return AVERROR_INVALIDDATA;
3084  flags = *p++;
3085  len--;
3086  if (!(flags & 0x10))
3087  return AVERROR_INVALIDDATA;
3088  if (len < 6)
3089  return AVERROR_INVALIDDATA;
3090  v = AV_RB32(p);
3091  *ppcr_high = ((int64_t) v << 1) | (p[4] >> 7);
3092  *ppcr_low = ((p[4] & 1) << 8) | p[5];
3093  return 0;
3094 }
3095 
3097 
3098  /* NOTE: We attempt to seek on non-seekable files as well, as the
3099  * probe buffer usually is big enough. Only warn if the seek failed
3100  * on files where the seek should work. */
3101  if (avio_seek(pb, pos, SEEK_SET) < 0)
3102  av_log(s, (pb->seekable & AVIO_SEEKABLE_NORMAL) ? AV_LOG_ERROR : AV_LOG_INFO, "Unable to seek back to the start\n");
3103 }
3104 
3106 {
3107  MpegTSContext *ts = s->priv_data;
3108  AVIOContext *pb = s->pb;
3109  int64_t pos, probesize = s->probesize;
3110  int64_t seekback = FFMAX(s->probesize, (int64_t)ts->resync_size + PROBE_PACKET_MAX_BUF);
3111 
3113 
3114  if (ffio_ensure_seekback(pb, seekback) < 0)
3115  av_log(s, AV_LOG_WARNING, "Failed to allocate buffers for seekback\n");
3116 
3117  pos = avio_tell(pb);
3119  if (ts->raw_packet_size <= 0) {
3120  av_log(s, AV_LOG_WARNING, "Could not detect TS packet size, defaulting to non-FEC/DVHS\n");
3122  }
3123  ts->stream = s;
3124  ts->auto_guess = 0;
3125 
3126  if (s->iformat == &ff_mpegts_demuxer.p) {
3127  /* normal demux */
3128 
3129  /* first do a scan to get all the services */
3130  seek_back(s, pb, pos);
3131 
3135 
3136  handle_packets(ts, probesize / ts->raw_packet_size);
3137  /* if could not find service, enable auto_guess */
3138 
3139  ts->auto_guess = 1;
3140 
3141  av_log(ts->stream, AV_LOG_TRACE, "tuning done\n");
3142 
3143  s->ctx_flags |= AVFMTCTX_NOHEADER;
3144  } else {
3145  AVStream *st;
3146  int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
3147  int64_t pcrs[2], pcr_h;
3148  uint8_t packet[TS_PACKET_SIZE];
3149  const uint8_t *data;
3150 
3151  /* only read packets */
3152 
3153  st = avformat_new_stream(s, NULL);
3154  if (!st)
3155  return AVERROR(ENOMEM);
3156  avpriv_set_pts_info(st, 60, 1, 27000000);
3159 
3160  /* we iterate until we find two PCRs to estimate the bitrate */
3161  pcr_pid = -1;
3162  nb_pcrs = 0;
3163  nb_packets = 0;
3164  for (;;) {
3165  ret = read_packet(s, packet, ts->raw_packet_size, &data);
3166  if (ret < 0)
3167  return ret;
3168  pid = AV_RB16(data + 1) & 0x1fff;
3169  if ((pcr_pid == -1 || pcr_pid == pid) &&
3170  parse_pcr(&pcr_h, &pcr_l, data) == 0) {
3172  pcr_pid = pid;
3173  pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
3174  nb_pcrs++;
3175  if (nb_pcrs >= 2) {
3176  if (pcrs[1] - pcrs[0] > 0) {
3177  /* the difference needs to be positive to make sense for bitrate computation */
3178  break;
3179  } else {
3180  av_log(ts->stream, AV_LOG_WARNING, "invalid pcr pair %"PRId64" >= %"PRId64"\n", pcrs[0], pcrs[1]);
3181  pcrs[0] = pcrs[1];
3182  nb_pcrs--;
3183  }
3184  }
3185  } else {
3187  }
3188  nb_packets++;
3189  }
3190 
3191  /* NOTE1: the bitrate is computed without the FEC */
3192  /* NOTE2: it is only the bitrate of the start of the stream */
3193  ts->pcr_incr = pcrs[1] - pcrs[0];
3194  ts->cur_pcr = pcrs[0] - ts->pcr_incr * (nb_packets - 1);
3195  s->bit_rate = TS_PACKET_SIZE * 8 * 27000000LL / ts->pcr_incr;
3196  st->codecpar->bit_rate = s->bit_rate;
3197  st->start_time = ts->cur_pcr;
3198  av_log(ts->stream, AV_LOG_TRACE, "start=%0.3f pcr=%0.3f incr=%"PRId64"\n",
3199  st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
3200  }
3201 
3202  seek_back(s, pb, pos);
3203  return 0;
3204 }
3205 
3206 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
3207 
3209 {
3210  MpegTSContext *ts = s->priv_data;
3211  int ret, i;
3212  int64_t pcr_h, next_pcr_h, pos;
3213  int pcr_l, next_pcr_l;
3214  uint8_t pcr_buf[12];
3215  const uint8_t *data;
3216 
3217  if ((ret = av_new_packet(pkt, TS_PACKET_SIZE)) < 0)
3218  return ret;
3220  pkt->pos = avio_tell(s->pb);
3221  if (ret < 0) {
3222  return ret;
3223  }
3224  if (data != pkt->data)
3225  memcpy(pkt->data, data, TS_PACKET_SIZE);
3227  if (ts->mpeg2ts_compute_pcr) {
3228  /* compute exact PCR for each packet */
3229  if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
3230  /* we read the next PCR (XXX: optimize it by using a bigger buffer */
3231  pos = avio_tell(s->pb);
3232  for (i = 0; i < MAX_PACKET_READAHEAD; i++) {
3233  avio_seek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
3234  avio_read(s->pb, pcr_buf, 12);
3235  if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
3236  /* XXX: not precise enough */
3237  ts->pcr_incr =
3238  ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
3239  (i + 1);
3240  break;
3241  }
3242  }
3243  avio_seek(s->pb, pos, SEEK_SET);
3244  /* no next PCR found: we use previous increment */
3245  ts->cur_pcr = pcr_h * 300 + pcr_l;
3246  }
3247  pkt->pts = ts->cur_pcr;
3248  pkt->duration = ts->pcr_incr;
3249  ts->cur_pcr += ts->pcr_incr;
3250  }
3251  pkt->stream_index = 0;
3252  return 0;
3253 }
3254 
3256 {
3257  MpegTSContext *ts = s->priv_data;
3258  int ret, i;
3259 
3260  pkt->size = -1;
3261  ts->pkt = pkt;
3262  ret = handle_packets(ts, 0);
3263  if (ret < 0) {
3264  av_packet_unref(ts->pkt);
3265  /* flush pes data left */
3266  for (i = 0; i < NB_PID_MAX; i++)
3267  if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
3268  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
3269  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
3270  ret = new_pes_packet(pes, pkt);
3271  if (ret < 0)
3272  return ret;
3273  pes->state = MPEGTS_SKIP;
3274  ret = 0;
3275  break;
3276  }
3277  }
3278  }
3279 
3280  if (!ret && pkt->size < 0)
3282  return ret;
3283 }
3284 
3285 static void mpegts_free(MpegTSContext *ts)
3286 {
3287  int i;
3288 
3289  clear_programs(ts);
3290 
3291  for (i = 0; i < FF_ARRAY_ELEMS(ts->pools); i++)
3292  av_buffer_pool_uninit(&ts->pools[i]);
3293 
3294  for (i = 0; i < NB_PID_MAX; i++)
3295  if (ts->pids[i])
3296  mpegts_close_filter(ts, ts->pids[i]);
3297 }
3298 
3300 {
3301  MpegTSContext *ts = s->priv_data;
3302  mpegts_free(ts);
3303  return 0;
3304 }
3305 
3307  int64_t *ppos, int64_t pos_limit)
3308 {
3309  MpegTSContext *ts = s->priv_data;
3310  int64_t pos, timestamp;
3311  uint8_t buf[TS_PACKET_SIZE];
3312  int pcr_l, pcr_pid =
3313  ((PESContext *)s->streams[stream_index]->priv_data)->pcr_pid;
3314  int pos47 = ts->pos47_full % ts->raw_packet_size;
3315  pos =
3316  ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) *
3317  ts->raw_packet_size + pos47;
3318  while(pos < pos_limit) {
3319  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
3320  return AV_NOPTS_VALUE;
3321  if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
3322  return AV_NOPTS_VALUE;
3323  if (buf[0] != 0x47) {
3324  if (mpegts_resync(s, TS_PACKET_SIZE, buf) < 0)
3325  return AV_NOPTS_VALUE;
3326  pos = avio_tell(s->pb);
3327  continue;
3328  }
3329  if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
3330  parse_pcr(&timestamp, &pcr_l, buf) == 0) {
3331  *ppos = pos;
3332  return timestamp;
3333  }
3334  pos += ts->raw_packet_size;
3335  }
3336 
3337  return AV_NOPTS_VALUE;
3338 }
3339 
3340 static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index,
3341  int64_t *ppos, int64_t pos_limit)
3342 {
3343  MpegTSContext *ts = s->priv_data;
3344  AVPacket *pkt;
3345  int64_t pos;
3346  int pos47 = ts->pos47_full % ts->raw_packet_size;
3347  pos = ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) * ts->raw_packet_size + pos47;
3349  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
3350  return AV_NOPTS_VALUE;
3351  pkt = av_packet_alloc();
3352  if (!pkt)
3353  return AV_NOPTS_VALUE;
3354  while(pos < pos_limit) {
3355  int ret = av_read_frame(s, pkt);
3356  if (ret < 0) {
3357  av_packet_free(&pkt);
3358  return AV_NOPTS_VALUE;
3359  }
3360  if (pkt->dts != AV_NOPTS_VALUE && pkt->pos >= 0) {
3362  av_add_index_entry(s->streams[pkt->stream_index], pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
3363  if (pkt->stream_index == stream_index && pkt->pos >= *ppos) {
3364  int64_t dts = pkt->dts;
3365  *ppos = pkt->pos;
3366  av_packet_free(&pkt);
3367  return dts;
3368  }
3369  }
3370  pos = pkt->pos;
3372  }
3373 
3374  av_packet_free(&pkt);
3375  return AV_NOPTS_VALUE;
3376 }
3377 
3378 /**************************************************************/
3379 /* parsing functions - called from other demuxers such as RTP */
3380 
3382 {
3383  MpegTSContext *ts;
3384 
3385  ts = av_mallocz(sizeof(MpegTSContext));
3386  if (!ts)
3387  return NULL;
3388  /* no stream case, currently used by RTP */
3390  ts->max_packet_size = 2048000;
3391  ts->stream = s;
3392  ts->auto_guess = 1;
3393 
3397 
3398  return ts;
3399 }
3400 
3401 /* return the consumed length if a packet was output, or -1 if no
3402  * packet is output */
3404  const uint8_t *buf, int len)
3405 {
3406  int len1;
3407 
3408  len1 = len;
3409  ts->pkt = pkt;
3410  for (;;) {
3411  ts->stop_parse = 0;
3412  if (len < TS_PACKET_SIZE)
3413  return AVERROR_INVALIDDATA;
3414  if (buf[0] != 0x47) {
3415  buf++;
3416  len--;
3417  } else {
3418  handle_packet(ts, buf, len1 - len + TS_PACKET_SIZE);
3419  buf += TS_PACKET_SIZE;
3420  len -= TS_PACKET_SIZE;
3421  if (ts->stop_parse == 1)
3422  break;
3423  }
3424  }
3425  return len1 - len;
3426 }
3427 
3429 {
3430  mpegts_free(ts);
3431  av_free(ts);
3432 }
3433 
3435  .p.name = "mpegts",
3436  .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
3437  .p.flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
3438  .p.priv_class = &mpegts_class,
3439  .priv_data_size = sizeof(MpegTSContext),
3445 };
3446 
3448  .p.name = "mpegtsraw",
3449  .p.long_name = NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"),
3450  .p.flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
3451  .p.priv_class = &mpegtsraw_class,
3452  .priv_data_size = sizeof(MpegTSContext),
3457 };
parse_MP4DecConfigDescrTag
static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1558
mpegts_set_stream_info
static int mpegts_set_stream_info(AVStream *st, PESContext *pes, uint32_t stream_type, uint32_t prog_reg_desc)
Definition: mpegts.c:916
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:428
parse_mp4_descr_arr
static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1498
new_pes_packet
static int new_pes_packet(PESContext *pes, AVPacket *pkt)
Definition: mpegts.c:1011
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:280
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
StreamType::stream_type
uint32_t stream_type
Definition: mpegts.c:795
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
MP4DescrParseContext::descr_count
int descr_count
Definition: mpegts.c:1463
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
MP4DecConfigDescrTag
#define MP4DecConfigDescrTag
Definition: isom.h:373
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:443
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
MPEGTS_PESHEADER_FILL
@ MPEGTS_PESHEADER_FILL
Definition: mpegts.c:243
MpegTSFilter::discard
int discard
Definition: mpegts.c:103
Program::nb_streams
unsigned int nb_streams
Definition: mpegts.c:122
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
MAX_LEVEL
#define MAX_LEVEL
Definition: mpegts.c:1457
AV_CODEC_ID_PCM_BLURAY
@ AV_CODEC_ID_PCM_BLURAY
Definition: codec_id.h:352
FFFormatContext::prefer_codec_framerate
int prefer_codec_framerate
Definition: internal.h:175
PAT_PID
#define PAT_PID
Definition: mpegts.h:37
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:477
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:420
mpegts.h
AVProgram::nb_stream_indexes
unsigned int nb_stream_indexes
Definition: avformat.h:1189
out
FILE * out
Definition: movenc.c:55
ff_parse_pes_pts
static int64_t ff_parse_pes_pts(const uint8_t *buf)
Parse MPEG-PES five-byte timestamp.
Definition: mpeg.h:69
TS_DVHS_PACKET_SIZE
#define TS_DVHS_PACKET_SIZE
Definition: mpegts.h:28
pmt_cb
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:2316
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:88
MpegTSFilter::pid
int pid
Definition: mpegts.c:99
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:188
ffio_read_indirect
int ffio_read_indirect(AVIOContext *s, unsigned char *buf, int size, const unsigned char **data)
Read size bytes from AVIOContext, returning a pointer.
Definition: aviobuf.c:672
STREAM_TYPE_PRIVATE_DATA
#define STREAM_TYPE_PRIVATE_DATA
Definition: mpeg.h:54
PESContext::flags
int flags
copied to the AVPacket flags
Definition: mpegts.c:264
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVStream::priv_data
void * priv_data
Definition: avformat.h:773
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
avpriv_mpegts_parse_packet
int avpriv_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt, const uint8_t *buf, int len)
Definition: mpegts.c:3403
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
opus_default_extradata
static const uint8_t opus_default_extradata[30]
Definition: opus.h:35
avcodec_get_type
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: codec_desc.c:3760
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:819
av_find_program_from_stream
AVProgram * av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
Find the programs which belong to a given stream.
Definition: avformat.c:392
STREAM_ID_EMM_STREAM
#define STREAM_ID_EMM_STREAM
Definition: mpegts.h:151
mpegts_close_filter
static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
Definition: mpegts.c:561
STREAM_ID_PADDING_STREAM
#define STREAM_ID_PADDING_STREAM
Definition: mpegts.h:146
AV_CODEC_ID_DIRAC
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:168
int64_t
long long int64_t
Definition: coverity.c:34
STREAM_ID_PROGRAM_STREAM_MAP
#define STREAM_ID_PROGRAM_STREAM_MAP
Definition: mpegts.h:144
SLConfigDescr::au_seq_num_len
int au_seq_num_len
Definition: mpegts.h:188
Program::pmt_found
int pmt_found
have we found pmt for this program
Definition: mpegts.c:126
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
PESContext::dts
int64_t dts
Definition: mpegts.c:269
METADATA_types
static const StreamType METADATA_types[]
Definition: mpegts.c:882
av_unused
#define av_unused
Definition: attributes.h:131
MP4DescrParseContext::max_descr_count
int max_descr_count
Definition: mpegts.c:1464
Stream::stream_identifier
int stream_identifier
Definition: mpegts.c:113
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
MpegTSContext::skip_changes
int skip_changes
Definition: mpegts.c:158
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1328
ff_mp4_read_dec_config_descr
int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext *pb)
Definition: isom.c:329
mpegts_find_stream_type
static void mpegts_find_stream_type(AVStream *st, uint32_t stream_type, const StreamType *types)
Definition: mpegts.c:898
MpegTSContext::auto_guess
int auto_guess
if true, all pids are analyzed to find streams
Definition: mpegts.c:139
AVPacket::data
uint8_t * data
Definition: packet.h:533
AV_CODEC_ID_DVB_TELETEXT
@ AV_CODEC_ID_DVB_TELETEXT
Definition: codec_id.h:557
clear_avprogram
static void clear_avprogram(MpegTSContext *ts, unsigned int programid)
Definition: mpegts.c:290
CHECK_BLOCK
#define CHECK_BLOCK
AVOption
AVOption.
Definition: opt.h:357
MpegTSSectionFilter
Definition: mpegts.c:85
MPEGTS_SECTION
@ MPEGTS_SECTION
Definition: mpegts.c:67
getstr8
static char * getstr8(const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:697
MpegTSSectionFilter::section_h_size
int section_h_size
Definition: mpegts.c:87
AV_CODEC_ID_AVS2
@ AV_CODEC_ID_AVS2
Definition: codec_id.h:246
data
const char data[16]
Definition: mxf.c:148
opus.h
MpegTSFilter::section_filter
MpegTSSectionFilter section_filter
Definition: mpegts.c:107
HLS_SAMPLE_ENC_types
static const StreamType HLS_SAMPLE_ENC_types[]
Definition: mpegts.c:855
MpegTSState
MpegTSState
Definition: mpegts.c:240
MP4SLDescrTag
#define MP4SLDescrTag
Definition: isom.h:375
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
MP4DescrParseContext::s
AVFormatContext * s
Definition: mpegts.c:1459
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
buffer_pool_get
static AVBufferRef * buffer_pool_get(MpegTSContext *ts, int size)
Definition: mpegts.c:1129
PES_HEADER_SIZE
#define PES_HEADER_SIZE
Definition: mpegts.c:250
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:464
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1461
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:551
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
ffio_init_read_context
void ffio_init_read_context(FFIOContext *s, const uint8_t *buffer, int buffer_size)
Wrap a buffer in an AVIOContext for reading.
Definition: aviobuf.c:99
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
SetServiceCallback
void SetServiceCallback(void *opaque, int ret)
Definition: mpegts.c:83
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1538
AV_PROFILE_ARIB_PROFILE_C
#define AV_PROFILE_ARIB_PROFILE_C
Definition: defs.h:188
Stream::idx
int idx
Definition: mpegts.c:112
AV_CODEC_ID_HDMV_PGS_SUBTITLE
@ AV_CODEC_ID_HDMV_PGS_SUBTITLE
Definition: codec_id.h:556
ff_read_frame_flush
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: seek.c:721
add_pid_to_program
static void add_pid_to_program(struct Program *p, unsigned int pid)
Definition: mpegts.c:336
PESContext::pts
int64_t pts
Definition: mpegts.c:269
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:484
FFIOContext
Definition: avio_internal.h:28
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
MpegTSContext::nb_prg
unsigned int nb_prg
structure to keep track of Program->pids mapping
Definition: mpegts.c:174
MpegTSPESFilter::pes_cb
PESCallback * pes_cb
Definition: mpegts.c:77
Program::streams
struct Stream streams[MAX_STREAMS_PER_PROGRAM]
Definition: mpegts.c:123
AV_CODEC_ID_BIN_DATA
@ AV_CODEC_ID_BIN_DATA
Definition: codec_id.h:590
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
PESContext::pcr_pid
int pcr_pid
if -1 then all packets containing PCR are considered
Definition: mpegts.c:255
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
SectionHeader::id
uint16_t id
Definition: mpegts.c:651
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
SLConfigDescr::use_idle
int use_idle
Definition: mpegts.h:181
AV_PKT_DATA_DOVI_CONF
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
Definition: packet.h:280
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
PROBE_PACKET_MAX_BUF
#define PROBE_PACKET_MAX_BUF
Definition: mpegts.c:62
mpegtsraw_class
static const AVClass mpegtsraw_class
Definition: mpegts.c:231
AV_PROFILE_ARIB_PROFILE_A
#define AV_PROFILE_ARIB_PROFILE_A
Definition: defs.h:187
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
PESContext::state
enum MpegTSState state
Definition: mpegts.c:261
MpegTSFilter::pes_filter
MpegTSPESFilter pes_filter
Definition: mpegts.c:106
METADATA_DESCRIPTOR
#define METADATA_DESCRIPTOR
Definition: mpegts.h:165
SLConfigDescr::inst_bitrate_len
int inst_bitrate_len
Definition: mpegts.h:186
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:855
REGISTRATION_DESCRIPTOR
#define REGISTRATION_DESCRIPTOR
Definition: mpegts.h:160
mpegts_read_close
static int mpegts_read_close(AVFormatContext *s)
Definition: mpegts.c:3299
mpegts_raw_read_packet
static int mpegts_raw_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegts.c:3208
find_matching_stream
static AVStream * find_matching_stream(MpegTSContext *ts, int pid, unsigned int programid, int stream_identifier, int pmt_stream_idx, struct Program *p)
Definition: mpegts.c:2248
update_av_program_info
static void update_av_program_info(AVFormatContext *s, unsigned int programid, unsigned int pid, int version)
Definition: mpegts.c:352
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:419
MP4ODescrTag
#define MP4ODescrTag
Definition: isom.h:370
PESCallback
int PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos)
Definition: mpegts.c:73
VIDEO_STREAM_DESCRIPTOR
#define VIDEO_STREAM_DESCRIPTOR
Definition: mpegts.h:159
STREAM_ID_DSMCC_STREAM
#define STREAM_ID_DSMCC_STREAM
Definition: mpegts.h:152
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: seek.c:121
pat_cb
static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:2536
GetBitContext
Definition: get_bits.h:108
Program::nb_pids
unsigned int nb_pids
Definition: mpegts.c:120
SLConfigDescr::use_padding
int use_padding
Definition: mpegts.h:179
mp4_read_iods
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:1669
AVProgram::discard
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:1187
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
AV_DISPOSITION_STILL_IMAGE
#define AV_DISPOSITION_STILL_IMAGE
The video stream contains still images.
Definition: avformat.h:713
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
SectionHeader::last_sec_num
uint8_t last_sec_num
Definition: mpegts.c:655
val
static double val(void *priv, double ch)
Definition: aeval.c:78
EIT_TID
#define EIT_TID
Definition: mpegts.h:95
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
MP4IODescrTag
#define MP4IODescrTag
Definition: isom.h:371
PESContext::sl
SLConfigDescr sl
Definition: mpegts.c:273
SLConfigDescr::use_rand_acc_pt
int use_rand_acc_pt
Definition: mpegts.h:178
SDT_PID
#define SDT_PID
Definition: mpegts.h:43
av_new_program
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: avformat.c:334
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:441
PESContext::stream
AVFormatContext * stream
Definition: mpegts.c:258
SLConfigDescr::timestamp_len
int timestamp_len
Definition: mpegts.h:183
MAX_SECTION_SIZE
#define MAX_SECTION_SIZE
Definition: mpegts.h:34
av_dovi_alloc
AVDOVIDecoderConfigurationRecord * av_dovi_alloc(size_t *size)
Allocate a AVDOVIDecoderConfigurationRecord structure and initialize its fields to default values.
Definition: dovi_meta.c:26
STREAM_ID_METADATA_STREAM
#define STREAM_ID_METADATA_STREAM
Definition: mpegts.h:154
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:551
PESContext::sub_st
AVStream * sub_st
stream for the embedded AC3 stream in HDMV TrueHD
Definition: mpegts.c:260
ff_mp4_parse_es_descr
void ff_mp4_parse_es_descr(AVIOContext *pb, int *es_id)
Definition: isom.c:304
SectionHeader::current_next
uint8_t current_next
Definition: mpegts.c:653
MpegTSContext::merge_pmt_versions
int merge_pmt_versions
Definition: mpegts.c:165
AV_DISPOSITION_CLEAN_EFFECTS
#define AV_DISPOSITION_CLEAN_EFFECTS
The audio stream contains music and sound effects without voice.
Definition: avformat.h:666
PESContext::header
uint8_t header[MAX_PES_HEADER_SIZE]
Definition: mpegts.c:271
avassert.h
MPEGTS_OPTIONS
#define MPEGTS_OPTIONS
Definition: mpegts.c:186
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
MpegTSContext::pos47_full
int64_t pos47_full
Definition: mpegts.c:136
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
avpriv_mpegts_parse_close
void avpriv_mpegts_parse_close(MpegTSContext *ts)
Definition: mpegts.c:3428
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
MpegTSContext::id
int id
Definition: mpegts.c:168
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
StreamType::codec_id
enum AVCodecID codec_id
Definition: mpegts.c:797
PESContext
Definition: mpegts.c:253
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:589
Mp4Descr::sl
SLConfigDescr sl
Definition: mpegts.h:196
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
opus_coupled_stream_cnt
static const uint8_t opus_coupled_stream_cnt[9]
Definition: mpegts.c:1794
AVFormatContext::ctx_flags
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1309
AVProgram::id
int id
Definition: avformat.h:1185
ff_parse_mpeg2_descriptor
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:1813
MpegTSContext::pools
AVBufferPool * pools[32]
Definition: mpegts.c:183
parse_pcr
static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet)
Definition: mpegts.c:3070
AV_CODEC_ID_S302M
@ AV_CODEC_ID_S302M
Definition: codec_id.h:354
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:384
MpegTSContext::stream
AVFormatContext * stream
Definition: mpegts.c:132
AV_CODEC_ID_MPEG4SYSTEMS
@ AV_CODEC_ID_MPEG4SYSTEMS
FAKE codec to indicate a MPEG-4 Systems stream (only used by libavformat)
Definition: codec_id.h:598
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:98
mpegts_get_pcr
static av_unused int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: mpegts.c:3306
mpegts_class
static const AVClass mpegts_class
Definition: mpegts.c:216
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1460
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
bits
uint8_t bits
Definition: vp3data.h:128
SLConfigDescr::degr_prior_len
int degr_prior_len
Definition: mpegts.h:187
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ff_mpegtsraw_demuxer
const FFInputFormat ff_mpegtsraw_demuxer
Definition: mpegts.c:3447
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
mpegts_open_filter
static MpegTSFilter * mpegts_open_filter(MpegTSContext *ts, unsigned int pid, enum MpegTSFilterType type)
Definition: mpegts.c:490
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:57
PES_START_SIZE
#define PES_START_SIZE
Definition: mpegts.c:249
MpegTSContext::resync_size
int resync_size
Definition: mpegts.c:164
channels
channels
Definition: aptx.h:31
get_bits.h
SectionHeader::sec_num
uint8_t sec_num
Definition: mpegts.c:654
STREAM_ID_TYPE_E_STREAM
#define STREAM_ID_TYPE_E_STREAM
Definition: mpegts.h:153
nb_streams
static int nb_streams
Definition: ffprobe.c:384
PESContext::stream_type
int stream_type
Definition: mpegts.c:256
parse_MP4IODescrTag
static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1509
PMT_TID
#define PMT_TID
Definition: mpegts.h:81
skip_identical
static int skip_identical(const SectionHeader *h, MpegTSSectionFilter *tssf)
Definition: mpegts.c:658
opus_stream_cnt
static const uint8_t opus_stream_cnt[9]
Definition: mpegts.c:1798
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AVDOVIDecoderConfigurationRecord::dv_version_major
uint8_t dv_version_major
Definition: dovi_meta.h:55
MPEGTS_SKIP
@ MPEGTS_SKIP
Definition: mpegts.c:245
MpegTSPESFilter::opaque
void * opaque
Definition: mpegts.c:78
get8
static int get8(const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:669
discard_pid
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:382
AV_CODEC_ID_ARIB_CAPTION
@ AV_CODEC_ID_ARIB_CAPTION
Definition: codec_id.h:575
if
if(ret)
Definition: filter_design.txt:179
MpegTSContext::cur_pcr
int64_t cur_pcr
used to estimate the exact PCR
Definition: mpegts.c:147
clear_programs
static void clear_programs(MpegTSContext *ts)
Definition: mpegts.c:314
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
MP4ESDescrTag
#define MP4ESDescrTag
Definition: isom.h:372
AV_CODEC_ID_AVS3
@ AV_CODEC_ID_AVS3
Definition: codec_id.h:248
MP4DescrParseContext::active_descr
Mp4Descr * active_descr
Definition: mpegts.c:1462
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:220
AVFormatContext
Format I/O context.
Definition: avformat.h:1260
FMC_DESCRIPTOR
#define FMC_DESCRIPTOR
Definition: mpegts.h:164
internal.h
MpegTSContext::pcr_incr
int64_t pcr_incr
used to estimate the exact PCR
Definition: mpegts.c:148
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:516
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVDOVIDecoderConfigurationRecord::dv_level
uint8_t dv_level
Definition: dovi_meta.h:58
av_program_add_stream_index
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: avformat.c:365
AVDOVIDecoderConfigurationRecord::dv_bl_signal_compatibility_id
uint8_t dv_bl_signal_compatibility_id
Definition: dovi_meta.h:62
MPEGTS_HEADER
@ MPEGTS_HEADER
Definition: mpegts.c:241
MpegTSSectionFilter::crc
unsigned crc
Definition: mpegts.c:89
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
MpegTSContext::stop_parse
int stop_parse
stop parsing loop
Definition: mpegts.c:152
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1211
isom.h
AV_CODEC_ID_TIMED_ID3
@ AV_CODEC_ID_TIMED_ID3
Definition: codec_id.h:589
MpegTSContext::current_pid
int current_pid
Definition: mpegts.c:180
MpegTSSectionFilter::section_index
int section_index
Definition: mpegts.c:86
MpegTSContext::last_pos
int64_t last_pos
to detect seek
Definition: mpegts.c:156
Mp4Descr::es_id
int es_id
Definition: mpegts.h:193
MpegTSFilter::es_id
int es_id
Definition: mpegts.c:100
MPEGTS_PESHEADER
@ MPEGTS_PESHEADER
Definition: mpegts.c:242
DESC_types
static const StreamType DESC_types[]
Definition: mpegts.c:889
PESContext::extended_stream_id
int extended_stream_id
Definition: mpegts.c:267
Mp4Descr::dec_config_descr_len
int dec_config_descr_len
Definition: mpegts.h:194
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
MpegTSSectionFilter::section_buf
uint8_t * section_buf
Definition: mpegts.c:91
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
eit_cb
static void eit_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:2624
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:322
MpegTSFilter::type
enum MpegTSFilterType type
Definition: mpegts.c:104
mpegts_open_pcr_filter
static MpegTSFilter * mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid)
Definition: mpegts.c:556
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
SectionHeader::version
uint8_t version
Definition: mpegts.c:652
seek_back
static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos)
Definition: mpegts.c:3096
SLConfigDescr::ocr_len
int ocr_len
Definition: mpegts.h:184
AVProgram::stream_index
unsigned int * stream_index
Definition: avformat.h:1188
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:828
AV_CODEC_ID_MPEG2TS
@ AV_CODEC_ID_MPEG2TS
FAKE codec to indicate a raw MPEG-2 TS stream (only used by libavformat)
Definition: codec_id.h:596
add_pes_stream
static PESContext * add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
Definition: mpegts.c:1433
MpegTSFilterType
MpegTSFilterType
Definition: mpegts.c:65
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
StreamType
Definition: mpegts.c:794
AV_CODEC_ID_SMPTE_KLV
@ AV_CODEC_ID_SMPTE_KLV
Definition: codec_id.h:587
ff_mp4_read_descr
int ff_mp4_read_descr(AVFormatContext *fc, AVIOContext *pb, int *tag)
Definition: isom.c:295
mpegts_open_section_filter
static MpegTSFilter * mpegts_open_section_filter(MpegTSContext *ts, unsigned int pid, SectionCallback *section_cb, void *opaque, int check_crc)
Definition: mpegts.c:513
SLConfigDescr::packet_seq_num_len
int packet_seq_num_len
Definition: mpegts.h:189
mpegts_open_pes_filter
static MpegTSFilter * mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid, PESCallback *pes_cb, void *opaque)
Definition: mpegts.c:540
PESContext::ts
MpegTSContext * ts
Definition: mpegts.c:257
OEITS_END_TID
#define OEITS_END_TID
Definition: mpegts.h:100
init_MP4DescrParseContext
static int init_MP4DescrParseContext(MP4DescrParseContext *d, AVFormatContext *s, const uint8_t *buf, unsigned size, Mp4Descr *descr, int max_descr_count)
Definition: mpegts.c:1469
MAX_PES_HEADER_SIZE
#define MAX_PES_HEADER_SIZE
Definition: mpegts.c:251
MAX_PACKET_READAHEAD
#define MAX_PACKET_READAHEAD
Definition: mpegts.c:3206
MAX_PIDS_PER_PROGRAM
#define MAX_PIDS_PER_PROGRAM
Definition: mpegts.c:117
MpegTSSectionFilter::end_of_section_reached
unsigned int end_of_section_reached
Definition: mpegts.c:93
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
parse_MP4ODescrTag
static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1522
mpegts_push_data
static int mpegts_push_data(MpegTSFilter *filter, const uint8_t *buf, int buf_size, int is_start, int64_t pos)
Definition: mpegts.c:1142
SLConfigDescr::use_au_start
int use_au_start
Definition: mpegts.h:176
new_data_packet
static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt)
Definition: mpegts.c:1004
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
AV_CODEC_ID_EAC3
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:480
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
SDT_TID
#define SDT_TID
Definition: mpegts.h:87
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
SCTE_types
static const StreamType SCTE_types[]
Definition: mpegts.c:842
MPEGTS_PES
@ MPEGTS_PES
Definition: mpegts.c:66
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
ff_mpegts_demuxer
const FFInputFormat ff_mpegts_demuxer
Definition: mpegts.c:3434
AVMediaType
AVMediaType
Definition: avutil.h:199
MP4DescrParseContext::descr
Mp4Descr * descr
Definition: mpegts.c:1461
AVPacket::size
int size
Definition: packet.h:534
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
MpegTSContext::max_packet_size
int max_packet_size
Definition: mpegts.c:166
FFStream
Definition: internal.h:193
SectionHeader::tid
uint8_t tid
Definition: mpegts.c:650
reset_pes_packet_state
static void reset_pes_packet_state(PESContext *pes)
Definition: mpegts.c:995
FFIOContext::pub
AVIOContext pub
Definition: avio_internal.h:29
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:444
Program
Definition: mpegts.c:118
MpegTSContext
Definition: mpegts.c:129
MpegTSFilter
Definition: mpegts.c:98
size
int size
Definition: twinvq_data.h:10344
MPEGTS_PAYLOAD
@ MPEGTS_PAYLOAD
Definition: mpegts.c:244
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MpegTSContext::raw_packet_size
int raw_packet_size
raw packet size, including FEC if present
Definition: mpegts.c:134
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
finished_reading_packet
static void finished_reading_packet(AVFormatContext *s, int raw_packet_size)
Definition: mpegts.c:2966
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
section
Definition: ffprobe.c:241
STREAM_ID_PRIVATE_STREAM_2
#define STREAM_ID_PRIVATE_STREAM_2
Definition: mpegts.h:147
SLConfigDescr::use_au_end
int use_au_end
Definition: mpegts.h:177
MpegTSSectionFilter::check_crc
unsigned int check_crc
Definition: mpegts.c:92
MpegTSContext::skip_clear
int skip_clear
Definition: mpegts.c:159
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:128
mpegts_get_dts
static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: mpegts.c:3340
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:500
mpegts_read_packet
static int mpegts_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegts.c:3255
ff_find_stream_index
int ff_find_stream_index(const AVFormatContext *s, int id)
Find stream index based on format-specific stream ID.
Definition: demux_utils.c:351
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
parse_MP4ESDescrTag
static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1536
buffer.h
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:658
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:532
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate an array through a pointer to a pointer.
Definition: mem.c:225
ffio_ensure_seekback
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1023
AV_CODEC_ID_VVC
@ AV_CODEC_ID_VVC
Definition: codec_id.h:250
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
SectionCallback
void SectionCallback(MpegTSFilter *f, const uint8_t *buf, int len)
Definition: mpegts.c:81
av_packet_side_data_add
AVPacketSideData * av_packet_side_data_add(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, void *data, size_t size, int flags)
Wrap existing data as packet side data.
Definition: packet.c:698
mpeg.h
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
FFStream::pts_wrap_behavior
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: internal.h:332
PESContext::pid
int pid
Definition: mpegts.c:254
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:539
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
version
version
Definition: libkvazaar.c:321
FFStream::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: internal.h:383
handle_packet
static int handle_packet(MpegTSContext *ts, const uint8_t *packet, int64_t pos)
Definition: mpegts.c:2768
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
update_offsets
static void update_offsets(AVIOContext *pb, int64_t *off, int *len)
Definition: mpegts.c:1488
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:453
EIT_PID
#define EIT_PID
Definition: mpegts.h:45
is_pes_stream
static int is_pes_stream(int stream_type, uint32_t prog_reg_desc)
Definition: mpegts.c:2310
SectionHeader
Definition: mpegts.c:649
ISO_639_LANGUAGE_DESCRIPTOR
#define ISO_639_LANGUAGE_DESCRIPTOR
Definition: mpegts.h:161
MP4DescrParseContext::pb
FFIOContext pb
Definition: mpegts.c:1460
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:526
avio_internal.h
IOD_DESCRIPTOR
#define IOD_DESCRIPTOR
Definition: mpegts.h:162
parse_stream_identifier_desc
static int parse_stream_identifier_desc(const uint8_t *p, const uint8_t *p_end)
Definition: mpegts.c:2274
MAX_MP4_DESCR_COUNT
#define MAX_MP4_DESCR_COUNT
Definition: mpegts.c:53
PESContext::data_index
int data_index
Definition: mpegts.c:263
AV_CODEC_ID_SMPTE_2038
@ AV_CODEC_ID_SMPTE_2038
Definition: codec_id.h:591
internal.h
get_program
static struct Program * get_program(MpegTSContext *ts, unsigned int programid)
Definition: mpegts.c:279
PAT_TID
#define PAT_TID
Definition: mpegts.h:79
MpegTSContext::pids
MpegTSFilter * pids[NB_PID_MAX]
filters for various streams specified by PMT + for the PAT and PMT
Definition: mpegts.c:179
PESContext::pes_header_size
int pes_header_size
Definition: mpegts.c:266
AV_CODEC_ID_CAVS
@ AV_CODEC_ID_CAVS
Definition: codec_id.h:139
get16
static int get16(const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:682
parse_section_header
static int parse_section_header(SectionHeader *h, const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:764
MpegTSContext::epg_stream
AVStream * epg_stream
Definition: mpegts.c:182
AV_CODEC_ID_EPG
@ AV_CODEC_ID_EPG
Definition: codec_id.h:582
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:590
mpegts_resync
static int mpegts_resync(AVFormatContext *s, int seekback, const uint8_t *current_packet)
Definition: mpegts.c:2898
MpegTSContext::crc_validity
int8_t crc_validity[NB_PID_MAX]
Definition: mpegts.c:177
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
PESContext::st
AVStream * st
Definition: mpegts.c:259
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AV_PKT_DATA_MPEGTS_STREAM_ID
@ AV_PKT_DATA_MPEGTS_STREAM_ID
MPEGTS stream ID as uint8_t, this is required to pass the stream ID information from the demuxer to t...
Definition: packet.h:212
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1184
handle_packets
static int handle_packets(MpegTSContext *ts, int64_t nb_packets)
Definition: mpegts.c:2974
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:122
demux.h
MpegTSContext::prg
struct Program * prg
Definition: mpegts.c:175
AV_DISPOSITION_DEPENDENT
#define AV_DISPOSITION_DEPENDENT
The stream is intended to be mixed with another stream before presentation.
Definition: avformat.h:709
len
int len
Definition: vorbis_enc_data.h:426
AV_CODEC_ID_JPEG2000
@ AV_CODEC_ID_JPEG2000
Definition: codec_id.h:140
AV_CRC_32_IEEE
@ AV_CRC_32_IEEE
Definition: crc.h:52
MpegTSPESFilter
Definition: mpegts.c:76
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
SLConfigDescr::au_len
int au_len
Definition: mpegts.h:185
MpegTSFilter::u
union MpegTSFilter::@382 u
MpegTSFilter::last_pcr
int64_t last_pcr
Definition: mpegts.c:102
MpegTSSectionFilter::last_crc
unsigned last_crc
Definition: mpegts.c:90
language
Undefined Behavior In the C language
Definition: undefined.txt:3
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:817
mid_pred
#define mid_pred
Definition: mathops.h:96
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:662
MP4DescrParseContext
Definition: mpegts.c:1458
tag
uint32_t tag
Definition: movenc.c:1876
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:760
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
MpegTSSectionFilter::last_ver
int last_ver
Definition: mpegts.c:88
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
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:71
Mp4Descr::dec_config_descr
uint8_t * dec_config_descr
Definition: mpegts.h:195
SLConfigDescr::use_timestamps
int use_timestamps
Definition: mpegts.h:180
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:746
mp4_read_od
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:1685
scte_data_cb
static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1765
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
dovi_meta.h
m4sl_cb
static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1701
dict.h
AV_DISPOSITION_DESCRIPTIONS
#define AV_DISPOSITION_DESCRIPTIONS
The subtitle stream contains a textual description of the video content.
Definition: avformat.h:698
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
TS_MAX_PACKET_SIZE
#define TS_MAX_PACKET_SIZE
Definition: mpegts.h:30
M4OD_TID
#define M4OD_TID
Definition: mpegts.h:84
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
R8_CHECK_CLIP_MAX
#define R8_CHECK_CLIP_MAX(dst, maxv)
probe
static int probe(const AVProbeData *p)
Definition: act.c:39
mpegts_probe
static int mpegts_probe(const AVProbeData *p)
Definition: mpegts.c:3027
PESContext::PES_packet_length
int PES_packet_length
Definition: mpegts.c:265
clear_program
static void clear_program(struct Program *p)
Definition: mpegts.c:305
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: packet.c:231
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
av_crc
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:392
NB_PID_MAX
#define NB_PID_MAX
Definition: mpegts.h:32
AVDOVIDecoderConfigurationRecord::bl_present_flag
uint8_t bl_present_flag
Definition: dovi_meta.h:61
SL_DESCRIPTOR
#define SL_DESCRIPTOR
Definition: mpegts.h:163
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
defs.h
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
PESContext::stream_id
uint8_t stream_id
Definition: mpegts.c:268
parse_MP4SLDescrTag
static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1572
avpriv_mpegts_parse_open
MpegTSContext * avpriv_mpegts_parse_open(AVFormatContext *s)
Definition: mpegts.c:3381
PESContext::buffer
AVBufferRef * buffer
Definition: mpegts.c:272
CHECK_COUNT
#define CHECK_COUNT
AVDOVIDecoderConfigurationRecord::rpu_present_flag
uint8_t rpu_present_flag
Definition: dovi_meta.h:59
mpegts_free
static void mpegts_free(MpegTSContext *ts)
Definition: mpegts.c:3285
HDMV_types
static const StreamType HDMV_types[]
Definition: mpegts.c:826
AVDOVIDecoderConfigurationRecord::el_present_flag
uint8_t el_present_flag
Definition: dovi_meta.h:60
AVPacket::stream_index
int stream_index
Definition: packet.h:535
AVPROBE_SCORE_STREAM_RETRY
#define AVPROBE_SCORE_STREAM_RETRY
Definition: avformat.h:459
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
SLConfigDescr::timestamp_res
int timestamp_res
Definition: mpegts.h:182
ISO_types
static const StreamType ISO_types[]
Definition: mpegts.c:800
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:284
AVDOVIDecoderConfigurationRecord::dv_version_minor
uint8_t dv_version_minor
Definition: dovi_meta.h:56
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
hex_dump_debug
#define hex_dump_debug(class, buf, size)
Definition: internal.h:39
read_sl_header
static int read_sl_header(PESContext *pes, SLConfigDescr *sl, const uint8_t *buf, int buf_size)
Definition: mpegts.c:1058
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:481
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
MpegTSContext::pkt
AVPacket * pkt
packet containing Audio/Video data
Definition: mpegts.c:154
mpegts_read_header
static int mpegts_read_header(AVFormatContext *s)
Definition: mpegts.c:3105
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
STREAM_TYPE_METADATA
#define STREAM_TYPE_METADATA
Definition: mpegts.h:128
MPEGTS_PCR
@ MPEGTS_PCR
Definition: mpegts.c:68
FFStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:263
Program::id
unsigned int id
Definition: mpegts.c:119
STREAM_ID_ECM_STREAM
#define STREAM_ID_ECM_STREAM
Definition: mpegts.h:150
MpegTSSectionFilter::opaque
void * opaque
Definition: mpegts.c:95
PESContext::merged_st
int merged_st
Definition: mpegts.c:274
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
TS_FEC_PACKET_SIZE
#define TS_FEC_PACKET_SIZE
Definition: mpegts.h:27
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
MAX_STREAMS_PER_PROGRAM
#define MAX_STREAMS_PER_PROGRAM
Definition: mpegts.c:116
AVPacket
This structure stores compressed data.
Definition: packet.h:510
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
STREAM_ID_PROGRAM_STREAM_DIRECTORY
#define STREAM_ID_PROGRAM_STREAM_DIRECTORY
Definition: mpegts.h:156
MpegTSFilter::last_cc
int last_cc
Definition: mpegts.c:101
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
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:88
MpegTSContext::scan_all_pmts
int scan_all_pmts
Definition: mpegts.c:162
AV_CODEC_ID_AC4
@ AV_CODEC_ID_AC4
Definition: codec_id.h:543
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:553
MP4DescrParseContext::predefined_SLConfigDescriptor_seen
int predefined_SLConfigDescriptor_seen
Definition: mpegts.c:1466
FFInputFormat
Definition: demux.h:37
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
Stream
Definition: mpegts.c:111
d
d
Definition: ffmpeg_filter.c:424
MP4DescrParseContext::level
int level
Definition: mpegts.c:1465
bytestream.h
FFStream::stream_identifier
int stream_identifier
Stream Identifier This is the MPEG-TS stream identifier +1 0 means unknown.
Definition: internal.h:399
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
MpegTSContext::skip_unknown_pmt
int skip_unknown_pmt
Definition: mpegts.c:160
raw_options
static const AVOption raw_options[]
Definition: mpegts.c:223
FFStream::need_context_update
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
Definition: internal.h:238
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
opus_channel_map
static const uint8_t opus_channel_map[8][8]
Definition: mpegts.c:1802
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
Program::pids
unsigned int pids[MAX_PIDS_PER_PROGRAM]
Definition: mpegts.c:121
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_ID_AAC_LATM
@ AV_CODEC_ID_AAC_LATM
Definition: codec_id.h:489
parse_mp4_descr
static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len, int target_tag)
Definition: mpegts.c:1615
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_CODEC_ID_HDMV_TEXT_SUBTITLE
@ AV_CODEC_ID_HDMV_TEXT_SUBTITLE
Definition: codec_id.h:573
TS_PACKET_SIZE
#define TS_PACKET_SIZE
Definition: mpegts.h:29
MpegTSSectionFilter::section_cb
SectionCallback * section_cb
Definition: mpegts.c:94
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
PROBE_PACKET_MARGIN
#define PROBE_PACKET_MARGIN
Definition: mpegts.c:63
h
h
Definition: vp9dsp_template.c:2038
read_timestamp
static int64_t read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: seek.c:280
get_ts64
static uint64_t get_ts64(GetBitContext *gb, int bits)
Definition: mpegts.c:1051
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:797
get_packet_size
static int get_packet_size(AVFormatContext *s)
Definition: mpegts.c:611
analyze
static int analyze(const uint8_t *buf, int size, int packet_size, int probe)
Definition: mpegts.c:582
write_section_data
static void write_section_data(MpegTSContext *ts, 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:423
ff_reduce_index
void ff_reduce_index(AVFormatContext *s, int stream_index)
Ensure the index uses less memory than the maximum specified in AVFormatContext.max_index_size by dis...
Definition: seek.c:49
read_packet
static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size, const uint8_t **data)
Definition: mpegts.c:2941
MpegTSContext::mpeg2ts_compute_pcr
int mpeg2ts_compute_pcr
compute exact PCR for each transport stream packet
Definition: mpegts.c:142
REGD_types
static const StreamType REGD_types[]
Definition: mpegts.c:863
MISC_types
static const StreamType MISC_types[]
Definition: mpegts.c:848
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
add_program
static struct Program * add_program(MpegTSContext *ts, unsigned int programid)
Definition: mpegts.c:320
options
static const AVOption options[]
Definition: mpegts.c:197
snprintf
#define snprintf
Definition: snprintf.h:34
PESContext::ts_packet_pos
int64_t ts_packet_pos
position of first TS packet of this PES packet
Definition: mpegts.c:270
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AVProgram::pcr_pid
int pcr_pid
Definition: avformat.h:1194
FFStream::pts_wrap_reference
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: internal.h:320
Mp4Descr
Definition: mpegts.h:192
SLConfigDescr
Definition: mpegts.h:175
avio_read_partial
int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:684
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
sdt_cb
static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:2678
MpegTSContext::fix_teletext_pts
int fix_teletext_pts
fix dvb teletext pts
Definition: mpegts.c:145
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:227
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:54
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346
AV_CODEC_ID_SCTE_35
@ AV_CODEC_ID_SCTE_35
Contain timestamp estimated through PCR of program stream.
Definition: codec_id.h:581
StreamType::codec_type
enum AVMediaType codec_type
Definition: mpegts.c:796