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