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/common.h"
26 #include "libavutil/crc.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/log.h"
30 #include "libavutil/dict.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/dovi_meta.h"
35 #include "libavcodec/avcodec.h"
36 #include "libavcodec/bytestream.h"
37 #include "libavcodec/get_bits.h"
38 #include "libavcodec/opus.h"
39 #include "avformat.h"
40 #include "mpegts.h"
41 #include "internal.h"
42 #include "avio_internal.h"
43 #include "demux.h"
44 #include "mpeg.h"
45 #include "isom.h"
46 #if CONFIG_ICONV
47 #include <iconv.h>
48 #endif
49 
50 /* maximum size in which we look for synchronization if
51  * synchronization is lost */
52 #define MAX_RESYNC_SIZE 65536
53 
54 #define MAX_MP4_DESCR_COUNT 16
55 
56 #define MOD_UNLIKELY(modulus, dividend, divisor, prev_dividend) \
57  do { \
58  if ((prev_dividend) == 0 || (dividend) - (prev_dividend) != (divisor)) \
59  (modulus) = (dividend) % (divisor); \
60  (prev_dividend) = (dividend); \
61  } while (0)
62 
63 #define PROBE_PACKET_MAX_BUF 8192
64 #define PROBE_PACKET_MARGIN 5
65 
70 };
71 
72 typedef struct MpegTSFilter MpegTSFilter;
73 
74 typedef int PESCallback (MpegTSFilter *f, const uint8_t *buf, int len,
75  int is_start, int64_t pos);
76 
77 typedef struct MpegTSPESFilter {
79  void *opaque;
81 
82 typedef void SectionCallback (MpegTSFilter *f, const uint8_t *buf, int len);
83 
84 typedef void SetServiceCallback (void *opaque, int ret);
85 
86 typedef struct MpegTSSectionFilter {
89  int last_ver;
90  unsigned crc;
91  unsigned last_crc;
92  uint8_t *section_buf;
93  unsigned int check_crc : 1;
94  unsigned int end_of_section_reached : 1;
96  void *opaque;
98 
99 struct MpegTSFilter {
100  int pid;
101  int es_id;
102  int last_cc; /* last cc code (-1 if first packet) */
103  int64_t last_pcr;
104  int discard;
106  union {
109  } u;
110 };
111 
112 struct Stream {
113  int idx;
115 };
116 
117 #define MAX_STREAMS_PER_PROGRAM 128
118 #define MAX_PIDS_PER_PROGRAM (MAX_STREAMS_PER_PROGRAM + 2)
119 struct Program {
120  unsigned int id; // program id/service id
121  unsigned int nb_pids;
122  unsigned int pids[MAX_PIDS_PER_PROGRAM];
123  unsigned int nb_streams;
125 
126  /** have we found pmt for this program */
128 };
129 
131  const AVClass *class;
132  /* user data */
134  /** raw packet size, including FEC if present */
136 
137  int64_t pos47_full;
138 
139  /** if true, all pids are analyzed to find streams */
141 
142  /** compute exact PCR for each transport stream packet */
144 
145  /** fix dvb teletext pts */
147 
148  int64_t cur_pcr; /**< used to estimate the exact PCR */
149  int64_t pcr_incr; /**< used to estimate the exact PCR */
150 
151  /* data needed to handle file based ts */
152  /** stop parsing loop */
154  /** packet containing Audio/Video data */
156  /** to detect seek */
157  int64_t last_pos;
158 
162 
164 
168 
169  /******************************************/
170  /* private mpegts data */
171  /* scan context */
172  /** structure to keep track of Program->pids mapping */
173  unsigned int nb_prg;
174  struct Program *prg;
175 
177  /** filters for various streams specified by PMT + for the PAT and PMT */
180 
183 };
184 
185 #define MPEGTS_OPTIONS \
186  { "resync_size", "set size limit for looking up a new synchronization", offsetof(MpegTSContext, resync_size), AV_OPT_TYPE_INT, { .i64 = MAX_RESYNC_SIZE}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM }
187 
188 static const AVOption options[] = {
190  {"fix_teletext_pts", "try to fix pts values of dvb teletext streams", offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_BOOL,
191  {.i64 = 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
192  {"ts_packetsize", "output option carrying the raw packet size", offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
194  {"scan_all_pmts", "scan and combine all PMTs", offsetof(MpegTSContext, scan_all_pmts), AV_OPT_TYPE_BOOL,
195  {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM },
196  {"skip_unknown_pmt", "skip PMTs for programs not advertised in the PAT", offsetof(MpegTSContext, skip_unknown_pmt), AV_OPT_TYPE_BOOL,
197  {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
198  {"merge_pmt_versions", "re-use streams when PMT's version/pids change", offsetof(MpegTSContext, merge_pmt_versions), AV_OPT_TYPE_BOOL,
199  {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
200  {"skip_changes", "skip changing / adding streams / programs", offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_BOOL,
201  {.i64 = 0}, 0, 1, 0 },
202  {"skip_clear", "skip clearing programs", offsetof(MpegTSContext, skip_clear), AV_OPT_TYPE_BOOL,
203  {.i64 = 0}, 0, 1, 0 },
204  {"max_packet_size", "maximum size of emitted packet", offsetof(MpegTSContext, max_packet_size), AV_OPT_TYPE_INT,
205  {.i64 = 204800}, 1, INT_MAX/2, AV_OPT_FLAG_DECODING_PARAM },
206  { NULL },
207 };
208 
209 static const AVClass mpegts_class = {
210  .class_name = "mpegts demuxer",
211  .item_name = av_default_item_name,
212  .option = options,
213  .version = LIBAVUTIL_VERSION_INT,
214 };
215 
216 static const AVOption raw_options[] = {
218  { "compute_pcr", "compute exact PCR for each transport stream packet",
219  offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_BOOL,
220  { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
221  { "ts_packetsize", "output option carrying the raw packet size",
222  offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
223  { .i64 = 0 }, 0, 0,
225  { NULL },
226 };
227 
228 static const AVClass mpegtsraw_class = {
229  .class_name = "mpegtsraw demuxer",
230  .item_name = av_default_item_name,
231  .option = raw_options,
232  .version = LIBAVUTIL_VERSION_INT,
233 };
234 
235 /* TS stream handling */
236 
243 };
244 
245 /* enough for PES header + length */
246 #define PES_START_SIZE 6
247 #define PES_HEADER_SIZE 9
248 #define MAX_PES_HEADER_SIZE (9 + 255)
249 
250 typedef struct PESContext {
251  int pid;
252  int pcr_pid; /**< if -1 then all packets containing PCR are considered */
257  AVStream *sub_st; /**< stream for the embedded AC3 stream in HDMV TrueHD */
259  /* used to get the format */
261  int flags; /**< copied to the AVPacket flags */
265  uint8_t stream_id;
266  int64_t pts, dts;
267  int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */
272 } PESContext;
273 
274 extern const AVInputFormat ff_mpegts_demuxer;
275 
276 static struct Program * get_program(MpegTSContext *ts, unsigned int programid)
277 {
278  int i;
279  for (i = 0; i < ts->nb_prg; i++) {
280  if (ts->prg[i].id == programid) {
281  return &ts->prg[i];
282  }
283  }
284  return NULL;
285 }
286 
287 static void clear_avprogram(MpegTSContext *ts, unsigned int programid)
288 {
289  AVProgram *prg = NULL;
290  int i;
291 
292  for (i = 0; i < ts->stream->nb_programs; i++)
293  if (ts->stream->programs[i]->id == programid) {
294  prg = ts->stream->programs[i];
295  break;
296  }
297  if (!prg)
298  return;
299  prg->nb_stream_indexes = 0;
300 }
301 
302 static void clear_program(struct Program *p)
303 {
304  if (!p)
305  return;
306  p->nb_pids = 0;
307  p->nb_streams = 0;
308  p->pmt_found = 0;
309 }
310 
312 {
313  av_freep(&ts->prg);
314  ts->nb_prg = 0;
315 }
316 
317 static struct Program * add_program(MpegTSContext *ts, unsigned int programid)
318 {
319  struct Program *p = get_program(ts, programid);
320  if (p)
321  return p;
322  if (av_reallocp_array(&ts->prg, ts->nb_prg + 1, sizeof(*ts->prg)) < 0) {
323  ts->nb_prg = 0;
324  return NULL;
325  }
326  p = &ts->prg[ts->nb_prg];
327  p->id = programid;
328  clear_program(p);
329  ts->nb_prg++;
330  return p;
331 }
332 
333 static void add_pid_to_program(struct Program *p, unsigned int pid)
334 {
335  int i;
336  if (!p)
337  return;
338 
339  if (p->nb_pids >= MAX_PIDS_PER_PROGRAM)
340  return;
341 
342  for (i = 0; i < p->nb_pids; i++)
343  if (p->pids[i] == pid)
344  return;
345 
346  p->pids[p->nb_pids++] = pid;
347 }
348 
349 static void update_av_program_info(AVFormatContext *s, unsigned int programid,
350  unsigned int pid, int version)
351 {
352  int i;
353  for (i = 0; i < s->nb_programs; i++) {
354  AVProgram *program = s->programs[i];
355  if (program->id == programid) {
356  int old_pcr_pid = program->pcr_pid,
357  old_version = program->pmt_version;
358  program->pcr_pid = pid;
359  program->pmt_version = version;
360 
361  if (old_version != -1 && old_version != version) {
363  "detected PMT change (program=%d, version=%d/%d, pcr_pid=0x%x/0x%x)\n",
364  programid, old_version, version, old_pcr_pid, pid);
365  }
366  break;
367  }
368  }
369 }
370 
371 /**
372  * @brief discard_pid() decides if the pid is to be discarded according
373  * to caller's programs selection
374  * @param ts : - TS context
375  * @param pid : - pid
376  * @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
377  * 0 otherwise
378  */
379 static int discard_pid(MpegTSContext *ts, unsigned int pid)
380 {
381  int i, j, k;
382  int used = 0, discarded = 0;
383  struct Program *p;
384 
385  if (pid == PAT_PID)
386  return 0;
387 
388  /* If none of the programs have .discard=AVDISCARD_ALL then there's
389  * no way we have to discard this packet */
390  for (k = 0; k < ts->stream->nb_programs; k++)
391  if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
392  break;
393  if (k == ts->stream->nb_programs)
394  return 0;
395 
396  for (i = 0; i < ts->nb_prg; i++) {
397  p = &ts->prg[i];
398  for (j = 0; j < p->nb_pids; j++) {
399  if (p->pids[j] != pid)
400  continue;
401  // is program with id p->id set to be discarded?
402  for (k = 0; k < ts->stream->nb_programs; k++) {
403  if (ts->stream->programs[k]->id == p->id) {
404  if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
405  discarded++;
406  else
407  used++;
408  }
409  }
410  }
411  }
412 
413  return !used && discarded;
414 }
415 
416 /**
417  * Assemble PES packets out of TS packets, and then call the "section_cb"
418  * function when they are complete.
419  */
421  const uint8_t *buf, int buf_size, int is_start)
422 {
423  MpegTSSectionFilter *tss = &tss1->u.section_filter;
424  uint8_t *cur_section_buf = NULL;
425  int len, offset;
426 
427  if (is_start) {
428  memcpy(tss->section_buf, buf, buf_size);
429  tss->section_index = buf_size;
430  tss->section_h_size = -1;
431  tss->end_of_section_reached = 0;
432  } else {
433  if (tss->end_of_section_reached)
434  return;
436  if (buf_size < len)
437  len = buf_size;
438  memcpy(tss->section_buf + tss->section_index, buf, len);
439  tss->section_index += len;
440  }
441 
442  offset = 0;
443  cur_section_buf = tss->section_buf;
444  while (cur_section_buf - tss->section_buf < MAX_SECTION_SIZE && cur_section_buf[0] != 0xff) {
445  /* compute section length if possible */
446  if (tss->section_h_size == -1 && tss->section_index - offset >= 3) {
447  len = (AV_RB16(cur_section_buf + 1) & 0xfff) + 3;
448  if (len > MAX_SECTION_SIZE)
449  return;
450  tss->section_h_size = len;
451  }
452 
453  if (tss->section_h_size != -1 &&
454  tss->section_index >= offset + tss->section_h_size) {
455  int crc_valid = 1;
456  tss->end_of_section_reached = 1;
457 
458  if (tss->check_crc) {
459  crc_valid = !av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, cur_section_buf, tss->section_h_size);
460  if (tss->section_h_size >= 4)
461  tss->crc = AV_RB32(cur_section_buf + tss->section_h_size - 4);
462 
463  if (crc_valid) {
464  ts->crc_validity[ tss1->pid ] = 100;
465  }else if (ts->crc_validity[ tss1->pid ] > -10) {
466  ts->crc_validity[ tss1->pid ]--;
467  }else
468  crc_valid = 2;
469  }
470  if (crc_valid) {
471  tss->section_cb(tss1, cur_section_buf, tss->section_h_size);
472  if (crc_valid != 1)
473  tss->last_ver = -1;
474  }
475 
476  cur_section_buf += tss->section_h_size;
477  offset += tss->section_h_size;
478  tss->section_h_size = -1;
479  } else {
480  tss->section_h_size = -1;
481  tss->end_of_section_reached = 0;
482  break;
483  }
484  }
485 }
486 
487 static MpegTSFilter *mpegts_open_filter(MpegTSContext *ts, unsigned int pid,
488  enum MpegTSFilterType type)
489 {
491 
492  av_log(ts->stream, AV_LOG_TRACE, "Filter: pid=0x%x type=%d\n", pid, type);
493 
494  if (pid >= NB_PID_MAX || ts->pids[pid])
495  return NULL;
496  filter = av_mallocz(sizeof(MpegTSFilter));
497  if (!filter)
498  return NULL;
499  ts->pids[pid] = filter;
500 
501  filter->type = type;
502  filter->pid = pid;
503  filter->es_id = -1;
504  filter->last_cc = -1;
505  filter->last_pcr= -1;
506 
507  return filter;
508 }
509 
511  unsigned int pid,
512  SectionCallback *section_cb,
513  void *opaque,
514  int check_crc)
515 {
517  MpegTSSectionFilter *sec;
518  uint8_t *section_buf = av_mallocz(MAX_SECTION_SIZE);
519 
520  if (!section_buf)
521  return NULL;
522 
523  if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_SECTION))) {
524  av_free(section_buf);
525  return NULL;
526  }
527  sec = &filter->u.section_filter;
528  sec->section_cb = section_cb;
529  sec->opaque = opaque;
530  sec->section_buf = section_buf;
531  sec->check_crc = check_crc;
532  sec->last_ver = -1;
533 
534  return filter;
535 }
536 
537 static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
538  PESCallback *pes_cb,
539  void *opaque)
540 {
542  MpegTSPESFilter *pes;
543 
544  if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_PES)))
545  return NULL;
546 
547  pes = &filter->u.pes_filter;
548  pes->pes_cb = pes_cb;
549  pes->opaque = opaque;
550  return filter;
551 }
552 
553 static MpegTSFilter *mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid)
554 {
555  return mpegts_open_filter(ts, pid, MPEGTS_PCR);
556 }
557 
559 {
560  int pid;
561 
562  pid = filter->pid;
563  if (filter->type == MPEGTS_SECTION)
564  av_freep(&filter->u.section_filter.section_buf);
565  else if (filter->type == MPEGTS_PES) {
566  PESContext *pes = filter->u.pes_filter.opaque;
567  av_buffer_unref(&pes->buffer);
568  /* referenced private data will be freed later in
569  * avformat_close_input (pes->st->priv_data == pes) */
570  if (!pes->st || pes->merged_st) {
571  av_freep(&filter->u.pes_filter.opaque);
572  }
573  }
574 
575  av_free(filter);
576  ts->pids[pid] = NULL;
577 }
578 
579 static int analyze(const uint8_t *buf, int size, int packet_size,
580  int probe)
581 {
582  int stat[TS_MAX_PACKET_SIZE];
583  int stat_all = 0;
584  int i;
585  int best_score = 0;
586 
587  memset(stat, 0, packet_size * sizeof(*stat));
588 
589  for (i = 0; i < size - 3; i++) {
590  if (buf[i] == 0x47) {
591  int pid = AV_RB16(buf+1) & 0x1FFF;
592  int asc = buf[i + 3] & 0x30;
593  if (!probe || pid == 0x1FFF || asc) {
594  int x = i % packet_size;
595  stat[x]++;
596  stat_all++;
597  if (stat[x] > best_score) {
598  best_score = stat[x];
599  }
600  }
601  }
602  }
603 
604  return best_score - FFMAX(stat_all - 10*best_score, 0)/10;
605 }
606 
607 /* autodetect fec presence */
609 {
610  int score, fec_score, dvhs_score;
611  int margin;
612  int ret;
613 
614  /*init buffer to store stream for probing */
615  uint8_t buf[PROBE_PACKET_MAX_BUF] = {0};
616  int buf_size = 0;
617  int max_iterations = 16;
618 
619  while (buf_size < PROBE_PACKET_MAX_BUF && max_iterations--) {
620  ret = avio_read_partial(s->pb, buf + buf_size, PROBE_PACKET_MAX_BUF - buf_size);
621  if (ret < 0)
622  return AVERROR_INVALIDDATA;
623  buf_size += ret;
624 
625  score = analyze(buf, buf_size, TS_PACKET_SIZE, 0);
626  dvhs_score = analyze(buf, buf_size, TS_DVHS_PACKET_SIZE, 0);
627  fec_score = analyze(buf, buf_size, TS_FEC_PACKET_SIZE, 0);
628  av_log(s, AV_LOG_TRACE, "Probe: %d, score: %d, dvhs_score: %d, fec_score: %d \n",
629  buf_size, score, dvhs_score, fec_score);
630 
631  margin = mid_pred(score, fec_score, dvhs_score);
632 
633  if (buf_size < PROBE_PACKET_MAX_BUF)
634  margin += PROBE_PACKET_MARGIN; /*if buffer not filled */
635 
636  if (score > margin)
637  return TS_PACKET_SIZE;
638  else if (dvhs_score > margin)
639  return TS_DVHS_PACKET_SIZE;
640  else if (fec_score > margin)
641  return TS_FEC_PACKET_SIZE;
642  }
643  return AVERROR_INVALIDDATA;
644 }
645 
646 typedef struct SectionHeader {
647  uint8_t tid;
648  uint16_t id;
649  uint8_t version;
650  uint8_t current_next;
651  uint8_t sec_num;
652  uint8_t last_sec_num;
653 } SectionHeader;
654 
656 {
657  if (h->version == tssf->last_ver && tssf->last_crc == tssf->crc)
658  return 1;
659 
660  tssf->last_ver = h->version;
661  tssf->last_crc = tssf->crc;
662 
663  return 0;
664 }
665 
666 static inline int get8(const uint8_t **pp, const uint8_t *p_end)
667 {
668  const uint8_t *p;
669  int c;
670 
671  p = *pp;
672  if (p >= p_end)
673  return AVERROR_INVALIDDATA;
674  c = *p++;
675  *pp = p;
676  return c;
677 }
678 
679 static inline int get16(const uint8_t **pp, const uint8_t *p_end)
680 {
681  const uint8_t *p;
682  int c;
683 
684  p = *pp;
685  if (1 >= p_end - p)
686  return AVERROR_INVALIDDATA;
687  c = AV_RB16(p);
688  p += 2;
689  *pp = p;
690  return c;
691 }
692 
693 /* read and allocate a DVB string preceded by its length */
694 static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
695 {
696  int len;
697  const uint8_t *p;
698  char *str;
699 
700  p = *pp;
701  len = get8(&p, p_end);
702  if (len < 0)
703  return NULL;
704  if (len > p_end - p)
705  return NULL;
706 #if CONFIG_ICONV
707  if (len) {
708  const char *encodings[] = {
709  "ISO6937", "ISO-8859-5", "ISO-8859-6", "ISO-8859-7",
710  "ISO-8859-8", "ISO-8859-9", "ISO-8859-10", "ISO-8859-11",
711  "", "ISO-8859-13", "ISO-8859-14", "ISO-8859-15", "", "", "", "",
712  "", "UCS-2BE", "KSC_5601", "GB2312", "UCS-2BE", "UTF-8", "", "",
713  "", "", "", "", "", "", "", ""
714  };
715  iconv_t cd;
716  char *in, *out;
717  size_t inlen = len, outlen = inlen * 6 + 1;
718  if (len >= 3 && p[0] == 0x10 && !p[1] && p[2] && p[2] <= 0xf && p[2] != 0xc) {
719  char iso8859[12];
720  snprintf(iso8859, sizeof(iso8859), "ISO-8859-%d", p[2]);
721  inlen -= 3;
722  in = (char *)p + 3;
723  cd = iconv_open("UTF-8", iso8859);
724  } else if (p[0] < 0x20) {
725  inlen -= 1;
726  in = (char *)p + 1;
727  cd = iconv_open("UTF-8", encodings[*p]);
728  } else {
729  in = (char *)p;
730  cd = iconv_open("UTF-8", encodings[0]);
731  }
732  if (cd == (iconv_t)-1)
733  goto no_iconv;
734  str = out = av_malloc(outlen);
735  if (!str) {
736  iconv_close(cd);
737  return NULL;
738  }
739  if (iconv(cd, &in, &inlen, &out, &outlen) == -1) {
740  iconv_close(cd);
741  av_freep(&str);
742  goto no_iconv;
743  }
744  iconv_close(cd);
745  *out = 0;
746  *pp = p + len;
747  return str;
748  }
749 no_iconv:
750 #endif
751  str = av_malloc(len + 1);
752  if (!str)
753  return NULL;
754  memcpy(str, p, len);
755  str[len] = '\0';
756  p += len;
757  *pp = p;
758  return str;
759 }
760 
762  const uint8_t **pp, const uint8_t *p_end)
763 {
764  int val;
765 
766  val = get8(pp, p_end);
767  if (val < 0)
768  return val;
769  h->tid = val;
770  *pp += 2;
771  val = get16(pp, p_end);
772  if (val < 0)
773  return val;
774  h->id = val;
775  val = get8(pp, p_end);
776  if (val < 0)
777  return val;
778  h->version = (val >> 1) & 0x1f;
779  h->current_next = val & 0x01;
780  val = get8(pp, p_end);
781  if (val < 0)
782  return val;
783  h->sec_num = val;
784  val = get8(pp, p_end);
785  if (val < 0)
786  return val;
787  h->last_sec_num = val;
788  return 0;
789 }
790 
791 typedef struct StreamType {
792  uint32_t stream_type;
795 } StreamType;
796 
797 static const StreamType ISO_types[] = {
804  /* Makito encoder sets stream type 0x11 for AAC,
805  * so auto-detect LOAS/LATM instead of hardcoding it. */
806 #if !CONFIG_LOAS_DEMUXER
807  { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM }, /* LATM syntax */
808 #endif
819  { 0 },
820 };
821 
822 static const StreamType HDMV_types[] = {
828  { 0x85, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD */
829  { 0x86, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD MASTER*/
830  { 0xa1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC3 Secondary Audio */
831  { 0xa2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS Express Secondary Audio */
834  { 0 },
835 };
836 
837 /* SCTE types */
838 static const StreamType SCTE_types[] = {
840  { 0 },
841 };
842 
843 /* ATSC ? */
844 static const StreamType MISC_types[] = {
847  { 0 },
848 };
849 
850 /* HLS Sample Encryption Types */
856  { 0 },
857 };
858 
859 static const StreamType REGD_types[] = {
860  { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
861  { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
862  { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M },
863  { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
864  { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
865  { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
866  { MKTAG('E', 'A', 'C', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 },
867  { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC },
868  { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
869  { MKTAG('V', 'A', 'N', 'C'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_2038 },
870  { MKTAG('I', 'D', '3', ' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
871  { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },
872  { MKTAG('O', 'p', 'u', 's'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_OPUS },
873  { 0 },
874 };
875 
876 static const StreamType METADATA_types[] = {
877  { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
878  { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
879  { 0 },
880 };
881 
882 /* descriptor present */
883 static const StreamType DESC_types[] = {
884  { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */
885  { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
888  { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
889  { 0 },
890 };
891 
893  uint32_t stream_type,
894  const StreamType *types)
895 {
896  FFStream *const sti = ffstream(st);
897  for (; types->stream_type; types++)
898  if (stream_type == types->stream_type) {
899  if (st->codecpar->codec_type != types->codec_type ||
900  st->codecpar->codec_id != types->codec_id) {
901  st->codecpar->codec_type = types->codec_type;
902  st->codecpar->codec_id = types->codec_id;
903  sti->need_context_update = 1;
904  }
905  sti->request_probe = 0;
906  return;
907  }
908 }
909 
911  uint32_t stream_type, uint32_t prog_reg_desc)
912 {
913  FFStream *const sti = ffstream(st);
914  int old_codec_type = st->codecpar->codec_type;
915  int old_codec_id = st->codecpar->codec_id;
916  int old_codec_tag = st->codecpar->codec_tag;
917 
918  if (avcodec_is_open(sti->avctx)) {
919  av_log(pes->stream, AV_LOG_DEBUG, "cannot set stream info, internal codec is open\n");
920  return 0;
921  }
922 
923  avpriv_set_pts_info(st, 33, 1, 90000);
924  st->priv_data = pes;
928  pes->st = st;
929  pes->stream_type = stream_type;
930 
931  av_log(pes->stream, AV_LOG_DEBUG,
932  "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
933  st->index, pes->stream_type, pes->pid, (char *)&prog_reg_desc);
934 
935  st->codecpar->codec_tag = pes->stream_type;
936 
938  if (pes->stream_type == 4 || pes->stream_type == 0x0f)
939  sti->request_probe = 50;
940  if ((prog_reg_desc == AV_RL32("HDMV") ||
941  prog_reg_desc == AV_RL32("HDPR")) &&
944  if (pes->stream_type == 0x83) {
945  // HDMV TrueHD streams also contain an AC3 coded version of the
946  // audio track - add a second stream for this
947  AVStream *sub_st;
948  // priv_data cannot be shared between streams
949  PESContext *sub_pes = av_memdup(pes, sizeof(*sub_pes));
950  if (!sub_pes)
951  return AVERROR(ENOMEM);
952 
953  sub_st = avformat_new_stream(pes->stream, NULL);
954  if (!sub_st) {
955  av_free(sub_pes);
956  return AVERROR(ENOMEM);
957  }
958 
959  sub_st->id = pes->pid;
960  avpriv_set_pts_info(sub_st, 33, 1, 90000);
961  sub_st->priv_data = sub_pes;
963  sub_st->codecpar->codec_id = AV_CODEC_ID_AC3;
965  sub_pes->sub_st = pes->sub_st = sub_st;
966  }
967  }
968  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
970  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
972  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
973  st->codecpar->codec_id = old_codec_id;
974  st->codecpar->codec_type = old_codec_type;
975  }
976  if ((st->codecpar->codec_id == AV_CODEC_ID_NONE ||
977  (sti->request_probe > 0 && sti->request_probe < AVPROBE_SCORE_STREAM_RETRY / 5)) &&
978  sti->probe_packets > 0 &&
979  stream_type == STREAM_TYPE_PRIVATE_DATA) {
983  }
984 
985  /* queue a context update if properties changed */
986  if (old_codec_type != st->codecpar->codec_type ||
987  old_codec_id != st->codecpar->codec_id ||
988  old_codec_tag != st->codecpar->codec_tag)
989  sti->need_context_update = 1;
990 
991  return 0;
992 }
993 
995 {
996  pes->pts = AV_NOPTS_VALUE;
997  pes->dts = AV_NOPTS_VALUE;
998  pes->data_index = 0;
999  pes->flags = 0;
1000  av_buffer_unref(&pes->buffer);
1001 }
1002 
1003 static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt)
1004 {
1006  pkt->data = (uint8_t *)buffer;
1007  pkt->size = len;
1008 }
1009 
1011 {
1012  uint8_t *sd;
1013 
1015 
1016  pkt->buf = pes->buffer;
1017  pkt->data = pes->buffer->data;
1018  pkt->size = pes->data_index;
1019 
1020  if (pes->PES_packet_length &&
1021  pes->pes_header_size + pes->data_index != pes->PES_packet_length +
1022  PES_START_SIZE) {
1023  av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n");
1024  pes->flags |= AV_PKT_FLAG_CORRUPT;
1025  }
1026  memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1027 
1028  // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
1029  if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76)
1030  pkt->stream_index = pes->sub_st->index;
1031  else
1032  pkt->stream_index = pes->st->index;
1033  pkt->pts = pes->pts;
1034  pkt->dts = pes->dts;
1035  /* store position of first TS packet of this PES packet */
1036  pkt->pos = pes->ts_packet_pos;
1037  pkt->flags = pes->flags;
1038 
1039  pes->buffer = NULL;
1041 
1043  if (!sd)
1044  return AVERROR(ENOMEM);
1045  *sd = pes->stream_id;
1046 
1047  return 0;
1048 }
1049 
1050 static uint64_t get_ts64(GetBitContext *gb, int bits)
1051 {
1052  if (get_bits_left(gb) < bits)
1053  return AV_NOPTS_VALUE;
1054  return get_bits64(gb, bits);
1055 }
1056 
1058  const uint8_t *buf, int buf_size)
1059 {
1060  GetBitContext gb;
1061  int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;
1062  int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;
1063  int dts_flag = -1, cts_flag = -1;
1064  int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE;
1065  uint8_t buf_padded[128 + AV_INPUT_BUFFER_PADDING_SIZE];
1066  int buf_padded_size = FFMIN(buf_size, sizeof(buf_padded) - AV_INPUT_BUFFER_PADDING_SIZE);
1067 
1068  memcpy(buf_padded, buf, buf_padded_size);
1069 
1070  init_get_bits(&gb, buf_padded, buf_padded_size * 8);
1071 
1072  if (sl->use_au_start)
1073  au_start_flag = get_bits1(&gb);
1074  if (sl->use_au_end)
1075  au_end_flag = get_bits1(&gb);
1076  if (!sl->use_au_start && !sl->use_au_end)
1077  au_start_flag = au_end_flag = 1;
1078  if (sl->ocr_len > 0)
1079  ocr_flag = get_bits1(&gb);
1080  if (sl->use_idle)
1081  idle_flag = get_bits1(&gb);
1082  if (sl->use_padding)
1083  padding_flag = get_bits1(&gb);
1084  if (padding_flag)
1085  padding_bits = get_bits(&gb, 3);
1086 
1087  if (!idle_flag && (!padding_flag || padding_bits != 0)) {
1088  if (sl->packet_seq_num_len)
1090  if (sl->degr_prior_len)
1091  if (get_bits1(&gb))
1092  skip_bits(&gb, sl->degr_prior_len);
1093  if (ocr_flag)
1094  skip_bits_long(&gb, sl->ocr_len);
1095  if (au_start_flag) {
1096  if (sl->use_rand_acc_pt)
1097  get_bits1(&gb);
1098  if (sl->au_seq_num_len > 0)
1099  skip_bits_long(&gb, sl->au_seq_num_len);
1100  if (sl->use_timestamps) {
1101  dts_flag = get_bits1(&gb);
1102  cts_flag = get_bits1(&gb);
1103  }
1104  }
1105  if (sl->inst_bitrate_len)
1106  inst_bitrate_flag = get_bits1(&gb);
1107  if (dts_flag == 1)
1108  dts = get_ts64(&gb, sl->timestamp_len);
1109  if (cts_flag == 1)
1110  cts = get_ts64(&gb, sl->timestamp_len);
1111  if (sl->au_len > 0)
1112  skip_bits_long(&gb, sl->au_len);
1113  if (inst_bitrate_flag)
1114  skip_bits_long(&gb, sl->inst_bitrate_len);
1115  }
1116 
1117  if (dts != AV_NOPTS_VALUE)
1118  pes->dts = dts;
1119  if (cts != AV_NOPTS_VALUE)
1120  pes->pts = cts;
1121 
1122  if (sl->timestamp_len && sl->timestamp_res)
1124 
1125  return (get_bits_count(&gb) + 7) >> 3;
1126 }
1127 
1129 {
1131  if (!ts->pools[index]) {
1132  int pool_size = FFMIN(ts->max_packet_size + AV_INPUT_BUFFER_PADDING_SIZE, 2 << index);
1133  ts->pools[index] = av_buffer_pool_init(pool_size, NULL);
1134  if (!ts->pools[index])
1135  return NULL;
1136  }
1137  return av_buffer_pool_get(ts->pools[index]);
1138 }
1139 
1140 /* return non zero if a packet could be constructed */
1142  const uint8_t *buf, int buf_size, int is_start,
1143  int64_t pos)
1144 {
1145  PESContext *pes = filter->u.pes_filter.opaque;
1146  MpegTSContext *ts = pes->ts;
1147  const uint8_t *p;
1148  int ret, len;
1149 
1150  if (!ts->pkt)
1151  return 0;
1152 
1153  if (is_start) {
1154  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
1155  ret = new_pes_packet(pes, ts->pkt);
1156  if (ret < 0)
1157  return ret;
1158  ts->stop_parse = 1;
1159  } else {
1161  }
1162  pes->state = MPEGTS_HEADER;
1163  pes->ts_packet_pos = pos;
1164  }
1165  p = buf;
1166  while (buf_size > 0) {
1167  switch (pes->state) {
1168  case MPEGTS_HEADER:
1169  len = PES_START_SIZE - pes->data_index;
1170  if (len > buf_size)
1171  len = buf_size;
1172  memcpy(pes->header + pes->data_index, p, len);
1173  pes->data_index += len;
1174  p += len;
1175  buf_size -= len;
1176  if (pes->data_index == PES_START_SIZE) {
1177  /* we got all the PES or section header. We can now
1178  * decide */
1179  if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
1180  pes->header[2] == 0x01) {
1181  /* it must be an MPEG-2 PES stream */
1182  pes->stream_id = pes->header[3];
1183  av_log(pes->stream, AV_LOG_TRACE, "pid=%x stream_id=%#x\n", pes->pid, pes->stream_id);
1184 
1185  if ((pes->st && pes->st->discard == AVDISCARD_ALL &&
1186  (!pes->sub_st ||
1187  pes->sub_st->discard == AVDISCARD_ALL)) ||
1189  goto skip;
1190 
1191  /* stream not present in PMT */
1192  if (!pes->st) {
1193  if (ts->skip_changes)
1194  goto skip;
1195  if (ts->merge_pmt_versions)
1196  goto skip; /* wait for PMT to merge new stream */
1197 
1198  pes->st = avformat_new_stream(ts->stream, NULL);
1199  if (!pes->st)
1200  return AVERROR(ENOMEM);
1201  pes->st->id = pes->pid;
1202  mpegts_set_stream_info(pes->st, pes, 0, 0);
1203  }
1204 
1205  pes->PES_packet_length = AV_RB16(pes->header + 4);
1206  /* NOTE: zero length means the PES size is unbounded */
1207 
1210  pes->stream_id != STREAM_ID_ECM_STREAM &&
1211  pes->stream_id != STREAM_ID_EMM_STREAM &&
1215  FFStream *const pes_sti = ffstream(pes->st);
1216  pes->state = MPEGTS_PESHEADER;
1217  if (pes->st->codecpar->codec_id == AV_CODEC_ID_NONE && !pes_sti->request_probe) {
1218  av_log(pes->stream, AV_LOG_TRACE,
1219  "pid=%x stream_type=%x probing\n",
1220  pes->pid,
1221  pes->stream_type);
1222  pes_sti->request_probe = 1;
1223  }
1224  } else {
1225  pes->pes_header_size = 6;
1226  pes->state = MPEGTS_PAYLOAD;
1227  pes->data_index = 0;
1228  }
1229  } else {
1230  /* otherwise, it should be a table */
1231  /* skip packet */
1232 skip:
1233  pes->state = MPEGTS_SKIP;
1234  continue;
1235  }
1236  }
1237  break;
1238  /**********************************************/
1239  /* PES packing parsing */
1240  case MPEGTS_PESHEADER:
1241  len = PES_HEADER_SIZE - pes->data_index;
1242  if (len < 0)
1243  return AVERROR_INVALIDDATA;
1244  if (len > buf_size)
1245  len = buf_size;
1246  memcpy(pes->header + pes->data_index, p, len);
1247  pes->data_index += len;
1248  p += len;
1249  buf_size -= len;
1250  if (pes->data_index == PES_HEADER_SIZE) {
1251  pes->pes_header_size = pes->header[8] + 9;
1253  }
1254  break;
1255  case MPEGTS_PESHEADER_FILL:
1256  len = pes->pes_header_size - pes->data_index;
1257  if (len < 0)
1258  return AVERROR_INVALIDDATA;
1259  if (len > buf_size)
1260  len = buf_size;
1261  memcpy(pes->header + pes->data_index, p, len);
1262  pes->data_index += len;
1263  p += len;
1264  buf_size -= len;
1265  if (pes->data_index == pes->pes_header_size) {
1266  const uint8_t *r;
1267  unsigned int flags, pes_ext, skip;
1268 
1269  flags = pes->header[7];
1270  r = pes->header + 9;
1271  pes->pts = AV_NOPTS_VALUE;
1272  pes->dts = AV_NOPTS_VALUE;
1273  if ((flags & 0xc0) == 0x80) {
1274  pes->dts = pes->pts = ff_parse_pes_pts(r);
1275  r += 5;
1276  } else if ((flags & 0xc0) == 0xc0) {
1277  pes->pts = ff_parse_pes_pts(r);
1278  r += 5;
1279  pes->dts = ff_parse_pes_pts(r);
1280  r += 5;
1281  }
1282  pes->extended_stream_id = -1;
1283  if (flags & 0x01) { /* PES extension */
1284  pes_ext = *r++;
1285  /* Skip PES private data, program packet sequence counter and P-STD buffer */
1286  skip = (pes_ext >> 4) & 0xb;
1287  skip += skip & 0x9;
1288  r += skip;
1289  if ((pes_ext & 0x41) == 0x01 &&
1290  (r + 2) <= (pes->header + pes->pes_header_size)) {
1291  /* PES extension 2 */
1292  if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)
1293  pes->extended_stream_id = r[1];
1294  }
1295  }
1296 
1297  /* we got the full header. We parse it and get the payload */
1298  pes->state = MPEGTS_PAYLOAD;
1299  pes->data_index = 0;
1300  if (pes->stream_type == 0x12 && buf_size > 0) {
1301  int sl_header_bytes = read_sl_header(pes, &pes->sl, p,
1302  buf_size);
1303  pes->pes_header_size += sl_header_bytes;
1304  p += sl_header_bytes;
1305  buf_size -= sl_header_bytes;
1306  }
1307  if (pes->stream_type == 0x15 && buf_size >= 5) {
1308  /* skip metadata access unit header */
1309  pes->pes_header_size += 5;
1310  p += 5;
1311  buf_size -= 5;
1312  }
1313  if ( pes->ts->fix_teletext_pts
1316  ) {
1317  AVProgram *p = NULL;
1318  int pcr_found = 0;
1319  while ((p = av_find_program_from_stream(pes->stream, p, pes->st->index))) {
1320  if (p->pcr_pid != -1 && p->discard != AVDISCARD_ALL) {
1321  MpegTSFilter *f = pes->ts->pids[p->pcr_pid];
1322  if (f) {
1323  AVStream *st = NULL;
1324  if (f->type == MPEGTS_PES) {
1325  PESContext *pcrpes = f->u.pes_filter.opaque;
1326  if (pcrpes)
1327  st = pcrpes->st;
1328  } else if (f->type == MPEGTS_PCR) {
1329  int i;
1330  for (i = 0; i < p->nb_stream_indexes; i++) {
1331  AVStream *pst = pes->stream->streams[p->stream_index[i]];
1332  if (pst->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
1333  st = pst;
1334  }
1335  }
1336  if (f->last_pcr != -1 && !f->discard) {
1337  // teletext packets do not always have correct timestamps,
1338  // the standard says they should be handled after 40.6 ms at most,
1339  // and the pcr error to this packet should be no more than 100 ms.
1340  // TODO: we should interpolate the PCR, not just use the last one
1341  int64_t pcr = f->last_pcr / 300;
1342  pcr_found = 1;
1343  if (st) {
1344  const FFStream *const sti = ffstream(st);
1345  FFStream *const pes_sti = ffstream(pes->st);
1346 
1347  pes_sti->pts_wrap_reference = sti->pts_wrap_reference;
1348  pes_sti->pts_wrap_behavior = sti->pts_wrap_behavior;
1349  }
1350  if (pes->dts == AV_NOPTS_VALUE || pes->dts < pcr) {
1351  pes->pts = pes->dts = pcr;
1352  } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT &&
1353  pes->dts > pcr + 3654 + 9000) {
1354  pes->pts = pes->dts = pcr + 3654 + 9000;
1355  } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
1356  pes->dts > pcr + 10*90000) { //10sec
1357  pes->pts = pes->dts = pcr + 3654 + 9000;
1358  }
1359  break;
1360  }
1361  }
1362  }
1363  }
1364 
1365  if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT &&
1366  !pcr_found) {
1368  "Forcing DTS/PTS to be unset for a "
1369  "non-trustworthy PES packet for PID %d as "
1370  "PCR hasn't been received yet.\n",
1371  pes->pid);
1372  pes->dts = pes->pts = AV_NOPTS_VALUE;
1373  }
1374  }
1375  }
1376  break;
1377  case MPEGTS_PAYLOAD:
1378  do {
1379  int max_packet_size = ts->max_packet_size;
1381  max_packet_size = pes->PES_packet_length + PES_START_SIZE - pes->pes_header_size;
1382 
1383  if (pes->data_index > 0 &&
1384  pes->data_index + buf_size > max_packet_size) {
1385  ret = new_pes_packet(pes, ts->pkt);
1386  if (ret < 0)
1387  return ret;
1388  pes->PES_packet_length = 0;
1389  max_packet_size = ts->max_packet_size;
1390  ts->stop_parse = 1;
1391  } else if (pes->data_index == 0 &&
1392  buf_size > max_packet_size) {
1393  // pes packet size is < ts size packet and pes data is padded with 0xff
1394  // not sure if this is legal in ts but see issue #2392
1395  buf_size = max_packet_size;
1396  }
1397 
1398  if (!pes->buffer) {
1399  pes->buffer = buffer_pool_get(ts, max_packet_size);
1400  if (!pes->buffer)
1401  return AVERROR(ENOMEM);
1402  }
1403 
1404  memcpy(pes->buffer->data + pes->data_index, p, buf_size);
1405  pes->data_index += buf_size;
1406  /* emit complete packets with known packet size
1407  * decreases demuxer delay for infrequent packets like subtitles from
1408  * a couple of seconds to milliseconds for properly muxed files. */
1409  if (!ts->stop_parse && pes->PES_packet_length &&
1411  ts->stop_parse = 1;
1412  ret = new_pes_packet(pes, ts->pkt);
1413  pes->state = MPEGTS_SKIP;
1414  if (ret < 0)
1415  return ret;
1416  }
1417  } while (0);
1418  buf_size = 0;
1419  break;
1420  case MPEGTS_SKIP:
1421  buf_size = 0;
1422  break;
1423  }
1424  }
1425 
1426  return 0;
1427 }
1428 
1429 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
1430 {
1431  MpegTSFilter *tss;
1432  PESContext *pes;
1433 
1434  /* if no pid found, then add a pid context */
1435  pes = av_mallocz(sizeof(PESContext));
1436  if (!pes)
1437  return 0;
1438  pes->ts = ts;
1439  pes->stream = ts->stream;
1440  pes->pid = pid;
1441  pes->pcr_pid = pcr_pid;
1442  pes->state = MPEGTS_SKIP;
1443  pes->pts = AV_NOPTS_VALUE;
1444  pes->dts = AV_NOPTS_VALUE;
1445  tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
1446  if (!tss) {
1447  av_free(pes);
1448  return 0;
1449  }
1450  return pes;
1451 }
1452 
1453 #define MAX_LEVEL 4
1454 typedef struct MP4DescrParseContext {
1461  int level;
1464 
1466  const uint8_t *buf, unsigned size,
1467  Mp4Descr *descr, int max_descr_count)
1468 {
1469  if (size > (1 << 30))
1470  return AVERROR_INVALIDDATA;
1471 
1472  ffio_init_context(&d->pb, (unsigned char *)buf, size,
1473  0, NULL, NULL, NULL, NULL);
1474 
1475  d->s = s;
1476  d->level = 0;
1477  d->descr_count = 0;
1478  d->descr = descr;
1479  d->active_descr = NULL;
1480  d->max_descr_count = max_descr_count;
1481 
1482  return 0;
1483 }
1484 
1485 static void update_offsets(AVIOContext *pb, int64_t *off, int *len)
1486 {
1487  int64_t new_off = avio_tell(pb);
1488  (*len) -= new_off - *off;
1489  *off = new_off;
1490 }
1491 
1492 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1493  int target_tag);
1494 
1495 static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
1496 {
1497  while (len > 0) {
1498  int ret = parse_mp4_descr(d, off, len, 0);
1499  if (ret < 0)
1500  return ret;
1501  update_offsets(&d->pb.pub, &off, &len);
1502  }
1503  return 0;
1504 }
1505 
1506 static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1507 {
1508  AVIOContext *const pb = &d->pb.pub;
1509  avio_rb16(pb); // ID
1510  avio_r8(pb);
1511  avio_r8(pb);
1512  avio_r8(pb);
1513  avio_r8(pb);
1514  avio_r8(pb);
1515  update_offsets(pb, &off, &len);
1516  return parse_mp4_descr_arr(d, off, len);
1517 }
1518 
1519 static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1520 {
1521  int id_flags;
1522  if (len < 2)
1523  return 0;
1524  id_flags = avio_rb16(&d->pb.pub);
1525  if (!(id_flags & 0x0020)) { // URL_Flag
1526  update_offsets(&d->pb.pub, &off, &len);
1527  return parse_mp4_descr_arr(d, off, len); // ES_Descriptor[]
1528  } else {
1529  return 0;
1530  }
1531 }
1532 
1533 static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1534 {
1535  AVIOContext *const pb = &d->pb.pub;
1536  int es_id = 0;
1537  int ret = 0;
1538 
1539  if (d->descr_count >= d->max_descr_count)
1540  return AVERROR_INVALIDDATA;
1541  ff_mp4_parse_es_descr(pb, &es_id);
1542  d->active_descr = d->descr + (d->descr_count++);
1543 
1544  d->active_descr->es_id = es_id;
1545  update_offsets(pb, &off, &len);
1546  if ((ret = parse_mp4_descr(d, off, len, MP4DecConfigDescrTag)) < 0)
1547  return ret;
1548  update_offsets(pb, &off, &len);
1549  if (len > 0)
1551  d->active_descr = NULL;
1552  return ret;
1553 }
1554 
1556  int len)
1557 {
1558  Mp4Descr *descr = d->active_descr;
1559  if (!descr)
1560  return AVERROR_INVALIDDATA;
1561  d->active_descr->dec_config_descr = av_malloc(len);
1562  if (!descr->dec_config_descr)
1563  return AVERROR(ENOMEM);
1564  descr->dec_config_descr_len = len;
1565  avio_read(&d->pb.pub, descr->dec_config_descr, len);
1566  return 0;
1567 }
1568 
1569 static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1570 {
1571  Mp4Descr *descr = d->active_descr;
1572  AVIOContext *const pb = &d->pb.pub;
1573  int predefined;
1574  if (!descr)
1575  return AVERROR_INVALIDDATA;
1576 
1577 #define R8_CHECK_CLIP_MAX(dst, maxv) do { \
1578  descr->sl.dst = avio_r8(pb); \
1579  if (descr->sl.dst > maxv) { \
1580  descr->sl.dst = maxv; \
1581  return AVERROR_INVALIDDATA; \
1582  } \
1583 } while (0)
1584 
1585  predefined = avio_r8(pb);
1586  if (!predefined) {
1587  int lengths;
1588  int flags = avio_r8(pb);
1589  descr->sl.use_au_start = !!(flags & 0x80);
1590  descr->sl.use_au_end = !!(flags & 0x40);
1591  descr->sl.use_rand_acc_pt = !!(flags & 0x20);
1592  descr->sl.use_padding = !!(flags & 0x08);
1593  descr->sl.use_timestamps = !!(flags & 0x04);
1594  descr->sl.use_idle = !!(flags & 0x02);
1595  descr->sl.timestamp_res = avio_rb32(pb);
1596  avio_rb32(pb);
1597  R8_CHECK_CLIP_MAX(timestamp_len, 63);
1598  R8_CHECK_CLIP_MAX(ocr_len, 63);
1599  R8_CHECK_CLIP_MAX(au_len, 31);
1600  descr->sl.inst_bitrate_len = avio_r8(pb);
1601  lengths = avio_rb16(pb);
1602  descr->sl.degr_prior_len = lengths >> 12;
1603  descr->sl.au_seq_num_len = (lengths >> 7) & 0x1f;
1604  descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f;
1605  } else if (!d->predefined_SLConfigDescriptor_seen){
1606  avpriv_report_missing_feature(d->s, "Predefined SLConfigDescriptor");
1607  d->predefined_SLConfigDescriptor_seen = 1;
1608  }
1609  return 0;
1610 }
1611 
1612 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1613  int target_tag)
1614 {
1615  int tag;
1616  AVIOContext *const pb = &d->pb.pub;
1617  int len1 = ff_mp4_read_descr(d->s, pb, &tag);
1618  int ret = 0;
1619 
1620  update_offsets(pb, &off, &len);
1621  if (len < 0 || len1 > len || len1 <= 0) {
1622  av_log(d->s, AV_LOG_ERROR,
1623  "Tag %x length violation new length %d bytes remaining %d\n",
1624  tag, len1, len);
1625  return AVERROR_INVALIDDATA;
1626  }
1627 
1628  if (d->level++ >= MAX_LEVEL) {
1629  av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n");
1631  goto done;
1632  }
1633 
1634  if (target_tag && tag != target_tag) {
1635  av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag,
1636  target_tag);
1638  goto done;
1639  }
1640 
1641  switch (tag) {
1642  case MP4IODescrTag:
1643  ret = parse_MP4IODescrTag(d, off, len1);
1644  break;
1645  case MP4ODescrTag:
1646  ret = parse_MP4ODescrTag(d, off, len1);
1647  break;
1648  case MP4ESDescrTag:
1649  ret = parse_MP4ESDescrTag(d, off, len1);
1650  break;
1651  case MP4DecConfigDescrTag:
1652  ret = parse_MP4DecConfigDescrTag(d, off, len1);
1653  break;
1654  case MP4SLDescrTag:
1655  ret = parse_MP4SLDescrTag(d, off, len1);
1656  break;
1657  }
1658 
1659 
1660 done:
1661  d->level--;
1662  avio_seek(pb, off + len1, SEEK_SET);
1663  return ret;
1664 }
1665 
1666 static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
1667  Mp4Descr *descr, int *descr_count, int max_descr_count)
1668 {
1670  int ret;
1671 
1672  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1673  if (ret < 0)
1674  return ret;
1675 
1676  ret = parse_mp4_descr(&d, avio_tell(&d.pb.pub), size, MP4IODescrTag);
1677 
1678  *descr_count = d.descr_count;
1679  return ret;
1680 }
1681 
1682 static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size,
1683  Mp4Descr *descr, int *descr_count, int max_descr_count)
1684 {
1686  int ret;
1687 
1688  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1689  if (ret < 0)
1690  return ret;
1691 
1692  ret = parse_mp4_descr_arr(&d, avio_tell(&d.pb.pub), size);
1693 
1694  *descr_count = d.descr_count;
1695  return ret;
1696 }
1697 
1698 static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section,
1699  int section_len)
1700 {
1701  MpegTSContext *ts = filter->u.section_filter.opaque;
1702  MpegTSSectionFilter *tssf = &filter->u.section_filter;
1703  SectionHeader h;
1704  const uint8_t *p, *p_end;
1705  int mp4_descr_count = 0;
1706  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
1707  int i, pid;
1708  AVFormatContext *s = ts->stream;
1709 
1710  p_end = section + section_len - 4;
1711  p = section;
1712  if (parse_section_header(&h, &p, p_end) < 0)
1713  return;
1714  if (h.tid != M4OD_TID)
1715  return;
1716  if (skip_identical(&h, tssf))
1717  return;
1718 
1719  mp4_read_od(s, p, (unsigned) (p_end - p), mp4_descr, &mp4_descr_count,
1721 
1722  for (pid = 0; pid < NB_PID_MAX; pid++) {
1723  if (!ts->pids[pid])
1724  continue;
1725  for (i = 0; i < mp4_descr_count; i++) {
1726  PESContext *pes;
1727  AVStream *st;
1728  FFStream *sti;
1729  FFIOContext pb;
1730  if (ts->pids[pid]->es_id != mp4_descr[i].es_id)
1731  continue;
1732  if (ts->pids[pid]->type != MPEGTS_PES) {
1733  av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);
1734  continue;
1735  }
1736  pes = ts->pids[pid]->u.pes_filter.opaque;
1737  st = pes->st;
1738  if (!st)
1739  continue;
1740  sti = ffstream(st);
1741 
1742  pes->sl = mp4_descr[i].sl;
1743 
1744  ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1745  mp4_descr[i].dec_config_descr_len, 0,
1746  NULL, NULL, NULL, NULL);
1748  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1749  st->codecpar->extradata_size > 0)
1750  sti->need_parsing = 0;
1751  if (st->codecpar->codec_id == AV_CODEC_ID_H264 &&
1752  st->codecpar->extradata_size > 0)
1753  sti->need_parsing = 0;
1754 
1756  sti->need_context_update = 1;
1757  }
1758  }
1759  for (i = 0; i < mp4_descr_count; i++)
1760  av_free(mp4_descr[i].dec_config_descr);
1761 }
1762 
1763 static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section,
1764  int section_len)
1765 {
1766  AVProgram *prg = NULL;
1767  MpegTSContext *ts = filter->u.section_filter.opaque;
1768 
1769  int idx = ff_find_stream_index(ts->stream, filter->pid);
1770  if (idx < 0)
1771  return;
1772 
1773  /**
1774  * In case we receive an SCTE-35 packet before mpegts context is fully
1775  * initialized.
1776  */
1777  if (!ts->pkt)
1778  return;
1779 
1780  new_data_packet(section, section_len, ts->pkt);
1781  ts->pkt->stream_index = idx;
1782  prg = av_find_program_from_stream(ts->stream, NULL, idx);
1783  if (prg && prg->pcr_pid != -1 && prg->discard != AVDISCARD_ALL) {
1784  MpegTSFilter *f = ts->pids[prg->pcr_pid];
1785  if (f && f->last_pcr != -1)
1786  ts->pkt->pts = ts->pkt->dts = f->last_pcr/300;
1787  }
1788  ts->stop_parse = 1;
1789 
1790 }
1791 
1792 static const uint8_t opus_coupled_stream_cnt[9] = {
1793  1, 0, 1, 1, 2, 2, 2, 3, 3
1794 };
1795 
1796 static const uint8_t opus_stream_cnt[9] = {
1797  1, 1, 1, 2, 2, 3, 4, 4, 5,
1798 };
1799 
1800 static const uint8_t opus_channel_map[8][8] = {
1801  { 0 },
1802  { 0,1 },
1803  { 0,2,1 },
1804  { 0,1,2,3 },
1805  { 0,4,1,2,3 },
1806  { 0,4,1,2,3,5 },
1807  { 0,4,1,2,3,5,6 },
1808  { 0,6,1,2,3,4,5,7 },
1809 };
1810 
1812  const uint8_t **pp, const uint8_t *desc_list_end,
1813  Mp4Descr *mp4_descr, int mp4_descr_count, int pid,
1814  MpegTSContext *ts)
1815 {
1816  FFStream *const sti = ffstream(st);
1817  const uint8_t *desc_end;
1818  int desc_len, desc_tag, desc_es_id, ext_desc_tag, channels, channel_config_code;
1819  char language[252];
1820  int i;
1821 
1822  desc_tag = get8(pp, desc_list_end);
1823  if (desc_tag < 0)
1824  return AVERROR_INVALIDDATA;
1825  desc_len = get8(pp, desc_list_end);
1826  if (desc_len < 0)
1827  return AVERROR_INVALIDDATA;
1828  desc_end = *pp + desc_len;
1829  if (desc_end > desc_list_end)
1830  return AVERROR_INVALIDDATA;
1831 
1832  av_log(fc, AV_LOG_TRACE, "tag: 0x%02x len=%d\n", desc_tag, desc_len);
1833 
1834  if ((st->codecpar->codec_id == AV_CODEC_ID_NONE || sti->request_probe > 0) &&
1835  stream_type == STREAM_TYPE_PRIVATE_DATA)
1836  mpegts_find_stream_type(st, desc_tag, DESC_types);
1837 
1838  switch (desc_tag) {
1840  if (get8(pp, desc_end) & 0x1) {
1842  }
1843  break;
1844  case SL_DESCRIPTOR:
1845  desc_es_id = get16(pp, desc_end);
1846  if (desc_es_id < 0)
1847  break;
1848  if (ts && ts->pids[pid])
1849  ts->pids[pid]->es_id = desc_es_id;
1850  for (i = 0; i < mp4_descr_count; i++)
1851  if (mp4_descr[i].dec_config_descr_len &&
1852  mp4_descr[i].es_id == desc_es_id) {
1853  FFIOContext pb;
1854  ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1855  mp4_descr[i].dec_config_descr_len, 0,
1856  NULL, NULL, NULL, NULL);
1858  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1859  st->codecpar->extradata_size > 0) {
1860  sti->need_parsing = 0;
1861  sti->need_context_update = 1;
1862  }
1864  mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);
1865  }
1866  break;
1867  case FMC_DESCRIPTOR:
1868  if (get16(pp, desc_end) < 0)
1869  break;
1870  if (mp4_descr_count > 0 &&
1872  (sti->request_probe == 0 && st->codecpar->codec_id == AV_CODEC_ID_NONE) ||
1873  sti->request_probe > 0) &&
1874  mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {
1875  FFIOContext pb;
1876  ffio_init_context(&pb, mp4_descr->dec_config_descr,
1877  mp4_descr->dec_config_descr_len, 0,
1878  NULL, NULL, NULL, NULL);
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 = FF_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 = FF_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 = FF_PROFILE_ARIB_PROFILE_C;
2168  }
2169  break;
2170  default:
2171  break;
2172  }
2173 
2174  if (picked_profile == FF_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 ret;
2193  int dependency_pid;
2194 
2195  if (desc_end - *pp < 4) // (8 + 8 + 7 + 6 + 1 + 1 + 1) / 8
2196  return AVERROR_INVALIDDATA;
2197 
2198  dovi = av_dovi_alloc(&dovi_size);
2199  if (!dovi)
2200  return AVERROR(ENOMEM);
2201 
2202  dovi->dv_version_major = get8(pp, desc_end);
2203  dovi->dv_version_minor = get8(pp, desc_end);
2204  buf = get16(pp, desc_end);
2205  dovi->dv_profile = (buf >> 9) & 0x7f; // 7 bits
2206  dovi->dv_level = (buf >> 3) & 0x3f; // 6 bits
2207  dovi->rpu_present_flag = (buf >> 2) & 0x01; // 1 bit
2208  dovi->el_present_flag = (buf >> 1) & 0x01; // 1 bit
2209  dovi->bl_present_flag = buf & 0x01; // 1 bit
2210  if (!dovi->bl_present_flag && desc_end - *pp >= 2) {
2211  buf = get16(pp, desc_end);
2212  dependency_pid = buf >> 3; // 13 bits
2213  }
2214  if (desc_end - *pp >= 1) { // 8 bits
2215  buf = get8(pp, desc_end);
2216  dovi->dv_bl_signal_compatibility_id = (buf >> 4) & 0x0f; // 4 bits
2217  } else {
2218  // 0 stands for None
2219  // Dolby Vision V1.2.93 profiles and levels
2221  }
2222 
2224  (uint8_t *)dovi, dovi_size);
2225  if (ret < 0) {
2226  av_free(dovi);
2227  return ret;
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->stream->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  }
2607  }
2608  }
2609  ts->nb_prg = nb_prg;
2610 
2611  if (sid < 0) {
2612  int i,j;
2613  for (j=0; j<ts->stream->nb_programs; j++) {
2614  for (i = 0; i < ts->nb_prg; i++)
2615  if (ts->prg[i].id == ts->stream->programs[j]->id)
2616  break;
2617  if (i==ts->nb_prg && !ts->skip_clear)
2618  clear_avprogram(ts, ts->stream->programs[j]->id);
2619  }
2620  }
2621 }
2622 
2623 static void eit_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2624 {
2625  MpegTSContext *ts = filter->u.section_filter.opaque;
2626  const uint8_t *p, *p_end;
2627  SectionHeader h1, *h = &h1;
2628 
2629  /*
2630  * Sometimes we receive EPG packets but SDT table do not have
2631  * eit_pres_following or eit_sched turned on, so we open EPG
2632  * stream directly here.
2633  */
2634  if (!ts->epg_stream) {
2636  if (!ts->epg_stream)
2637  return;
2638  ts->epg_stream->id = EIT_PID;
2641  }
2642 
2643  if (ts->epg_stream->discard == AVDISCARD_ALL)
2644  return;
2645 
2646  p_end = section + section_len - 4;
2647  p = section;
2648 
2649  if (parse_section_header(h, &p, p_end) < 0)
2650  return;
2651  if (h->tid < EIT_TID || h->tid > OEITS_END_TID)
2652  return;
2653 
2654  av_log(ts->stream, AV_LOG_TRACE, "EIT: tid received = %.02x\n", h->tid);
2655 
2656  /**
2657  * Service_id 0xFFFF is reserved, it indicates that the current EIT table
2658  * is scrambled.
2659  */
2660  if (h->id == 0xFFFF) {
2661  av_log(ts->stream, AV_LOG_TRACE, "Scrambled EIT table received.\n");
2662  return;
2663  }
2664 
2665  /**
2666  * In case we receive an EPG packet before mpegts context is fully
2667  * initialized.
2668  */
2669  if (!ts->pkt)
2670  return;
2671 
2672  new_data_packet(section, section_len, ts->pkt);
2673  ts->pkt->stream_index = ts->epg_stream->index;
2674  ts->stop_parse = 1;
2675 }
2676 
2677 static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2678 {
2679  MpegTSContext *ts = filter->u.section_filter.opaque;
2680  MpegTSSectionFilter *tssf = &filter->u.section_filter;
2681  SectionHeader h1, *h = &h1;
2682  const uint8_t *p, *p_end, *desc_list_end, *desc_end;
2683  int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
2684  char *name, *provider_name;
2685 
2686  av_log(ts->stream, AV_LOG_TRACE, "SDT:\n");
2687  hex_dump_debug(ts->stream, section, section_len);
2688 
2689  p_end = section + section_len - 4;
2690  p = section;
2691  if (parse_section_header(h, &p, p_end) < 0)
2692  return;
2693  if (h->tid != SDT_TID)
2694  return;
2695  if (!h->current_next)
2696  return;
2697  if (ts->skip_changes)
2698  return;
2699  if (skip_identical(h, tssf))
2700  return;
2701 
2702  onid = get16(&p, p_end);
2703  if (onid < 0)
2704  return;
2705  val = get8(&p, p_end);
2706  if (val < 0)
2707  return;
2708  for (;;) {
2709  sid = get16(&p, p_end);
2710  if (sid < 0)
2711  break;
2712  val = get8(&p, p_end);
2713  if (val < 0)
2714  break;
2715  desc_list_len = get16(&p, p_end);
2716  if (desc_list_len < 0)
2717  break;
2718  desc_list_len &= 0xfff;
2719  desc_list_end = p + desc_list_len;
2720  if (desc_list_end > p_end)
2721  break;
2722  for (;;) {
2723  desc_tag = get8(&p, desc_list_end);
2724  if (desc_tag < 0)
2725  break;
2726  desc_len = get8(&p, desc_list_end);
2727  desc_end = p + desc_len;
2728  if (desc_len < 0 || desc_end > desc_list_end)
2729  break;
2730 
2731  av_log(ts->stream, AV_LOG_TRACE, "tag: 0x%02x len=%d\n",
2732  desc_tag, desc_len);
2733 
2734  switch (desc_tag) {
2735  case 0x48:
2736  service_type = get8(&p, desc_end);
2737  if (service_type < 0)
2738  break;
2739  provider_name = getstr8(&p, desc_end);
2740  if (!provider_name)
2741  break;
2742  name = getstr8(&p, desc_end);
2743  if (name) {
2744  AVProgram *program = av_new_program(ts->stream, sid);
2745  if (program) {
2746  av_dict_set(&program->metadata, "service_name", name, 0);
2747  av_dict_set(&program->metadata, "service_provider",
2748  provider_name, 0);
2749  }
2750  }
2751  av_free(name);
2752  av_free(provider_name);
2753  break;
2754  default:
2755  break;
2756  }
2757  p = desc_end;
2758  }
2759  p = desc_list_end;
2760  }
2761 }
2762 
2763 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
2764  const uint8_t *packet);
2765 
2766 /* handle one TS packet */
2767 static int handle_packet(MpegTSContext *ts, const uint8_t *packet, int64_t pos)
2768 {
2769  MpegTSFilter *tss;
2770  int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,
2771  has_adaptation, has_payload;
2772  const uint8_t *p, *p_end;
2773 
2774  pid = AV_RB16(packet + 1) & 0x1fff;
2775  is_start = packet[1] & 0x40;
2776  tss = ts->pids[pid];
2777  if (ts->auto_guess && !tss && is_start) {
2778  add_pes_stream(ts, pid, -1);
2779  tss = ts->pids[pid];
2780  }
2781  if (!tss)
2782  return 0;
2783  if (is_start)
2784  tss->discard = discard_pid(ts, pid);
2785  if (tss->discard)
2786  return 0;
2787  ts->current_pid = pid;
2788 
2789  afc = (packet[3] >> 4) & 3;
2790  if (afc == 0) /* reserved value */
2791  return 0;
2792  has_adaptation = afc & 2;
2793  has_payload = afc & 1;
2794  is_discontinuity = has_adaptation &&
2795  packet[4] != 0 && /* with length > 0 */
2796  (packet[5] & 0x80); /* and discontinuity indicated */
2797 
2798  /* continuity check (currently not used) */
2799  cc = (packet[3] & 0xf);
2800  expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc;
2801  cc_ok = pid == 0x1FFF || // null packet PID
2802  is_discontinuity ||
2803  tss->last_cc < 0 ||
2804  expected_cc == cc;
2805 
2806  tss->last_cc = cc;
2807  if (!cc_ok) {
2808  av_log(ts->stream, AV_LOG_DEBUG,
2809  "Continuity check failed for pid %d expected %d got %d\n",
2810  pid, expected_cc, cc);
2811  if (tss->type == MPEGTS_PES) {
2812  PESContext *pc = tss->u.pes_filter.opaque;
2813  pc->flags |= AV_PKT_FLAG_CORRUPT;
2814  }
2815  }
2816 
2817  if (packet[1] & 0x80) {
2818  av_log(ts->stream, AV_LOG_DEBUG, "Packet had TEI flag set; marking as corrupt\n");
2819  if (tss->type == MPEGTS_PES) {
2820  PESContext *pc = tss->u.pes_filter.opaque;
2821  pc->flags |= AV_PKT_FLAG_CORRUPT;
2822  }
2823  }
2824 
2825  p = packet + 4;
2826  if (has_adaptation) {
2827  int64_t pcr_h;
2828  int pcr_l;
2829  if (parse_pcr(&pcr_h, &pcr_l, packet) == 0)
2830  tss->last_pcr = pcr_h * 300 + pcr_l;
2831  /* skip adaptation field */
2832  p += p[0] + 1;
2833  }
2834  /* if past the end of packet, ignore */
2835  p_end = packet + TS_PACKET_SIZE;
2836  if (p >= p_end || !has_payload)
2837  return 0;
2838 
2839  if (pos >= 0) {
2841  ts->pos47_full = pos - TS_PACKET_SIZE;
2842  }
2843 
2844  if (tss->type == MPEGTS_SECTION) {
2845  if (is_start) {
2846  /* pointer field present */
2847  len = *p++;
2848  if (len > p_end - p)
2849  return 0;
2850  if (len && cc_ok) {
2851  /* write remaining section bytes */
2852  write_section_data(ts, tss,
2853  p, len, 0);
2854  /* check whether filter has been closed */
2855  if (!ts->pids[pid])
2856  return 0;
2857  }
2858  p += len;
2859  if (p < p_end) {
2860  write_section_data(ts, tss,
2861  p, p_end - p, 1);
2862  }
2863  } else {
2864  if (cc_ok) {
2865  write_section_data(ts, tss,
2866  p, p_end - p, 0);
2867  }
2868  }
2869 
2870  // stop find_stream_info from waiting for more streams
2871  // when all programs have received a PMT
2872  if (ts->stream->ctx_flags & AVFMTCTX_NOHEADER && ts->scan_all_pmts <= 0) {
2873  int i;
2874  for (i = 0; i < ts->nb_prg; i++) {
2875  if (!ts->prg[i].pmt_found)
2876  break;
2877  }
2878  if (i == ts->nb_prg && ts->nb_prg > 0) {
2879  av_log(ts->stream, AV_LOG_DEBUG, "All programs have pmt, headers found\n");
2881  }
2882  }
2883 
2884  } else {
2885  int ret;
2886  // Note: The position here points actually behind the current packet.
2887  if (tss->type == MPEGTS_PES) {
2888  if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
2889  pos - ts->raw_packet_size)) < 0)
2890  return ret;
2891  }
2892  }
2893 
2894  return 0;
2895 }
2896 
2897 static int mpegts_resync(AVFormatContext *s, int seekback, const uint8_t *current_packet)
2898 {
2899  MpegTSContext *ts = s->priv_data;
2900  AVIOContext *pb = s->pb;
2901  int c, i;
2902  uint64_t pos = avio_tell(pb);
2903  int64_t back = FFMIN(seekback, pos);
2904 
2905  //Special case for files like 01c56b0dc1.ts
2906  if (current_packet[0] == 0x80 && current_packet[12] == 0x47 && pos >= TS_PACKET_SIZE) {
2907  avio_seek(pb, 12 - TS_PACKET_SIZE, SEEK_CUR);
2908  return 0;
2909  }
2910 
2911  avio_seek(pb, -back, SEEK_CUR);
2912 
2913  for (i = 0; i < ts->resync_size; i++) {
2914  c = avio_r8(pb);
2915  if (avio_feof(pb))
2916  return AVERROR_EOF;
2917  if (c == 0x47) {
2918  int new_packet_size, ret;
2919  avio_seek(pb, -1, SEEK_CUR);
2920  pos = avio_tell(pb);
2922  if (ret < 0)
2923  return ret;
2924  new_packet_size = get_packet_size(s);
2925  if (new_packet_size > 0 && new_packet_size != ts->raw_packet_size) {
2926  av_log(ts->stream, AV_LOG_WARNING, "changing packet size to %d\n", new_packet_size);
2927  ts->raw_packet_size = new_packet_size;
2928  }
2929  avio_seek(pb, pos, SEEK_SET);
2930  return 0;
2931  }
2932  }
2934  "max resync size reached, could not find sync byte\n");
2935  /* no sync found */
2936  return AVERROR_INVALIDDATA;
2937 }
2938 
2939 /* return AVERROR_something if error or EOF. Return 0 if OK. */
2940 static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size,
2941  const uint8_t **data)
2942 {
2943  AVIOContext *pb = s->pb;
2944  int len;
2945 
2946  for (;;) {
2948  if (len != TS_PACKET_SIZE)
2949  return len < 0 ? len : AVERROR_EOF;
2950  /* check packet sync byte */
2951  if ((*data)[0] != 0x47) {
2952  /* find a new packet start */
2953 
2954  if (mpegts_resync(s, raw_packet_size, *data) < 0)
2955  return AVERROR(EAGAIN);
2956  else
2957  continue;
2958  } else {
2959  break;
2960  }
2961  }
2962  return 0;
2963 }
2964 
2965 static void finished_reading_packet(AVFormatContext *s, int raw_packet_size)
2966 {
2967  AVIOContext *pb = s->pb;
2968  int skip = raw_packet_size - TS_PACKET_SIZE;
2969  if (skip > 0)
2970  avio_skip(pb, skip);
2971 }
2972 
2973 static int handle_packets(MpegTSContext *ts, int64_t nb_packets)
2974 {
2975  AVFormatContext *s = ts->stream;
2976  uint8_t packet[TS_PACKET_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
2977  const uint8_t *data;
2978  int64_t packet_num;
2979  int ret = 0;
2980 
2981  if (avio_tell(s->pb) != ts->last_pos) {
2982  int i;
2983  av_log(ts->stream, AV_LOG_TRACE, "Skipping after seek\n");
2984  /* seek detected, flush pes buffer */
2985  for (i = 0; i < NB_PID_MAX; i++) {
2986  if (ts->pids[i]) {
2987  if (ts->pids[i]->type == MPEGTS_PES) {
2988  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
2989  av_buffer_unref(&pes->buffer);
2990  pes->data_index = 0;
2991  pes->state = MPEGTS_SKIP; /* skip until pes header */
2992  } else if (ts->pids[i]->type == MPEGTS_SECTION) {
2993  ts->pids[i]->u.section_filter.last_ver = -1;
2994  }
2995  ts->pids[i]->last_cc = -1;
2996  ts->pids[i]->last_pcr = -1;
2997  }
2998  }
2999  }
3000 
3001  ts->stop_parse = 0;
3002  packet_num = 0;
3003  memset(packet + TS_PACKET_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3004  for (;;) {
3005  packet_num++;
3006  if (nb_packets != 0 && packet_num >= nb_packets ||
3007  ts->stop_parse > 1) {
3008  ret = AVERROR(EAGAIN);
3009  break;
3010  }
3011  if (ts->stop_parse > 0)
3012  break;
3013 
3014  ret = read_packet(s, packet, ts->raw_packet_size, &data);
3015  if (ret != 0)
3016  break;
3017  ret = handle_packet(ts, data, avio_tell(s->pb));
3019  if (ret != 0)
3020  break;
3021  }
3022  ts->last_pos = avio_tell(s->pb);
3023  return ret;
3024 }
3025 
3026 static int mpegts_probe(const AVProbeData *p)
3027 {
3028  const int size = p->buf_size;
3029  int maxscore = 0;
3030  int sumscore = 0;
3031  int i;
3032  int check_count = size / TS_FEC_PACKET_SIZE;
3033 #define CHECK_COUNT 10
3034 #define CHECK_BLOCK 100
3035 
3036  if (!check_count)
3037  return 0;
3038 
3039  for (i = 0; i<check_count; i+=CHECK_BLOCK) {
3040  int left = FFMIN(check_count - i, CHECK_BLOCK);
3041  int score = analyze(p->buf + TS_PACKET_SIZE *i, TS_PACKET_SIZE *left, TS_PACKET_SIZE , 1);
3044  score = FFMAX3(score, dvhs_score, fec_score);
3045  sumscore += score;
3046  maxscore = FFMAX(maxscore, score);
3047  }
3048 
3049  sumscore = sumscore * CHECK_COUNT / check_count;
3050  maxscore = maxscore * CHECK_COUNT / CHECK_BLOCK;
3051 
3052  ff_dlog(0, "TS score: %d %d\n", sumscore, maxscore);
3053 
3054  if (check_count > CHECK_COUNT && sumscore > 6) {
3055  return AVPROBE_SCORE_MAX + sumscore - CHECK_COUNT;
3056  } else if (check_count >= CHECK_COUNT && sumscore > 6) {
3057  return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT;
3058  } else if (check_count >= CHECK_COUNT && maxscore > 6) {
3059  return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT;
3060  } else if (sumscore > 6) {
3061  return 2;
3062  } else {
3063  return 0;
3064  }
3065 }
3066 
3067 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
3068  * (-1) if not available */
3069 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet)
3070 {
3071  int afc, len, flags;
3072  const uint8_t *p;
3073  unsigned int v;
3074 
3075  afc = (packet[3] >> 4) & 3;
3076  if (afc <= 1)
3077  return AVERROR_INVALIDDATA;
3078  p = packet + 4;
3079  len = p[0];
3080  p++;
3081  if (len == 0)
3082  return AVERROR_INVALIDDATA;
3083  flags = *p++;
3084  len--;
3085  if (!(flags & 0x10))
3086  return AVERROR_INVALIDDATA;
3087  if (len < 6)
3088  return AVERROR_INVALIDDATA;
3089  v = AV_RB32(p);
3090  *ppcr_high = ((int64_t) v << 1) | (p[4] >> 7);
3091  *ppcr_low = ((p[4] & 1) << 8) | p[5];
3092  return 0;
3093 }
3094 
3095 static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos) {
3096 
3097  /* NOTE: We attempt to seek on non-seekable files as well, as the
3098  * probe buffer usually is big enough. Only warn if the seek failed
3099  * on files where the seek should work. */
3100  if (avio_seek(pb, pos, SEEK_SET) < 0)
3101  av_log(s, (pb->seekable & AVIO_SEEKABLE_NORMAL) ? AV_LOG_ERROR : AV_LOG_INFO, "Unable to seek back to the start\n");
3102 }
3103 
3105 {
3106  MpegTSContext *ts = s->priv_data;
3107  AVIOContext *pb = s->pb;
3108  int64_t pos, probesize = s->probesize;
3109  int64_t seekback = FFMAX(s->probesize, (int64_t)ts->resync_size + PROBE_PACKET_MAX_BUF);
3110 
3112 
3113  if (ffio_ensure_seekback(pb, seekback) < 0)
3114  av_log(s, AV_LOG_WARNING, "Failed to allocate buffers for seekback\n");
3115 
3116  pos = avio_tell(pb);
3118  if (ts->raw_packet_size <= 0) {
3119  av_log(s, AV_LOG_WARNING, "Could not detect TS packet size, defaulting to non-FEC/DVHS\n");
3121  }
3122  ts->stream = s;
3123  ts->auto_guess = 0;
3124 
3125  if (s->iformat == &ff_mpegts_demuxer) {
3126  /* normal demux */
3127 
3128  /* first do a scan to get all the services */
3129  seek_back(s, pb, pos);
3130 
3134 
3135  handle_packets(ts, probesize / ts->raw_packet_size);
3136  /* if could not find service, enable auto_guess */
3137 
3138  ts->auto_guess = 1;
3139 
3140  av_log(ts->stream, AV_LOG_TRACE, "tuning done\n");
3141 
3142  s->ctx_flags |= AVFMTCTX_NOHEADER;
3143  } else {
3144  AVStream *st;
3145  int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
3146  int64_t pcrs[2], pcr_h;
3147  uint8_t packet[TS_PACKET_SIZE];
3148  const uint8_t *data;
3149 
3150  /* only read packets */
3151 
3152  st = avformat_new_stream(s, NULL);
3153  if (!st)
3154  return AVERROR(ENOMEM);
3155  avpriv_set_pts_info(st, 60, 1, 27000000);
3158 
3159  /* we iterate until we find two PCRs to estimate the bitrate */
3160  pcr_pid = -1;
3161  nb_pcrs = 0;
3162  nb_packets = 0;
3163  for (;;) {
3164  ret = read_packet(s, packet, ts->raw_packet_size, &data);
3165  if (ret < 0)
3166  return ret;
3167  pid = AV_RB16(data + 1) & 0x1fff;
3168  if ((pcr_pid == -1 || pcr_pid == pid) &&
3169  parse_pcr(&pcr_h, &pcr_l, data) == 0) {
3171  pcr_pid = pid;
3172  pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
3173  nb_pcrs++;
3174  if (nb_pcrs >= 2) {
3175  if (pcrs[1] - pcrs[0] > 0) {
3176  /* the difference needs to be positive to make sense for bitrate computation */
3177  break;
3178  } else {
3179  av_log(ts->stream, AV_LOG_WARNING, "invalid pcr pair %"PRId64" >= %"PRId64"\n", pcrs[0], pcrs[1]);
3180  pcrs[0] = pcrs[1];
3181  nb_pcrs--;
3182  }
3183  }
3184  } else {
3186  }
3187  nb_packets++;
3188  }
3189 
3190  /* NOTE1: the bitrate is computed without the FEC */
3191  /* NOTE2: it is only the bitrate of the start of the stream */
3192  ts->pcr_incr = pcrs[1] - pcrs[0];
3193  ts->cur_pcr = pcrs[0] - ts->pcr_incr * (nb_packets - 1);
3194  s->bit_rate = TS_PACKET_SIZE * 8 * 27000000LL / ts->pcr_incr;
3195  st->codecpar->bit_rate = s->bit_rate;
3196  st->start_time = ts->cur_pcr;
3197  av_log(ts->stream, AV_LOG_TRACE, "start=%0.3f pcr=%0.3f incr=%"PRId64"\n",
3198  st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
3199  }
3200 
3201  seek_back(s, pb, pos);
3202  return 0;
3203 }
3204 
3205 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
3206 
3208 {
3209  MpegTSContext *ts = s->priv_data;
3210  int ret, i;
3211  int64_t pcr_h, next_pcr_h, pos;
3212  int pcr_l, next_pcr_l;
3213  uint8_t pcr_buf[12];
3214  const uint8_t *data;
3215 
3216  if ((ret = av_new_packet(pkt, TS_PACKET_SIZE)) < 0)
3217  return ret;
3219  pkt->pos = avio_tell(s->pb);
3220  if (ret < 0) {
3221  return ret;
3222  }
3223  if (data != pkt->data)
3224  memcpy(pkt->data, data, TS_PACKET_SIZE);
3226  if (ts->mpeg2ts_compute_pcr) {
3227  /* compute exact PCR for each packet */
3228  if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
3229  /* we read the next PCR (XXX: optimize it by using a bigger buffer */
3230  pos = avio_tell(s->pb);
3231  for (i = 0; i < MAX_PACKET_READAHEAD; i++) {
3232  avio_seek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
3233  avio_read(s->pb, pcr_buf, 12);
3234  if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
3235  /* XXX: not precise enough */
3236  ts->pcr_incr =
3237  ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
3238  (i + 1);
3239  break;
3240  }
3241  }
3242  avio_seek(s->pb, pos, SEEK_SET);
3243  /* no next PCR found: we use previous increment */
3244  ts->cur_pcr = pcr_h * 300 + pcr_l;
3245  }
3246  pkt->pts = ts->cur_pcr;
3247  pkt->duration = ts->pcr_incr;
3248  ts->cur_pcr += ts->pcr_incr;
3249  }
3250  pkt->stream_index = 0;
3251  return 0;
3252 }
3253 
3255 {
3256  MpegTSContext *ts = s->priv_data;
3257  int ret, i;
3258 
3259  pkt->size = -1;
3260  ts->pkt = pkt;
3261  ret = handle_packets(ts, 0);
3262  if (ret < 0) {
3263  av_packet_unref(ts->pkt);
3264  /* flush pes data left */
3265  for (i = 0; i < NB_PID_MAX; i++)
3266  if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
3267  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
3268  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
3269  ret = new_pes_packet(pes, pkt);
3270  if (ret < 0)
3271  return ret;
3272  pes->state = MPEGTS_SKIP;
3273  ret = 0;
3274  break;
3275  }
3276  }
3277  }
3278 
3279  if (!ret && pkt->size < 0)
3281  return ret;
3282 }
3283 
3284 static void mpegts_free(MpegTSContext *ts)
3285 {
3286  int i;
3287 
3288  clear_programs(ts);
3289 
3290  for (i = 0; i < FF_ARRAY_ELEMS(ts->pools); i++)
3291  av_buffer_pool_uninit(&ts->pools[i]);
3292 
3293  for (i = 0; i < NB_PID_MAX; i++)
3294  if (ts->pids[i])
3295  mpegts_close_filter(ts, ts->pids[i]);
3296 }
3297 
3299 {
3300  MpegTSContext *ts = s->priv_data;
3301  mpegts_free(ts);
3302  return 0;
3303 }
3304 
3305 static av_unused int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
3306  int64_t *ppos, int64_t pos_limit)
3307 {
3308  MpegTSContext *ts = s->priv_data;
3309  int64_t pos, timestamp;
3310  uint8_t buf[TS_PACKET_SIZE];
3311  int pcr_l, pcr_pid =
3312  ((PESContext *)s->streams[stream_index]->priv_data)->pcr_pid;
3313  int pos47 = ts->pos47_full % ts->raw_packet_size;
3314  pos =
3315  ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) *
3316  ts->raw_packet_size + pos47;
3317  while(pos < pos_limit) {
3318  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
3319  return AV_NOPTS_VALUE;
3320  if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
3321  return AV_NOPTS_VALUE;
3322  if (buf[0] != 0x47) {
3323  if (mpegts_resync(s, TS_PACKET_SIZE, buf) < 0)
3324  return AV_NOPTS_VALUE;
3325  pos = avio_tell(s->pb);
3326  continue;
3327  }
3328  if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
3329  parse_pcr(&timestamp, &pcr_l, buf) == 0) {
3330  *ppos = pos;
3331  return timestamp;
3332  }
3333  pos += ts->raw_packet_size;
3334  }
3335 
3336  return AV_NOPTS_VALUE;
3337 }
3338 
3339 static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index,
3340  int64_t *ppos, int64_t pos_limit)
3341 {
3342  MpegTSContext *ts = s->priv_data;
3343  AVPacket *pkt;
3344  int64_t pos;
3345  int pos47 = ts->pos47_full % ts->raw_packet_size;
3346  pos = ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) * ts->raw_packet_size + pos47;
3348  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
3349  return AV_NOPTS_VALUE;
3350  pkt = av_packet_alloc();
3351  if (!pkt)
3352  return AV_NOPTS_VALUE;
3353  while(pos < pos_limit) {
3354  int ret = av_read_frame(s, pkt);
3355  if (ret < 0) {
3356  av_packet_free(&pkt);
3357  return AV_NOPTS_VALUE;
3358  }
3359  if (pkt->dts != AV_NOPTS_VALUE && pkt->pos >= 0) {
3361  av_add_index_entry(s->streams[pkt->stream_index], pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
3362  if (pkt->stream_index == stream_index && pkt->pos >= *ppos) {
3363  int64_t dts = pkt->dts;
3364  *ppos = pkt->pos;
3365  av_packet_free(&pkt);
3366  return dts;
3367  }
3368  }
3369  pos = pkt->pos;
3371  }
3372 
3373  av_packet_free(&pkt);
3374  return AV_NOPTS_VALUE;
3375 }
3376 
3377 /**************************************************************/
3378 /* parsing functions - called from other demuxers such as RTP */
3379 
3381 {
3382  MpegTSContext *ts;
3383 
3384  ts = av_mallocz(sizeof(MpegTSContext));
3385  if (!ts)
3386  return NULL;
3387  /* no stream case, currently used by RTP */
3389  ts->max_packet_size = 2048000;
3390  ts->stream = s;
3391  ts->auto_guess = 1;
3392 
3396 
3397  return ts;
3398 }
3399 
3400 /* return the consumed length if a packet was output, or -1 if no
3401  * packet is output */
3403  const uint8_t *buf, int len)
3404 {
3405  int len1;
3406 
3407  len1 = len;
3408  ts->pkt = pkt;
3409  for (;;) {
3410  ts->stop_parse = 0;
3411  if (len < TS_PACKET_SIZE)
3412  return AVERROR_INVALIDDATA;
3413  if (buf[0] != 0x47) {
3414  buf++;
3415  len--;
3416  } else {
3417  handle_packet(ts, buf, len1 - len + TS_PACKET_SIZE);
3418  buf += TS_PACKET_SIZE;
3419  len -= TS_PACKET_SIZE;
3420  if (ts->stop_parse == 1)
3421  break;
3422  }
3423  }
3424  return len1 - len;
3425 }
3426 
3428 {
3429  mpegts_free(ts);
3430  av_free(ts);
3431 }
3432 
3434  .name = "mpegts",
3435  .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
3436  .priv_data_size = sizeof(MpegTSContext),
3443  .priv_class = &mpegts_class,
3444 };
3445 
3447  .name = "mpegtsraw",
3448  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"),
3449  .priv_data_size = sizeof(MpegTSContext),
3455  .priv_class = &mpegtsraw_class,
3456 };
parse_MP4DecConfigDescrTag
static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1555
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:910
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
parse_mp4_descr_arr
static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1495
new_pes_packet
static int new_pes_packet(PESContext *pes, AVPacket *pkt)
Definition: mpegts.c:1010
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:268
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:792
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:76
MP4DescrParseContext::descr_count
int descr_count
Definition: mpegts.c:1459
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:340
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:240
MpegTSFilter::discard
int discard
Definition: mpegts.c:104
Program::nb_streams
unsigned int nb_streams
Definition: mpegts.c:123
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:664
r
const char * r
Definition: vf_curves.c:126
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
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: options.c:243
MAX_LEVEL
#define MAX_LEVEL
Definition: mpegts.c:1453
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:179
PAT_PID
#define PAT_PID
Definition: mpegts.h:37
AV_OPT_FLAG_READONLY
#define AV_OPT_FLAG_READONLY
The option may not be set through the AVOptions API, only read.
Definition: opt.h:294
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:58
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:426
mpegts.h
AVProgram::nb_stream_indexes
unsigned int nb_stream_indexes
Definition: avformat.h:1033
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:216
out
FILE * out
Definition: movenc.c:54
ff_parse_pes_pts
static int64_t ff_parse_pes_pts(const uint8_t *buf)
Parse MPEG-PES five-byte timestamp.
Definition: mpeg.h:68
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:100
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:192
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:693
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:261
AVStream::priv_data
void * priv_data
Definition: avformat.h:863
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:3402
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:3719
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:909
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:363
STREAM_ID_EMM_STREAM
#define STREAM_ID_EMM_STREAM
Definition: mpegts.h:150
mpegts_close_filter
static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
Definition: mpegts.c:558
STREAM_ID_PADDING_STREAM
#define STREAM_ID_PADDING_STREAM
Definition: mpegts.h:145
AV_CODEC_ID_DIRAC
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:168
STREAM_ID_PROGRAM_STREAM_MAP
#define STREAM_ID_PROGRAM_STREAM_MAP
Definition: mpegts.h:143
SLConfigDescr::au_seq_num_len
int au_seq_num_len
Definition: mpegts.h:187
Program::pmt_found
int pmt_found
have we found pmt for this program
Definition: mpegts.c:127
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:256
PESContext::dts
int64_t dts
Definition: mpegts.c:266
METADATA_types
static const StreamType METADATA_types[]
Definition: mpegts.c:876
av_unused
#define av_unused
Definition: attributes.h:131
MP4DescrParseContext::max_descr_count
int max_descr_count
Definition: mpegts.c:1460
Stream::stream_identifier
int stream_identifier
Definition: mpegts.c:114
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
MpegTSContext::skip_changes
int skip_changes
Definition: mpegts.c:159
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1172
ff_mp4_read_dec_config_descr
int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext *pb)
Definition: isom.c:328
mpegts_find_stream_type
static void mpegts_find_stream_type(AVStream *st, uint32_t stream_type, const StreamType *types)
Definition: mpegts.c:892
MpegTSContext::auto_guess
int auto_guess
if true, all pids are analyzed to find streams
Definition: mpegts.c:140
AVPacket::data
uint8_t * data
Definition: packet.h:374
AV_CODEC_ID_DVB_TELETEXT
@ AV_CODEC_ID_DVB_TELETEXT
Definition: codec_id.h:553
clear_avprogram
static void clear_avprogram(MpegTSContext *ts, unsigned int programid)
Definition: mpegts.c:287
CHECK_BLOCK
#define CHECK_BLOCK
AVOption
AVOption.
Definition: opt.h:251
MpegTSSectionFilter
Definition: mpegts.c:86
MPEGTS_SECTION
@ MPEGTS_SECTION
Definition: mpegts.c:68
getstr8
static char * getstr8(const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:694
MpegTSSectionFilter::section_h_size
int section_h_size
Definition: mpegts.c:88
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:108
HLS_SAMPLE_ENC_types
static const StreamType HLS_SAMPLE_ENC_types[]
Definition: mpegts.c:851
MpegTSState
MpegTSState
Definition: mpegts.c:237
MP4SLDescrTag
#define MP4SLDescrTag
Definition: isom.h:342
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
MP4DescrParseContext::s
AVFormatContext * s
Definition: mpegts.c:1455
buffer_pool_get
static AVBufferRef * buffer_pool_get(MpegTSContext *ts, int size)
Definition: mpegts.c:1128
PES_HEADER_SIZE
#define PES_HEADER_SIZE
Definition: mpegts.c:247
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:551
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1270
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:66
mathematics.h
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
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:84
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1455
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:704
Stream::idx
int idx
Definition: mpegts.c:113
AV_CODEC_ID_HDMV_PGS_SUBTITLE
@ AV_CODEC_ID_HDMV_PGS_SUBTITLE
Definition: codec_id.h:552
ff_read_frame_flush
void ff_read_frame_flush(AVFormatContext *s)
Flush the frame reader.
Definition: seek.c:720
add_pid_to_program
static void add_pid_to_program(struct Program *p, unsigned int pid)
Definition: mpegts.c:333
PESContext::pts
int64_t pts
Definition: mpegts.c:266
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:484
FFIOContext
Definition: avio_internal.h:29
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:493
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:73
MpegTSContext::nb_prg
unsigned int nb_prg
structure to keep track of Program->pids mapping
Definition: mpegts.c:173
MpegTSPESFilter::pes_cb
PESCallback * pes_cb
Definition: mpegts.c:78
Program::streams
struct Stream streams[MAX_STREAMS_PER_PROGRAM]
Definition: mpegts.c:124
AV_CODEC_ID_BIN_DATA
@ AV_CODEC_ID_BIN_DATA
Definition: codec_id.h:586
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:252
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:705
SectionHeader::id
uint16_t id
Definition: mpegts.c:648
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:302
SLConfigDescr::use_idle
int use_idle
Definition: mpegts.h:180
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:371
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:63
mpegtsraw_class
static const AVClass mpegtsraw_class
Definition: mpegts.c:228
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:325
PESContext::state
enum MpegTSState state
Definition: mpegts.c:258
MpegTSFilter::pes_filter
MpegTSPESFilter pes_filter
Definition: mpegts.c:107
METADATA_DESCRIPTOR
#define METADATA_DESCRIPTOR
Definition: mpegts.h:164
SLConfigDescr::inst_bitrate_len
int inst_bitrate_len
Definition: mpegts.h:185
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:785
REGISTRATION_DESCRIPTOR
#define REGISTRATION_DESCRIPTOR
Definition: mpegts.h:159
mpegts_read_close
static int mpegts_read_close(AVFormatContext *s)
Definition: mpegts.c:3298
mpegts_raw_read_packet
static int mpegts_raw_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegts.c:3207
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:349
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:416
MP4ODescrTag
#define MP4ODescrTag
Definition: isom.h:337
PESCallback
int PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos)
Definition: mpegts.c:74
VIDEO_STREAM_DESCRIPTOR
#define VIDEO_STREAM_DESCRIPTOR
Definition: mpegts.h:158
STREAM_ID_DSMCC_STREAM
#define STREAM_ID_DSMCC_STREAM
Definition: mpegts.h:151
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:120
pat_cb
static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:2536
GetBitContext
Definition: get_bits.h:107
Program::nb_pids
unsigned int nb_pids
Definition: mpegts.c:121
SLConfigDescr::use_padding
int use_padding
Definition: mpegts.h:178
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:1666
AVProgram::discard
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:1031
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:808
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:500
FFStream::avctx
struct AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:224
SectionHeader::last_sec_num
uint8_t last_sec_num
Definition: mpegts.c:652
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:338
PESContext::sl
SLConfigDescr sl
Definition: mpegts.c:270
SLConfigDescr::use_rand_acc_pt
int use_rand_acc_pt
Definition: mpegts.h:177
SDT_PID
#define SDT_PID
Definition: mpegts.h:43
av_new_program
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: avformat.c:305
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:255
SLConfigDescr::timestamp_len
int timestamp_len
Definition: mpegts.h:182
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:24
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:547
PESContext::sub_st
AVStream * sub_st
stream for the embedded AC3 stream in HDMV TrueHD
Definition: mpegts.c:257
ff_mp4_parse_es_descr
void ff_mp4_parse_es_descr(AVIOContext *pb, int *es_id)
Definition: isom.c:303
SectionHeader::current_next
uint8_t current_next
Definition: mpegts.c:650
MpegTSContext::merge_pmt_versions
int merge_pmt_versions
Definition: mpegts.c:166
AV_DISPOSITION_CLEAN_EFFECTS
#define AV_DISPOSITION_CLEAN_EFFECTS
The audio stream contains music and sound effects without voice.
Definition: avformat.h:761
PESContext::header
uint8_t header[MAX_PES_HEADER_SIZE]
Definition: mpegts.c:268
avassert.h
MPEGTS_OPTIONS
#define MPEGTS_OPTIONS
Definition: mpegts.c:185
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:782
MpegTSContext::pos47_full
int64_t pos47_full
Definition: mpegts.c:137
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:3427
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVInputFormat
Definition: avformat.h:546
StreamType::codec_id
enum AVCodecID codec_id
Definition: mpegts.c:794
PESContext
Definition: mpegts.c:250
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:430
Mp4Descr::sl
SLConfigDescr sl
Definition: mpegts.h:195
opus_coupled_stream_cnt
static const uint8_t opus_coupled_stream_cnt[9]
Definition: mpegts.c:1792
AVFormatContext::ctx_flags
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1153
AVProgram::id
int id
Definition: avformat.h:1029
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:1811
MpegTSContext::pools
AVBufferPool * pools[32]
Definition: mpegts.c:182
parse_pcr
static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet)
Definition: mpegts.c:3069
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:133
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:594
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
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: avpacket.c:97
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:3305
mpegts_class
static const AVClass mpegts_class
Definition: mpegts.c:209
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1269
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:551
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
FF_PROFILE_ARIB_PROFILE_C
#define FF_PROFILE_ARIB_PROFILE_C
Definition: avcodec.h:1713
bits
uint8_t bits
Definition: vp3data.h:128
SLConfigDescr::degr_prior_len
int degr_prior_len
Definition: mpegts.h:186
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1590
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:487
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:55
PES_START_SIZE
#define PES_START_SIZE
Definition: mpegts.c:246
MpegTSContext::resync_size
int resync_size
Definition: mpegts.c:165
channels
channels
Definition: aptx.h:31
get_bits.h
SectionHeader::sec_num
uint8_t sec_num
Definition: mpegts.c:651
STREAM_ID_TYPE_E_STREAM
#define STREAM_ID_TYPE_E_STREAM
Definition: mpegts.h:152
nb_streams
static int nb_streams
Definition: ffprobe.c:315
PESContext::stream_type
int stream_type
Definition: mpegts.c:253
parse_MP4IODescrTag
static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1506
PMT_TID
#define PMT_TID
Definition: mpegts.h:81
skip_identical
static int skip_identical(const SectionHeader *h, MpegTSSectionFilter *tssf)
Definition: mpegts.c:655
opus_stream_cnt
static const uint8_t opus_stream_cnt[9]
Definition: mpegts.c:1796
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:53
MPEGTS_SKIP
@ MPEGTS_SKIP
Definition: mpegts.c:242
MpegTSPESFilter::opaque
void * opaque
Definition: mpegts.c:79
get8
static int get8(const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:666
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:379
AV_CODEC_ID_ARIB_CAPTION
@ AV_CODEC_ID_ARIB_CAPTION
Definition: codec_id.h:571
if
if(ret)
Definition: filter_design.txt:179
MpegTSContext::cur_pcr
int64_t cur_pcr
used to estimate the exact PCR
Definition: mpegts.c:148
clear_programs
static void clear_programs(MpegTSContext *ts)
Definition: mpegts.c:311
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:387
MP4ESDescrTag
#define MP4ESDescrTag
Definition: isom.h:339
AV_CODEC_ID_AVS3
@ AV_CODEC_ID_AVS3
Definition: codec_id.h:248
MP4DescrParseContext::active_descr
Mp4Descr * active_descr
Definition: mpegts.c:1458
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:76
AVFormatContext
Format I/O context.
Definition: avformat.h:1104
FMC_DESCRIPTOR
#define FMC_DESCRIPTOR
Definition: mpegts.h:163
internal.h
MpegTSContext::pcr_incr
int64_t pcr_incr
used to estimate the exact PCR
Definition: mpegts.c:149
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:357
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:861
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:56
av_program_add_stream_index
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
Definition: avformat.c:336
AVDOVIDecoderConfigurationRecord::dv_bl_signal_compatibility_id
uint8_t dv_bl_signal_compatibility_id
Definition: dovi_meta.h:60
MPEGTS_HEADER
@ MPEGTS_HEADER
Definition: mpegts.c:238
MpegTSSectionFilter::crc
unsigned crc
Definition: mpegts.c:90
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:153
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1055
isom.h
AV_CODEC_ID_TIMED_ID3
@ AV_CODEC_ID_TIMED_ID3
Definition: codec_id.h:585
MpegTSContext::current_pid
int current_pid
Definition: mpegts.c:179
MpegTSSectionFilter::section_index
int section_index
Definition: mpegts.c:87
MpegTSContext::last_pos
int64_t last_pos
to detect seek
Definition: mpegts.c:157
Mp4Descr::es_id
int es_id
Definition: mpegts.h:192
MpegTSFilter::es_id
int es_id
Definition: mpegts.c:101
MPEGTS_PESHEADER
@ MPEGTS_PESHEADER
Definition: mpegts.c:239
DESC_types
static const StreamType DESC_types[]
Definition: mpegts.c:883
PESContext::extended_stream_id
int extended_stream_id
Definition: mpegts.c:264
av_stream_add_side_data
int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as stream side data.
Definition: avformat.c:156
Mp4Descr::dec_config_descr_len
int dec_config_descr_len
Definition: mpegts.h:193
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:92
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:378
eit_cb
static void eit_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:2623
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:105
mpegts_open_pcr_filter
static MpegTSFilter * mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid)
Definition: mpegts.c:553
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:649
seek_back
static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos)
Definition: mpegts.c:3095
SLConfigDescr::ocr_len
int ocr_len
Definition: mpegts.h:183
AVProgram::stream_index
unsigned int * stream_index
Definition: avformat.h:1032
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:918
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:592
add_pes_stream
static PESContext * add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
Definition: mpegts.c:1429
MpegTSFilterType
MpegTSFilterType
Definition: mpegts.c:66
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
StreamType
Definition: mpegts.c:791
AV_CODEC_ID_SMPTE_KLV
@ AV_CODEC_ID_SMPTE_KLV
Definition: codec_id.h:583
ff_mp4_read_descr
int ff_mp4_read_descr(AVFormatContext *fc, AVIOContext *pb, int *tag)
Definition: isom.c:294
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:510
SLConfigDescr::packet_seq_num_len
int packet_seq_num_len
Definition: mpegts.h:188
mpegts_open_pes_filter
static MpegTSFilter * mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid, PESCallback *pes_cb, void *opaque)
Definition: mpegts.c:537
PESContext::ts
MpegTSContext * ts
Definition: mpegts.c:254
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:1465
MAX_PES_HEADER_SIZE
#define MAX_PES_HEADER_SIZE
Definition: mpegts.c:248
MAX_PACKET_READAHEAD
#define MAX_PACKET_READAHEAD
Definition: mpegts.c:3205
MAX_PIDS_PER_PROGRAM
#define MAX_PIDS_PER_PROGRAM
Definition: mpegts.c:118
MpegTSSectionFilter::end_of_section_reached
unsigned int end_of_section_reached
Definition: mpegts.c:94
index
int index
Definition: gxfenc.c:89
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:1519
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:1141
SLConfigDescr::use_au_start
int use_au_start
Definition: mpegts.h:175
new_data_packet
static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt)
Definition: mpegts.c:1003
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:80
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:838
MPEGTS_PES
@ MPEGTS_PES
Definition: mpegts.c:67
f
f
Definition: af_crystalizer.c:122
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
AVMediaType
AVMediaType
Definition: avutil.h:199
MP4DescrParseContext::descr
Mp4Descr * descr
Definition: mpegts.c:1457
AVPacket::size
int size
Definition: packet.h:375
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:114
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:267
MpegTSContext::max_packet_size
int max_packet_size
Definition: mpegts.c:167
FFStream
Definition: internal.h:197
SectionHeader::tid
uint8_t tid
Definition: mpegts.c:647
reset_pes_packet_state
static void reset_pes_packet_state(PESContext *pes)
Definition: mpegts.c:994
FFIOContext::pub
AVIOContext pub
Definition: avio_internal.h:30
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:444
Program
Definition: mpegts.c:119
MpegTSContext
Definition: mpegts.c:130
MpegTSFilter
Definition: mpegts.c:99
size
int size
Definition: twinvq_data.h:10344
MPEGTS_PAYLOAD
@ MPEGTS_PAYLOAD
Definition: mpegts.c:241
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:135
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:2965
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:164
STREAM_ID_PRIVATE_STREAM_2
#define STREAM_ID_PRIVATE_STREAM_2
Definition: mpegts.h:146
SLConfigDescr::use_au_end
int use_au_end
Definition: mpegts.h:176
MpegTSSectionFilter::check_crc
unsigned int check_crc
Definition: mpegts.c:93
MpegTSContext::skip_clear
int skip_clear
Definition: mpegts.c:160
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:122
mpegts_get_dts
static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: mpegts.c:3339
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:3254
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:371
parse_MP4ESDescrTag
static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1533
buffer.h
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:753
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:624
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:223
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:1047
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:82
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:335
PESContext::pid
int pid
Definition: mpegts.c:251
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:62
version
version
Definition: libkvazaar.c:314
FFStream::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: internal.h:384
handle_packet
static int handle_packet(MpegTSContext *ts, const uint8_t *packet, int64_t pos)
Definition: mpegts.c:2767
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:1485
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:432
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
FF_PROFILE_ARIB_PROFILE_A
#define FF_PROFILE_ARIB_PROFILE_A
Definition: avcodec.h:1712
SectionHeader
Definition: mpegts.c:646
ISO_639_LANGUAGE_DESCRIPTOR
#define ISO_639_LANGUAGE_DESCRIPTOR
Definition: mpegts.h:160
MP4DescrParseContext::pb
FFIOContext pb
Definition: mpegts.c:1456
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:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
avio_internal.h
IOD_DESCRIPTOR
#define IOD_DESCRIPTOR
Definition: mpegts.h:161
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:54
PESContext::data_index
int data_index
Definition: mpegts.c:260
AV_CODEC_ID_SMPTE_2038
@ AV_CODEC_ID_SMPTE_2038
Definition: codec_id.h:587
internal.h
get_program
static struct Program * get_program(MpegTSContext *ts, unsigned int programid)
Definition: mpegts.c:276
PAT_TID
#define PAT_TID
Definition: mpegts.h:79
ff_mpegts_demuxer
const AVInputFormat ff_mpegts_demuxer
Definition: mpegts.c:3433
MpegTSContext::pids
MpegTSFilter * pids[NB_PID_MAX]
filters for various streams specified by PMT + for the PAT and PMT
Definition: mpegts.c:178
PESContext::pes_header_size
int pes_header_size
Definition: mpegts.c:263
ffio_init_context
void ffio_init_context(FFIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:81
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:679
parse_section_header
static int parse_section_header(SectionHeader *h, const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:761
MpegTSContext::epg_stream
AVStream * epg_stream
Definition: mpegts.c:181
common.h
AV_CODEC_ID_EPG
@ AV_CODEC_ID_EPG
Definition: codec_id.h:578
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:664
mpegts_resync
static int mpegts_resync(AVFormatContext *s, int seekback, const uint8_t *current_packet)
Definition: mpegts.c:2897
MpegTSContext::crc_validity
int8_t crc_validity[NB_PID_MAX]
Definition: mpegts.c:176
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:282
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
PESContext::st
AVStream * st
Definition: mpegts.c:256
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:254
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1028
handle_packets
static int handle_packets(MpegTSContext *ts, int64_t nb_packets)
Definition: mpegts.c:2973
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:122
demux.h
MpegTSContext::prg
struct Program * prg
Definition: mpegts.c:174
AV_DISPOSITION_DEPENDENT
#define AV_DISPOSITION_DEPENDENT
The audio stream is intended to be mixed with another stream before presentation.
Definition: avformat.h:804
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:77
SLConfigDescr::au_len
int au_len
Definition: mpegts.h:184
avcodec.h
MpegTSFilter::last_pcr
int64_t last_pcr
Definition: mpegts.c:103
MpegTSSectionFilter::last_crc
unsigned last_crc
Definition: mpegts.c:91
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:907
mid_pred
#define mid_pred
Definition: mathops.h:98
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
The stream is intended for visually impaired audiences.
Definition: avformat.h:757
MP4DescrParseContext
Definition: mpegts.c:1454
tag
uint32_t tag
Definition: movenc.c:1709
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:850
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:838
MpegTSSectionFilter::last_ver
int last_ver
Definition: mpegts.c:89
AVFormatContext::ts_id
int ts_id
Transport stream id.
Definition: avformat.h:1443
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:284
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:252
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:194
SLConfigDescr::use_timestamps
int use_timestamps
Definition: mpegts.h:179
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:767
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:1682
scte_data_cb
static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1763
pos
unsigned int pos
Definition: spdifenc.c:413
avformat.h
dovi_meta.h
m4sl_cb
static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1698
dict.h
AV_DISPOSITION_DESCRIPTIONS
#define AV_DISPOSITION_DESCRIPTIONS
The subtitle stream contains a textual description of the video content.
Definition: avformat.h:793
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:844
R8_CHECK_CLIP_MAX
#define R8_CHECK_CLIP_MAX(dst, maxv)
MpegTSFilter::u
union MpegTSFilter::@302 u
probe
static int probe(const AVProbeData *p)
Definition: act.c:38
mpegts_probe
static int mpegts_probe(const AVProbeData *p)
Definition: mpegts.c:3026
PESContext::PES_packet_length
int PES_packet_length
Definition: mpegts.c:262
AV_OPT_FLAG_EXPORT
#define AV_OPT_FLAG_EXPORT
The option is intended for exporting values to the caller.
Definition: opt.h:289
clear_program
static void clear_program(struct Program *p)
Definition: mpegts.c:302
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: avpacket.c:230
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:59
SL_DESCRIPTOR
#define SL_DESCRIPTOR
Definition: mpegts.h:162
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
PESContext::stream_id
uint8_t stream_id
Definition: mpegts.c:265
parse_MP4SLDescrTag
static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1569
avpriv_mpegts_parse_open
MpegTSContext * avpriv_mpegts_parse_open(AVFormatContext *s)
Definition: mpegts.c:3380
PESContext::buffer
AVBufferRef * buffer
Definition: mpegts.c:269
CHECK_COUNT
#define CHECK_COUNT
AVDOVIDecoderConfigurationRecord::rpu_present_flag
uint8_t rpu_present_flag
Definition: dovi_meta.h:57
mpegts_free
static void mpegts_free(MpegTSContext *ts)
Definition: mpegts.c:3284
HDMV_types
static const StreamType HDMV_types[]
Definition: mpegts.c:822
AVDOVIDecoderConfigurationRecord::el_present_flag
uint8_t el_present_flag
Definition: dovi_meta.h:58
AVPacket::stream_index
int stream_index
Definition: packet.h:376
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:339
SLConfigDescr::timestamp_res
int timestamp_res
Definition: mpegts.h:181
ISO_types
static const StreamType ISO_types[]
Definition: mpegts.c:797
AVDOVIDecoderConfigurationRecord::dv_version_minor
uint8_t dv_version_minor
Definition: dovi_meta.h:54
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:29
hex_dump_debug
#define hex_dump_debug(class, buf, size)
Definition: internal.h:41
read_sl_header
static int read_sl_header(PESContext *pes, SLConfigDescr *sl, const uint8_t *buf, int buf_size)
Definition: mpegts.c:1057
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:481
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
MpegTSContext::pkt
AVPacket * pkt
packet containing Audio/Video data
Definition: mpegts.c:155
mpegts_read_header
static int mpegts_read_header(AVFormatContext *s)
Definition: mpegts.c:3104
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
MPEGTS_PCR
@ MPEGTS_PCR
Definition: mpegts.c:69
FFStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:266
Program::id
unsigned int id
Definition: mpegts.c:120
STREAM_ID_ECM_STREAM
#define STREAM_ID_ECM_STREAM
Definition: mpegts.h:149
MpegTSSectionFilter::opaque
void * opaque
Definition: mpegts.c:96
PESContext::merged_st
int merged_st
Definition: mpegts.c:271
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:62
MAX_STREAMS_PER_PROGRAM
#define MAX_STREAMS_PER_PROGRAM
Definition: mpegts.c:117
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
STREAM_ID_PROGRAM_STREAM_DIRECTORY
#define STREAM_ID_PROGRAM_STREAM_DIRECTORY
Definition: mpegts.h:155
MpegTSFilter::last_cc
int last_cc
Definition: mpegts.c:102
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:86
MpegTSContext::scan_all_pmts
int scan_all_pmts
Definition: mpegts.c:163
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:394
MP4DescrParseContext::predefined_SLConfigDescriptor_seen
int predefined_SLConfigDescriptor_seen
Definition: mpegts.c:1462
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
Stream
Definition: mpegts.c:112
d
d
Definition: ffmpeg_filter.c:354
MP4DescrParseContext::level
int level
Definition: mpegts.c:1461
bytestream.h
FFStream::stream_identifier
int stream_identifier
Stream Identifier This is the MPEG-TS stream identifier +1 0 means unknown.
Definition: internal.h:400
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:688
MpegTSContext::skip_unknown_pmt
int skip_unknown_pmt
Definition: mpegts.c:161
raw_options
static const AVOption raw_options[]
Definition: mpegts.c:216
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:241
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
opus_channel_map
static const uint8_t opus_channel_map[8][8]
Definition: mpegts.c:1800
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:91
Program::pids
unsigned int pids[MAX_PIDS_PER_PROGRAM]
Definition: mpegts.c:122
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
ff_mpegtsraw_demuxer
const AVInputFormat ff_mpegtsraw_demuxer
Definition: mpegts.c:3446
parse_mp4_descr
static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len, int target_tag)
Definition: mpegts.c:1612
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:569
TS_PACKET_SIZE
#define TS_PACKET_SIZE
Definition: mpegts.h:29
MpegTSSectionFilter::section_cb
SectionCallback * section_cb
Definition: mpegts.c:95
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
PROBE_PACKET_MARGIN
#define PROBE_PACKET_MARGIN
Definition: mpegts.c:64
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:279
get_ts64
static uint64_t get_ts64(GetBitContext *gb, int bits)
Definition: mpegts.c:1050
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:887
get_packet_size
static int get_packet_size(AVFormatContext *s)
Definition: mpegts.c:608
analyze
static int analyze(const uint8_t *buf, int size, int packet_size, int probe)
Definition: mpegts.c:579
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:420
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:48
read_packet
static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size, const uint8_t **data)
Definition: mpegts.c:2940
MpegTSContext::mpeg2ts_compute_pcr
int mpeg2ts_compute_pcr
compute exact PCR for each transport stream packet
Definition: mpegts.c:143
REGD_types
static const StreamType REGD_types[]
Definition: mpegts.c:859
MISC_types
static const StreamType MISC_types[]
Definition: mpegts.c:844
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:317
options
static const AVOption options[]
Definition: mpegts.c:188
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:267
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AVProgram::pcr_pid
int pcr_pid
Definition: avformat.h:1038
FFStream::pts_wrap_reference
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: internal.h:323
Mp4Descr
Definition: mpegts.h:191
SLConfigDescr
Definition: mpegts.h:174
avio_read_partial
int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:705
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:2677
MpegTSContext::fix_teletext_pts
int fix_teletext_pts
fix dvb teletext pts
Definition: mpegts.c:146
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:238
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:52
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:367
AV_CODEC_ID_SCTE_35
@ AV_CODEC_ID_SCTE_35
Contain timestamp estimated through PCR of program stream.
Definition: codec_id.h:577
StreamType::codec_type
enum AVMediaType codec_type
Definition: mpegts.c:793