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