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 static const StreamType REGD_types[] = {
843  { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
844  { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
845  { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M },
846  { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
847  { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
848  { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
849  { MKTAG('E', 'A', 'C', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 },
850  { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC },
851  { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
852  { MKTAG('I', 'D', '3', ' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
853  { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },
854  { MKTAG('O', 'p', 'u', 's'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_OPUS },
855  { 0 },
856 };
857 
858 static const StreamType METADATA_types[] = {
859  { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
860  { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
861  { 0 },
862 };
863 
864 /* descriptor present */
865 static const StreamType DESC_types[] = {
866  { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */
867  { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
870  { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
871  { 0 },
872 };
873 
875  uint32_t stream_type,
876  const StreamType *types)
877 {
878  for (; types->stream_type; types++)
879  if (stream_type == types->stream_type) {
880  if (st->codecpar->codec_type != types->codec_type ||
881  st->codecpar->codec_id != types->codec_id) {
882  st->codecpar->codec_type = types->codec_type;
883  st->codecpar->codec_id = types->codec_id;
884  st->internal->need_context_update = 1;
885  }
886  st->internal->request_probe = 0;
887  return;
888  }
889 }
890 
892  uint32_t stream_type, uint32_t prog_reg_desc)
893 {
894  int old_codec_type = st->codecpar->codec_type;
895  int old_codec_id = st->codecpar->codec_id;
896  int old_codec_tag = st->codecpar->codec_tag;
897 
898  if (avcodec_is_open(st->internal->avctx)) {
899  av_log(pes->stream, AV_LOG_DEBUG, "cannot set stream info, internal codec is open\n");
900  return 0;
901  }
902 
903  avpriv_set_pts_info(st, 33, 1, 90000);
904  st->priv_data = pes;
908  pes->st = st;
909  pes->stream_type = stream_type;
910 
911  av_log(pes->stream, AV_LOG_DEBUG,
912  "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
913  st->index, pes->stream_type, pes->pid, (char *)&prog_reg_desc);
914 
915  st->codecpar->codec_tag = pes->stream_type;
916 
918  if (pes->stream_type == 4 || pes->stream_type == 0x0f)
919  st->internal->request_probe = 50;
920  if ((prog_reg_desc == AV_RL32("HDMV") ||
921  prog_reg_desc == AV_RL32("HDPR")) &&
924  if (pes->stream_type == 0x83) {
925  // HDMV TrueHD streams also contain an AC3 coded version of the
926  // audio track - add a second stream for this
927  AVStream *sub_st;
928  // priv_data cannot be shared between streams
929  PESContext *sub_pes = av_malloc(sizeof(*sub_pes));
930  if (!sub_pes)
931  return AVERROR(ENOMEM);
932  memcpy(sub_pes, pes, sizeof(*sub_pes));
933 
934  sub_st = avformat_new_stream(pes->stream, NULL);
935  if (!sub_st) {
936  av_free(sub_pes);
937  return AVERROR(ENOMEM);
938  }
939 
940  sub_st->id = pes->pid;
941  avpriv_set_pts_info(sub_st, 33, 1, 90000);
942  sub_st->priv_data = sub_pes;
944  sub_st->codecpar->codec_id = AV_CODEC_ID_AC3;
946  sub_pes->sub_st = pes->sub_st = sub_st;
947  }
948  }
949  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
951  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
952  st->codecpar->codec_id = old_codec_id;
953  st->codecpar->codec_type = old_codec_type;
954  }
955  if ((st->codecpar->codec_id == AV_CODEC_ID_NONE ||
957  st->internal->probe_packets > 0 &&
958  stream_type == STREAM_TYPE_PRIVATE_DATA) {
962  }
963 
964  /* queue a context update if properties changed */
965  if (old_codec_type != st->codecpar->codec_type ||
966  old_codec_id != st->codecpar->codec_id ||
967  old_codec_tag != st->codecpar->codec_tag)
968  st->internal->need_context_update = 1;
969 
970  return 0;
971 }
972 
974 {
975  pes->pts = AV_NOPTS_VALUE;
976  pes->dts = AV_NOPTS_VALUE;
977  pes->data_index = 0;
978  pes->flags = 0;
979  av_buffer_unref(&pes->buffer);
980 }
981 
982 static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt)
983 {
985  pkt->data = (uint8_t *)buffer;
986  pkt->size = len;
987 }
988 
990 {
991  uint8_t *sd;
992 
994 
995  pkt->buf = pes->buffer;
996  pkt->data = pes->buffer->data;
997  pkt->size = pes->data_index;
998 
999  if (pes->total_size != MAX_PES_PAYLOAD &&
1000  pes->pes_header_size + pes->data_index != pes->total_size +
1001  PES_START_SIZE) {
1002  av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n");
1003  pes->flags |= AV_PKT_FLAG_CORRUPT;
1004  }
1005  memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1006 
1007  // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
1008  if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76)
1009  pkt->stream_index = pes->sub_st->index;
1010  else
1011  pkt->stream_index = pes->st->index;
1012  pkt->pts = pes->pts;
1013  pkt->dts = pes->dts;
1014  /* store position of first TS packet of this PES packet */
1015  pkt->pos = pes->ts_packet_pos;
1016  pkt->flags = pes->flags;
1017 
1018  pes->buffer = NULL;
1020 
1022  if (!sd)
1023  return AVERROR(ENOMEM);
1024  *sd = pes->stream_id;
1025 
1026  return 0;
1027 }
1028 
1029 static uint64_t get_ts64(GetBitContext *gb, int bits)
1030 {
1031  if (get_bits_left(gb) < bits)
1032  return AV_NOPTS_VALUE;
1033  return get_bits64(gb, bits);
1034 }
1035 
1037  const uint8_t *buf, int buf_size)
1038 {
1039  GetBitContext gb;
1040  int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;
1041  int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;
1042  int dts_flag = -1, cts_flag = -1;
1043  int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE;
1044  uint8_t buf_padded[128 + AV_INPUT_BUFFER_PADDING_SIZE];
1045  int buf_padded_size = FFMIN(buf_size, sizeof(buf_padded) - AV_INPUT_BUFFER_PADDING_SIZE);
1046 
1047  memcpy(buf_padded, buf, buf_padded_size);
1048 
1049  init_get_bits(&gb, buf_padded, buf_padded_size * 8);
1050 
1051  if (sl->use_au_start)
1052  au_start_flag = get_bits1(&gb);
1053  if (sl->use_au_end)
1054  au_end_flag = get_bits1(&gb);
1055  if (!sl->use_au_start && !sl->use_au_end)
1056  au_start_flag = au_end_flag = 1;
1057  if (sl->ocr_len > 0)
1058  ocr_flag = get_bits1(&gb);
1059  if (sl->use_idle)
1060  idle_flag = get_bits1(&gb);
1061  if (sl->use_padding)
1062  padding_flag = get_bits1(&gb);
1063  if (padding_flag)
1064  padding_bits = get_bits(&gb, 3);
1065 
1066  if (!idle_flag && (!padding_flag || padding_bits != 0)) {
1067  if (sl->packet_seq_num_len)
1069  if (sl->degr_prior_len)
1070  if (get_bits1(&gb))
1071  skip_bits(&gb, sl->degr_prior_len);
1072  if (ocr_flag)
1073  skip_bits_long(&gb, sl->ocr_len);
1074  if (au_start_flag) {
1075  if (sl->use_rand_acc_pt)
1076  get_bits1(&gb);
1077  if (sl->au_seq_num_len > 0)
1078  skip_bits_long(&gb, sl->au_seq_num_len);
1079  if (sl->use_timestamps) {
1080  dts_flag = get_bits1(&gb);
1081  cts_flag = get_bits1(&gb);
1082  }
1083  }
1084  if (sl->inst_bitrate_len)
1085  inst_bitrate_flag = get_bits1(&gb);
1086  if (dts_flag == 1)
1087  dts = get_ts64(&gb, sl->timestamp_len);
1088  if (cts_flag == 1)
1089  cts = get_ts64(&gb, sl->timestamp_len);
1090  if (sl->au_len > 0)
1091  skip_bits_long(&gb, sl->au_len);
1092  if (inst_bitrate_flag)
1093  skip_bits_long(&gb, sl->inst_bitrate_len);
1094  }
1095 
1096  if (dts != AV_NOPTS_VALUE)
1097  pes->dts = dts;
1098  if (cts != AV_NOPTS_VALUE)
1099  pes->pts = cts;
1100 
1101  if (sl->timestamp_len && sl->timestamp_res)
1103 
1104  return (get_bits_count(&gb) + 7) >> 3;
1105 }
1106 
1108 {
1110  if (!ts->pools[index]) {
1111  int pool_size = FFMIN(MAX_PES_PAYLOAD + AV_INPUT_BUFFER_PADDING_SIZE, 2 << index);
1112  ts->pools[index] = av_buffer_pool_init(pool_size, NULL);
1113  if (!ts->pools[index])
1114  return NULL;
1115  }
1116  return av_buffer_pool_get(ts->pools[index]);
1117 }
1118 
1119 /* return non zero if a packet could be constructed */
1121  const uint8_t *buf, int buf_size, int is_start,
1122  int64_t pos)
1123 {
1124  PESContext *pes = filter->u.pes_filter.opaque;
1125  MpegTSContext *ts = pes->ts;
1126  const uint8_t *p;
1127  int ret, len, code;
1128 
1129  if (!ts->pkt)
1130  return 0;
1131 
1132  if (is_start) {
1133  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
1134  ret = new_pes_packet(pes, ts->pkt);
1135  if (ret < 0)
1136  return ret;
1137  ts->stop_parse = 1;
1138  } else {
1140  }
1141  pes->state = MPEGTS_HEADER;
1142  pes->ts_packet_pos = pos;
1143  }
1144  p = buf;
1145  while (buf_size > 0) {
1146  switch (pes->state) {
1147  case MPEGTS_HEADER:
1148  len = PES_START_SIZE - pes->data_index;
1149  if (len > buf_size)
1150  len = buf_size;
1151  memcpy(pes->header + pes->data_index, p, len);
1152  pes->data_index += len;
1153  p += len;
1154  buf_size -= len;
1155  if (pes->data_index == PES_START_SIZE) {
1156  /* we got all the PES or section header. We can now
1157  * decide */
1158  if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
1159  pes->header[2] == 0x01) {
1160  /* it must be an MPEG-2 PES stream */
1161  code = pes->header[3] | 0x100;
1162  av_log(pes->stream, AV_LOG_TRACE, "pid=%x pes_code=%#x\n", pes->pid,
1163  code);
1164  pes->stream_id = pes->header[3];
1165 
1166  if ((pes->st && pes->st->discard == AVDISCARD_ALL &&
1167  (!pes->sub_st ||
1168  pes->sub_st->discard == AVDISCARD_ALL)) ||
1169  code == 0x1be) /* padding_stream */
1170  goto skip;
1171 
1172  /* stream not present in PMT */
1173  if (!pes->st) {
1174  if (ts->skip_changes)
1175  goto skip;
1176  if (ts->merge_pmt_versions)
1177  goto skip; /* wait for PMT to merge new stream */
1178 
1179  pes->st = avformat_new_stream(ts->stream, NULL);
1180  if (!pes->st)
1181  return AVERROR(ENOMEM);
1182  pes->st->id = pes->pid;
1183  mpegts_set_stream_info(pes->st, pes, 0, 0);
1184  }
1185 
1186  pes->total_size = AV_RB16(pes->header + 4);
1187  /* NOTE: a zero total size means the PES size is
1188  * unbounded */
1189  if (!pes->total_size)
1190  pes->total_size = MAX_PES_PAYLOAD;
1191 
1192  /* allocate pes buffer */
1193  pes->buffer = buffer_pool_get(ts, pes->total_size);
1194  if (!pes->buffer)
1195  return AVERROR(ENOMEM);
1196 
1197  if (code != 0x1bc && code != 0x1bf && /* program_stream_map, private_stream_2 */
1198  code != 0x1f0 && code != 0x1f1 && /* ECM, EMM */
1199  code != 0x1ff && code != 0x1f2 && /* program_stream_directory, DSMCC_stream */
1200  code != 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */
1201  pes->state = MPEGTS_PESHEADER;
1202  if (pes->st->codecpar->codec_id == AV_CODEC_ID_NONE && !pes->st->internal->request_probe) {
1203  av_log(pes->stream, AV_LOG_TRACE,
1204  "pid=%x stream_type=%x probing\n",
1205  pes->pid,
1206  pes->stream_type);
1207  pes->st->internal->request_probe = 1;
1208  }
1209  } else {
1210  pes->pes_header_size = 6;
1211  pes->state = MPEGTS_PAYLOAD;
1212  pes->data_index = 0;
1213  }
1214  } else {
1215  /* otherwise, it should be a table */
1216  /* skip packet */
1217 skip:
1218  pes->state = MPEGTS_SKIP;
1219  continue;
1220  }
1221  }
1222  break;
1223  /**********************************************/
1224  /* PES packing parsing */
1225  case MPEGTS_PESHEADER:
1226  len = PES_HEADER_SIZE - pes->data_index;
1227  if (len < 0)
1228  return AVERROR_INVALIDDATA;
1229  if (len > buf_size)
1230  len = buf_size;
1231  memcpy(pes->header + pes->data_index, p, len);
1232  pes->data_index += len;
1233  p += len;
1234  buf_size -= len;
1235  if (pes->data_index == PES_HEADER_SIZE) {
1236  pes->pes_header_size = pes->header[8] + 9;
1238  }
1239  break;
1240  case MPEGTS_PESHEADER_FILL:
1241  len = pes->pes_header_size - pes->data_index;
1242  if (len < 0)
1243  return AVERROR_INVALIDDATA;
1244  if (len > buf_size)
1245  len = buf_size;
1246  memcpy(pes->header + pes->data_index, p, len);
1247  pes->data_index += len;
1248  p += len;
1249  buf_size -= len;
1250  if (pes->data_index == pes->pes_header_size) {
1251  const uint8_t *r;
1252  unsigned int flags, pes_ext, skip;
1253 
1254  flags = pes->header[7];
1255  r = pes->header + 9;
1256  pes->pts = AV_NOPTS_VALUE;
1257  pes->dts = AV_NOPTS_VALUE;
1258  if ((flags & 0xc0) == 0x80) {
1259  pes->dts = pes->pts = ff_parse_pes_pts(r);
1260  r += 5;
1261  } else if ((flags & 0xc0) == 0xc0) {
1262  pes->pts = ff_parse_pes_pts(r);
1263  r += 5;
1264  pes->dts = ff_parse_pes_pts(r);
1265  r += 5;
1266  }
1267  pes->extended_stream_id = -1;
1268  if (flags & 0x01) { /* PES extension */
1269  pes_ext = *r++;
1270  /* Skip PES private data, program packet sequence counter and P-STD buffer */
1271  skip = (pes_ext >> 4) & 0xb;
1272  skip += skip & 0x9;
1273  r += skip;
1274  if ((pes_ext & 0x41) == 0x01 &&
1275  (r + 2) <= (pes->header + pes->pes_header_size)) {
1276  /* PES extension 2 */
1277  if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)
1278  pes->extended_stream_id = r[1];
1279  }
1280  }
1281 
1282  /* we got the full header. We parse it and get the payload */
1283  pes->state = MPEGTS_PAYLOAD;
1284  pes->data_index = 0;
1285  if (pes->stream_type == 0x12 && buf_size > 0) {
1286  int sl_header_bytes = read_sl_header(pes, &pes->sl, p,
1287  buf_size);
1288  pes->pes_header_size += sl_header_bytes;
1289  p += sl_header_bytes;
1290  buf_size -= sl_header_bytes;
1291  }
1292  if (pes->stream_type == 0x15 && buf_size >= 5) {
1293  /* skip metadata access unit header */
1294  pes->pes_header_size += 5;
1295  p += 5;
1296  buf_size -= 5;
1297  }
1298  if ( pes->ts->fix_teletext_pts
1301  ) {
1302  AVProgram *p = NULL;
1303  int pcr_found = 0;
1304  while ((p = av_find_program_from_stream(pes->stream, p, pes->st->index))) {
1305  if (p->pcr_pid != -1 && p->discard != AVDISCARD_ALL) {
1306  MpegTSFilter *f = pes->ts->pids[p->pcr_pid];
1307  if (f) {
1308  AVStream *st = NULL;
1309  if (f->type == MPEGTS_PES) {
1310  PESContext *pcrpes = f->u.pes_filter.opaque;
1311  if (pcrpes)
1312  st = pcrpes->st;
1313  } else if (f->type == MPEGTS_PCR) {
1314  int i;
1315  for (i = 0; i < p->nb_stream_indexes; i++) {
1316  AVStream *pst = pes->stream->streams[p->stream_index[i]];
1317  if (pst->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
1318  st = pst;
1319  }
1320  }
1321  if (f->last_pcr != -1 && !f->discard) {
1322  // teletext packets do not always have correct timestamps,
1323  // the standard says they should be handled after 40.6 ms at most,
1324  // and the pcr error to this packet should be no more than 100 ms.
1325  // TODO: we should interpolate the PCR, not just use the last one
1326  int64_t pcr = f->last_pcr / 300;
1327  pcr_found = 1;
1328  if (st) {
1331  }
1332  if (pes->dts == AV_NOPTS_VALUE || pes->dts < pcr) {
1333  pes->pts = pes->dts = pcr;
1334  } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT &&
1335  pes->dts > pcr + 3654 + 9000) {
1336  pes->pts = pes->dts = pcr + 3654 + 9000;
1337  } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
1338  pes->dts > pcr + 10*90000) { //10sec
1339  pes->pts = pes->dts = pcr + 3654 + 9000;
1340  }
1341  break;
1342  }
1343  }
1344  }
1345  }
1346 
1347  if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT &&
1348  !pcr_found) {
1350  "Forcing DTS/PTS to be unset for a "
1351  "non-trustworthy PES packet for PID %d as "
1352  "PCR hasn't been received yet.\n",
1353  pes->pid);
1354  pes->dts = pes->pts = AV_NOPTS_VALUE;
1355  }
1356  }
1357  }
1358  break;
1359  case MPEGTS_PAYLOAD:
1360  if (pes->buffer) {
1361  if (pes->data_index > 0 &&
1362  pes->data_index + buf_size > pes->total_size) {
1363  ret = new_pes_packet(pes, ts->pkt);
1364  if (ret < 0)
1365  return ret;
1366  pes->total_size = MAX_PES_PAYLOAD;
1367  pes->buffer = buffer_pool_get(ts, pes->total_size);
1368  if (!pes->buffer)
1369  return AVERROR(ENOMEM);
1370  ts->stop_parse = 1;
1371  } else if (pes->data_index == 0 &&
1372  buf_size > pes->total_size) {
1373  // pes packet size is < ts size packet and pes data is padded with 0xff
1374  // not sure if this is legal in ts but see issue #2392
1375  buf_size = pes->total_size;
1376  }
1377  memcpy(pes->buffer->data + pes->data_index, p, buf_size);
1378  pes->data_index += buf_size;
1379  /* emit complete packets with known packet size
1380  * decreases demuxer delay for infrequent packets like subtitles from
1381  * a couple of seconds to milliseconds for properly muxed files.
1382  * total_size is the number of bytes following pes_packet_length
1383  * in the pes header, i.e. not counting the first PES_START_SIZE bytes */
1384  if (!ts->stop_parse && pes->total_size < MAX_PES_PAYLOAD &&
1385  pes->pes_header_size + pes->data_index == pes->total_size + PES_START_SIZE) {
1386  ts->stop_parse = 1;
1387  ret = new_pes_packet(pes, ts->pkt);
1388  if (ret < 0)
1389  return ret;
1390  }
1391  }
1392  buf_size = 0;
1393  break;
1394  case MPEGTS_SKIP:
1395  buf_size = 0;
1396  break;
1397  }
1398  }
1399 
1400  return 0;
1401 }
1402 
1403 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
1404 {
1405  MpegTSFilter *tss;
1406  PESContext *pes;
1407 
1408  /* if no pid found, then add a pid context */
1409  pes = av_mallocz(sizeof(PESContext));
1410  if (!pes)
1411  return 0;
1412  pes->ts = ts;
1413  pes->stream = ts->stream;
1414  pes->pid = pid;
1415  pes->pcr_pid = pcr_pid;
1416  pes->state = MPEGTS_SKIP;
1417  pes->pts = AV_NOPTS_VALUE;
1418  pes->dts = AV_NOPTS_VALUE;
1419  tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
1420  if (!tss) {
1421  av_free(pes);
1422  return 0;
1423  }
1424  return pes;
1425 }
1426 
1427 #define MAX_LEVEL 4
1428 typedef struct MP4DescrParseContext {
1435  int level;
1438 
1440  const uint8_t *buf, unsigned size,
1441  Mp4Descr *descr, int max_descr_count)
1442 {
1443  int ret;
1444  if (size > (1 << 30))
1445  return AVERROR_INVALIDDATA;
1446 
1447  if ((ret = ffio_init_context(&d->pb, (unsigned char *)buf, size, 0,
1448  NULL, NULL, NULL, NULL)) < 0)
1449  return ret;
1450 
1451  d->s = s;
1452  d->level = 0;
1453  d->descr_count = 0;
1454  d->descr = descr;
1455  d->active_descr = NULL;
1456  d->max_descr_count = max_descr_count;
1457 
1458  return 0;
1459 }
1460 
1461 static void update_offsets(AVIOContext *pb, int64_t *off, int *len)
1462 {
1463  int64_t new_off = avio_tell(pb);
1464  (*len) -= new_off - *off;
1465  *off = new_off;
1466 }
1467 
1468 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1469  int target_tag);
1470 
1471 static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
1472 {
1473  while (len > 0) {
1474  int ret = parse_mp4_descr(d, off, len, 0);
1475  if (ret < 0)
1476  return ret;
1477  update_offsets(&d->pb, &off, &len);
1478  }
1479  return 0;
1480 }
1481 
1482 static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1483 {
1484  avio_rb16(&d->pb); // ID
1485  avio_r8(&d->pb);
1486  avio_r8(&d->pb);
1487  avio_r8(&d->pb);
1488  avio_r8(&d->pb);
1489  avio_r8(&d->pb);
1490  update_offsets(&d->pb, &off, &len);
1491  return parse_mp4_descr_arr(d, off, len);
1492 }
1493 
1494 static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1495 {
1496  int id_flags;
1497  if (len < 2)
1498  return 0;
1499  id_flags = avio_rb16(&d->pb);
1500  if (!(id_flags & 0x0020)) { // URL_Flag
1501  update_offsets(&d->pb, &off, &len);
1502  return parse_mp4_descr_arr(d, off, len); // ES_Descriptor[]
1503  } else {
1504  return 0;
1505  }
1506 }
1507 
1508 static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1509 {
1510  int es_id = 0;
1511  int ret = 0;
1512 
1513  if (d->descr_count >= d->max_descr_count)
1514  return AVERROR_INVALIDDATA;
1515  ff_mp4_parse_es_descr(&d->pb, &es_id);
1516  d->active_descr = d->descr + (d->descr_count++);
1517 
1518  d->active_descr->es_id = es_id;
1519  update_offsets(&d->pb, &off, &len);
1520  if ((ret = parse_mp4_descr(d, off, len, MP4DecConfigDescrTag)) < 0)
1521  return ret;
1522  update_offsets(&d->pb, &off, &len);
1523  if (len > 0)
1525  d->active_descr = NULL;
1526  return ret;
1527 }
1528 
1530  int len)
1531 {
1532  Mp4Descr *descr = d->active_descr;
1533  if (!descr)
1534  return AVERROR_INVALIDDATA;
1535  d->active_descr->dec_config_descr = av_malloc(len);
1536  if (!descr->dec_config_descr)
1537  return AVERROR(ENOMEM);
1538  descr->dec_config_descr_len = len;
1539  avio_read(&d->pb, descr->dec_config_descr, len);
1540  return 0;
1541 }
1542 
1543 static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1544 {
1545  Mp4Descr *descr = d->active_descr;
1546  int predefined;
1547  if (!descr)
1548  return AVERROR_INVALIDDATA;
1549 
1550 #define R8_CHECK_CLIP_MAX(dst, maxv) do { \
1551  descr->sl.dst = avio_r8(&d->pb); \
1552  if (descr->sl.dst > maxv) { \
1553  descr->sl.dst = maxv; \
1554  return AVERROR_INVALIDDATA; \
1555  } \
1556 } while (0)
1557 
1558  predefined = avio_r8(&d->pb);
1559  if (!predefined) {
1560  int lengths;
1561  int flags = avio_r8(&d->pb);
1562  descr->sl.use_au_start = !!(flags & 0x80);
1563  descr->sl.use_au_end = !!(flags & 0x40);
1564  descr->sl.use_rand_acc_pt = !!(flags & 0x20);
1565  descr->sl.use_padding = !!(flags & 0x08);
1566  descr->sl.use_timestamps = !!(flags & 0x04);
1567  descr->sl.use_idle = !!(flags & 0x02);
1568  descr->sl.timestamp_res = avio_rb32(&d->pb);
1569  avio_rb32(&d->pb);
1570  R8_CHECK_CLIP_MAX(timestamp_len, 63);
1571  R8_CHECK_CLIP_MAX(ocr_len, 63);
1572  R8_CHECK_CLIP_MAX(au_len, 31);
1573  descr->sl.inst_bitrate_len = avio_r8(&d->pb);
1574  lengths = avio_rb16(&d->pb);
1575  descr->sl.degr_prior_len = lengths >> 12;
1576  descr->sl.au_seq_num_len = (lengths >> 7) & 0x1f;
1577  descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f;
1578  } else if (!d->predefined_SLConfigDescriptor_seen){
1579  avpriv_report_missing_feature(d->s, "Predefined SLConfigDescriptor");
1580  d->predefined_SLConfigDescriptor_seen = 1;
1581  }
1582  return 0;
1583 }
1584 
1585 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1586  int target_tag)
1587 {
1588  int tag;
1589  int len1 = ff_mp4_read_descr(d->s, &d->pb, &tag);
1590  int ret = 0;
1591 
1592  update_offsets(&d->pb, &off, &len);
1593  if (len < 0 || len1 > len || len1 <= 0) {
1594  av_log(d->s, AV_LOG_ERROR,
1595  "Tag %x length violation new length %d bytes remaining %d\n",
1596  tag, len1, len);
1597  return AVERROR_INVALIDDATA;
1598  }
1599 
1600  if (d->level++ >= MAX_LEVEL) {
1601  av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n");
1603  goto done;
1604  }
1605 
1606  if (target_tag && tag != target_tag) {
1607  av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag,
1608  target_tag);
1610  goto done;
1611  }
1612 
1613  switch (tag) {
1614  case MP4IODescrTag:
1615  ret = parse_MP4IODescrTag(d, off, len1);
1616  break;
1617  case MP4ODescrTag:
1618  ret = parse_MP4ODescrTag(d, off, len1);
1619  break;
1620  case MP4ESDescrTag:
1621  ret = parse_MP4ESDescrTag(d, off, len1);
1622  break;
1623  case MP4DecConfigDescrTag:
1624  ret = parse_MP4DecConfigDescrTag(d, off, len1);
1625  break;
1626  case MP4SLDescrTag:
1627  ret = parse_MP4SLDescrTag(d, off, len1);
1628  break;
1629  }
1630 
1631 
1632 done:
1633  d->level--;
1634  avio_seek(&d->pb, off + len1, SEEK_SET);
1635  return ret;
1636 }
1637 
1638 static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
1639  Mp4Descr *descr, int *descr_count, int max_descr_count)
1640 {
1642  int ret;
1643 
1644  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1645  if (ret < 0)
1646  return ret;
1647 
1649 
1650  *descr_count = d.descr_count;
1651  return ret;
1652 }
1653 
1654 static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size,
1655  Mp4Descr *descr, int *descr_count, int max_descr_count)
1656 {
1658  int ret;
1659 
1660  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1661  if (ret < 0)
1662  return ret;
1663 
1664  ret = parse_mp4_descr_arr(&d, avio_tell(&d.pb), size);
1665 
1666  *descr_count = d.descr_count;
1667  return ret;
1668 }
1669 
1670 static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section,
1671  int section_len)
1672 {
1673  MpegTSContext *ts = filter->u.section_filter.opaque;
1674  MpegTSSectionFilter *tssf = &filter->u.section_filter;
1675  SectionHeader h;
1676  const uint8_t *p, *p_end;
1677  AVIOContext pb;
1678  int mp4_descr_count = 0;
1679  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
1680  int i, pid;
1681  AVFormatContext *s = ts->stream;
1682 
1683  p_end = section + section_len - 4;
1684  p = section;
1685  if (parse_section_header(&h, &p, p_end) < 0)
1686  return;
1687  if (h.tid != M4OD_TID)
1688  return;
1689  if (skip_identical(&h, tssf))
1690  return;
1691 
1692  mp4_read_od(s, p, (unsigned) (p_end - p), mp4_descr, &mp4_descr_count,
1694 
1695  for (pid = 0; pid < NB_PID_MAX; pid++) {
1696  if (!ts->pids[pid])
1697  continue;
1698  for (i = 0; i < mp4_descr_count; i++) {
1699  PESContext *pes;
1700  AVStream *st;
1701  if (ts->pids[pid]->es_id != mp4_descr[i].es_id)
1702  continue;
1703  if (ts->pids[pid]->type != MPEGTS_PES) {
1704  av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);
1705  continue;
1706  }
1707  pes = ts->pids[pid]->u.pes_filter.opaque;
1708  st = pes->st;
1709  if (!st)
1710  continue;
1711 
1712  pes->sl = mp4_descr[i].sl;
1713 
1714  ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1715  mp4_descr[i].dec_config_descr_len, 0,
1716  NULL, NULL, NULL, NULL);
1717  ff_mp4_read_dec_config_descr(s, st, &pb);
1718  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1719  st->codecpar->extradata_size > 0)
1720  st->internal->need_parsing = 0;
1721  if (st->codecpar->codec_id == AV_CODEC_ID_H264 &&
1722  st->codecpar->extradata_size > 0)
1723  st->internal->need_parsing = 0;
1724 
1726  st->internal->need_context_update = 1;
1727  }
1728  }
1729  for (i = 0; i < mp4_descr_count; i++)
1730  av_free(mp4_descr[i].dec_config_descr);
1731 }
1732 
1733 static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section,
1734  int section_len)
1735 {
1736  AVProgram *prg = NULL;
1737  MpegTSContext *ts = filter->u.section_filter.opaque;
1738 
1739  int idx = ff_find_stream_index(ts->stream, filter->pid);
1740  if (idx < 0)
1741  return;
1742 
1743  /**
1744  * In case we receive an SCTE-35 packet before mpegts context is fully
1745  * initialized.
1746  */
1747  if (!ts->pkt)
1748  return;
1749 
1750  new_data_packet(section, section_len, ts->pkt);
1751  ts->pkt->stream_index = idx;
1752  prg = av_find_program_from_stream(ts->stream, NULL, idx);
1753  if (prg && prg->pcr_pid != -1 && prg->discard != AVDISCARD_ALL) {
1754  MpegTSFilter *f = ts->pids[prg->pcr_pid];
1755  if (f && f->last_pcr != -1)
1756  ts->pkt->pts = ts->pkt->dts = f->last_pcr/300;
1757  }
1758  ts->stop_parse = 1;
1759 
1760 }
1761 
1762 static const uint8_t opus_coupled_stream_cnt[9] = {
1763  1, 0, 1, 1, 2, 2, 2, 3, 3
1764 };
1765 
1766 static const uint8_t opus_stream_cnt[9] = {
1767  1, 1, 1, 2, 2, 3, 4, 4, 5,
1768 };
1769 
1770 static const uint8_t opus_channel_map[8][8] = {
1771  { 0 },
1772  { 0,1 },
1773  { 0,2,1 },
1774  { 0,1,2,3 },
1775  { 0,4,1,2,3 },
1776  { 0,4,1,2,3,5 },
1777  { 0,4,1,2,3,5,6 },
1778  { 0,6,1,2,3,4,5,7 },
1779 };
1780 
1782  const uint8_t **pp, const uint8_t *desc_list_end,
1783  Mp4Descr *mp4_descr, int mp4_descr_count, int pid,
1784  MpegTSContext *ts)
1785 {
1786  const uint8_t *desc_end;
1787  int desc_len, desc_tag, desc_es_id, ext_desc_tag, channels, channel_config_code;
1788  char language[252];
1789  int i;
1790 
1791  desc_tag = get8(pp, desc_list_end);
1792  if (desc_tag < 0)
1793  return AVERROR_INVALIDDATA;
1794  desc_len = get8(pp, desc_list_end);
1795  if (desc_len < 0)
1796  return AVERROR_INVALIDDATA;
1797  desc_end = *pp + desc_len;
1798  if (desc_end > desc_list_end)
1799  return AVERROR_INVALIDDATA;
1800 
1801  av_log(fc, AV_LOG_TRACE, "tag: 0x%02x len=%d\n", desc_tag, desc_len);
1802 
1803  if ((st->codecpar->codec_id == AV_CODEC_ID_NONE || st->internal->request_probe > 0) &&
1804  stream_type == STREAM_TYPE_PRIVATE_DATA)
1805  mpegts_find_stream_type(st, desc_tag, DESC_types);
1806 
1807  switch (desc_tag) {
1809  if (get8(pp, desc_end) & 0x1) {
1811  }
1812  break;
1813  case SL_DESCRIPTOR:
1814  desc_es_id = get16(pp, desc_end);
1815  if (desc_es_id < 0)
1816  break;
1817  if (ts && ts->pids[pid])
1818  ts->pids[pid]->es_id = desc_es_id;
1819  for (i = 0; i < mp4_descr_count; i++)
1820  if (mp4_descr[i].dec_config_descr_len &&
1821  mp4_descr[i].es_id == desc_es_id) {
1822  AVIOContext pb;
1823  ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1824  mp4_descr[i].dec_config_descr_len, 0,
1825  NULL, NULL, NULL, NULL);
1826  ff_mp4_read_dec_config_descr(fc, st, &pb);
1827  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1828  st->codecpar->extradata_size > 0) {
1829  st->internal->need_parsing = 0;
1830  st->internal->need_context_update = 1;
1831  }
1833  mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);
1834  }
1835  break;
1836  case FMC_DESCRIPTOR:
1837  if (get16(pp, desc_end) < 0)
1838  break;
1839  if (mp4_descr_count > 0 &&
1841  (st->internal->request_probe == 0 && st->codecpar->codec_id == AV_CODEC_ID_NONE) ||
1842  st->internal->request_probe > 0) &&
1843  mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {
1844  AVIOContext pb;
1845  ffio_init_context(&pb, mp4_descr->dec_config_descr,
1846  mp4_descr->dec_config_descr_len, 0,
1847  NULL, NULL, NULL, NULL);
1848  ff_mp4_read_dec_config_descr(fc, st, &pb);
1849  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1850  st->codecpar->extradata_size > 0) {
1851  st->internal->request_probe = st->internal->need_parsing = 0;
1853  st->internal->need_context_update = 1;
1854  }
1855  }
1856  break;
1857  case 0x56: /* DVB teletext descriptor */
1858  {
1859  uint8_t *extradata = NULL;
1860  int language_count = desc_len / 5, ret;
1861 
1862  if (desc_len > 0 && desc_len % 5 != 0)
1863  return AVERROR_INVALIDDATA;
1864 
1865  if (language_count > 0) {
1866  /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1867  av_assert0(language_count <= sizeof(language) / 4);
1868 
1869  if (st->codecpar->extradata == NULL) {
1870  ret = ff_alloc_extradata(st->codecpar, language_count * 2);
1871  if (ret < 0)
1872  return ret;
1873  }
1874 
1875  if (st->codecpar->extradata_size < language_count * 2)
1876  return AVERROR_INVALIDDATA;
1877 
1878  extradata = st->codecpar->extradata;
1879 
1880  for (i = 0; i < language_count; i++) {
1881  language[i * 4 + 0] = get8(pp, desc_end);
1882  language[i * 4 + 1] = get8(pp, desc_end);
1883  language[i * 4 + 2] = get8(pp, desc_end);
1884  language[i * 4 + 3] = ',';
1885 
1886  memcpy(extradata, *pp, 2);
1887  extradata += 2;
1888 
1889  *pp += 2;
1890  }
1891 
1892  language[i * 4 - 1] = 0;
1893  av_dict_set(&st->metadata, "language", language, 0);
1894  st->internal->need_context_update = 1;
1895  }
1896  }
1897  break;
1898  case 0x59: /* subtitling descriptor */
1899  {
1900  /* 8 bytes per DVB subtitle substream data:
1901  * ISO_639_language_code (3 bytes),
1902  * subtitling_type (1 byte),
1903  * composition_page_id (2 bytes),
1904  * ancillary_page_id (2 bytes) */
1905  int language_count = desc_len / 8, ret;
1906 
1907  if (desc_len > 0 && desc_len % 8 != 0)
1908  return AVERROR_INVALIDDATA;
1909 
1910  if (language_count > 1) {
1911  avpriv_request_sample(fc, "DVB subtitles with multiple languages");
1912  }
1913 
1914  if (language_count > 0) {
1915  uint8_t *extradata;
1916 
1917  /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1918  av_assert0(language_count <= sizeof(language) / 4);
1919 
1920  if (st->codecpar->extradata == NULL) {
1921  ret = ff_alloc_extradata(st->codecpar, language_count * 5);
1922  if (ret < 0)
1923  return ret;
1924  }
1925 
1926  if (st->codecpar->extradata_size < language_count * 5)
1927  return AVERROR_INVALIDDATA;
1928 
1929  extradata = st->codecpar->extradata;
1930 
1931  for (i = 0; i < language_count; i++) {
1932  language[i * 4 + 0] = get8(pp, desc_end);
1933  language[i * 4 + 1] = get8(pp, desc_end);
1934  language[i * 4 + 2] = get8(pp, desc_end);
1935  language[i * 4 + 3] = ',';
1936 
1937  /* hearing impaired subtitles detection using subtitling_type */
1938  switch (*pp[0]) {
1939  case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */
1940  case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */
1941  case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */
1942  case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */
1943  case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */
1944  case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */
1946  break;
1947  }
1948 
1949  extradata[4] = get8(pp, desc_end); /* subtitling_type */
1950  memcpy(extradata, *pp, 4); /* composition_page_id and ancillary_page_id */
1951  extradata += 5;
1952 
1953  *pp += 4;
1954  }
1955 
1956  language[i * 4 - 1] = 0;
1957  av_dict_set(&st->metadata, "language", language, 0);
1958  st->internal->need_context_update = 1;
1959  }
1960  }
1961  break;
1963  for (i = 0; i + 4 <= desc_len; i += 4) {
1964  language[i + 0] = get8(pp, desc_end);
1965  language[i + 1] = get8(pp, desc_end);
1966  language[i + 2] = get8(pp, desc_end);
1967  language[i + 3] = ',';
1968  switch (get8(pp, desc_end)) {
1969  case 0x01:
1971  break;
1972  case 0x02:
1974  break;
1975  case 0x03:
1978  break;
1979  }
1980  }
1981  if (i && language[0]) {
1982  language[i - 1] = 0;
1983  /* don't overwrite language, as it may already have been set by
1984  * another, more specific descriptor (e.g. supplementary audio) */
1986  }
1987  break;
1989  st->codecpar->codec_tag = bytestream_get_le32(pp);
1990  av_log(fc, AV_LOG_TRACE, "reg_desc=%.4s\n", (char *)&st->codecpar->codec_tag);
1991  if (st->codecpar->codec_id == AV_CODEC_ID_NONE || st->internal->request_probe > 0) {
1993  if (st->codecpar->codec_tag == MKTAG('B', 'S', 'S', 'D'))
1994  st->internal->request_probe = 50;
1995  }
1996  break;
1997  case 0x52: /* stream identifier descriptor */
1998  st->internal->stream_identifier = 1 + get8(pp, desc_end);
1999  break;
2000  case METADATA_DESCRIPTOR:
2001  if (get16(pp, desc_end) == 0xFFFF)
2002  *pp += 4;
2003  if (get8(pp, desc_end) == 0xFF) {
2004  st->codecpar->codec_tag = bytestream_get_le32(pp);
2005  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2007  }
2008  break;
2009  case 0x7f: /* DVB extension descriptor */
2010  ext_desc_tag = get8(pp, desc_end);
2011  if (ext_desc_tag < 0)
2012  return AVERROR_INVALIDDATA;
2013  if (st->codecpar->codec_id == AV_CODEC_ID_OPUS &&
2014  ext_desc_tag == 0x80) { /* User defined (provisional Opus) */
2015  if (!st->codecpar->extradata) {
2018  if (!st->codecpar->extradata)
2019  return AVERROR(ENOMEM);
2020 
2023 
2024  channel_config_code = get8(pp, desc_end);
2025  if (channel_config_code < 0)
2026  return AVERROR_INVALIDDATA;
2027  if (channel_config_code <= 0x8) {
2028  st->codecpar->extradata[9] = channels = channel_config_code ? channel_config_code : 2;
2029  AV_WL32(&st->codecpar->extradata[12], 48000);
2030  st->codecpar->extradata[18] = channel_config_code ? (channels > 2) : /* Dual Mono */ 255;
2031  st->codecpar->extradata[19] = opus_stream_cnt[channel_config_code];
2032  st->codecpar->extradata[20] = opus_coupled_stream_cnt[channel_config_code];
2033  memcpy(&st->codecpar->extradata[21], opus_channel_map[channels - 1], channels);
2034  st->codecpar->extradata_size = st->codecpar->extradata[18] ? 21 + channels : 19;
2035  } else {
2036  avpriv_request_sample(fc, "Opus in MPEG-TS - channel_config_code > 0x8");
2037  }
2039  st->internal->need_context_update = 1;
2040  }
2041  }
2042  if (ext_desc_tag == 0x06) { /* supplementary audio descriptor */
2043  int flags;
2044 
2045  if (desc_len < 1)
2046  return AVERROR_INVALIDDATA;
2047  flags = get8(pp, desc_end);
2048 
2049  if ((flags & 0x80) == 0) /* mix_type */
2051 
2052  switch ((flags >> 2) & 0x1F) { /* editorial_classification */
2053  case 0x01:
2056  break;
2057  case 0x02:
2059  break;
2060  case 0x03:
2062  break;
2063  }
2064 
2065  if (flags & 0x01) { /* language_code_present */
2066  if (desc_len < 4)
2067  return AVERROR_INVALIDDATA;
2068  language[0] = get8(pp, desc_end);
2069  language[1] = get8(pp, desc_end);
2070  language[2] = get8(pp, desc_end);
2071  language[3] = 0;
2072 
2073  /* This language always has to override a possible
2074  * ISO 639 language descriptor language */
2075  if (language[0])
2076  av_dict_set(&st->metadata, "language", language, 0);
2077  }
2078  }
2079  break;
2080  case 0x6a: /* ac-3_descriptor */
2081  {
2082  int component_type_flag = get8(pp, desc_end) & (1 << 7);
2083  if (component_type_flag) {
2084  int component_type = get8(pp, desc_end);
2085  int service_type_mask = 0x38; // 0b00111000
2086  int service_type = ((component_type & service_type_mask) >> 3);
2087  if (service_type == 0x02 /* 0b010 */) {
2089  av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition);
2090  }
2091  }
2092  }
2093  break;
2094  case 0x7a: /* enhanced_ac-3_descriptor */
2095  {
2096  int component_type_flag = get8(pp, desc_end) & (1 << 7);
2097  if (component_type_flag) {
2098  int component_type = get8(pp, desc_end);
2099  int service_type_mask = 0x38; // 0b00111000
2100  int service_type = ((component_type & service_type_mask) >> 3);
2101  if (service_type == 0x02 /* 0b010 */) {
2103  av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition);
2104  }
2105  }
2106  }
2107  break;
2108  case 0xfd: /* ARIB data coding type descriptor */
2109  // STD-B24, fascicle 3, chapter 4 defines private_stream_1
2110  // for captions
2111  if (stream_type == STREAM_TYPE_PRIVATE_DATA) {
2112  // This structure is defined in STD-B10, part 1, listing 5.4 and
2113  // part 2, 6.2.20).
2114  // Listing of data_component_ids is in STD-B10, part 2, Annex J.
2115  // Component tag limits are documented in TR-B14, fascicle 2,
2116  // Vol. 3, Section 2, 4.2.8.1
2117  int actual_component_tag = st->internal->stream_identifier - 1;
2118  int picked_profile = FF_PROFILE_UNKNOWN;
2119  int data_component_id = get16(pp, desc_end);
2120  if (data_component_id < 0)
2121  return AVERROR_INVALIDDATA;
2122 
2123  switch (data_component_id) {
2124  case 0x0008:
2125  // [0x30..0x37] are component tags utilized for
2126  // non-mobile captioning service ("profile A").
2127  if (actual_component_tag >= 0x30 &&
2128  actual_component_tag <= 0x37) {
2129  picked_profile = FF_PROFILE_ARIB_PROFILE_A;
2130  }
2131  break;
2132  case 0x0012:
2133  // component tag 0x87 signifies a mobile/partial reception
2134  // (1seg) captioning service ("profile C").
2135  if (actual_component_tag == 0x87) {
2136  picked_profile = FF_PROFILE_ARIB_PROFILE_C;
2137  }
2138  break;
2139  default:
2140  break;
2141  }
2142 
2143  if (picked_profile == FF_PROFILE_UNKNOWN)
2144  break;
2145 
2148  st->codecpar->profile = picked_profile;
2149  st->internal->request_probe = 0;
2150  }
2151  break;
2152  case 0xb0: /* DOVI video stream descriptor */
2153  {
2154  uint32_t buf;
2156  size_t dovi_size;
2157  int ret;
2158  if (desc_end - *pp < 4) // (8 + 8 + 7 + 6 + 1 + 1 + 1) / 8
2159  return AVERROR_INVALIDDATA;
2160 
2161  dovi = av_dovi_alloc(&dovi_size);
2162  if (!dovi)
2163  return AVERROR(ENOMEM);
2164 
2165  dovi->dv_version_major = get8(pp, desc_end);
2166  dovi->dv_version_minor = get8(pp, desc_end);
2167  buf = get16(pp, desc_end);
2168  dovi->dv_profile = (buf >> 9) & 0x7f; // 7 bits
2169  dovi->dv_level = (buf >> 3) & 0x3f; // 6 bits
2170  dovi->rpu_present_flag = (buf >> 2) & 0x01; // 1 bit
2171  dovi->el_present_flag = (buf >> 1) & 0x01; // 1 bit
2172  dovi->bl_present_flag = buf & 0x01; // 1 bit
2173  if (desc_end - *pp >= 20) { // 4 + 4 * 4
2174  buf = get8(pp, desc_end);
2175  dovi->dv_bl_signal_compatibility_id = (buf >> 4) & 0x0f; // 4 bits
2176  } else {
2177  // 0 stands for None
2178  // Dolby Vision V1.2.93 profiles and levels
2180  }
2181 
2183  (uint8_t *)dovi, dovi_size);
2184  if (ret < 0) {
2185  av_free(dovi);
2186  return ret;
2187  }
2188 
2189  av_log(fc, AV_LOG_TRACE, "DOVI, version: %d.%d, profile: %d, level: %d, "
2190  "rpu flag: %d, el flag: %d, bl flag: %d, compatibility id: %d\n",
2191  dovi->dv_version_major, dovi->dv_version_minor,
2192  dovi->dv_profile, dovi->dv_level,
2193  dovi->rpu_present_flag,
2194  dovi->el_present_flag,
2195  dovi->bl_present_flag,
2196  dovi->dv_bl_signal_compatibility_id);
2197  }
2198  break;
2199  default:
2200  break;
2201  }
2202  *pp = desc_end;
2203  return 0;
2204 }
2205 
2206 static AVStream *find_matching_stream(MpegTSContext *ts, int pid, unsigned int programid,
2207  int stream_identifier, int pmt_stream_idx, struct Program *p)
2208 {
2209  AVFormatContext *s = ts->stream;
2210  int i;
2211  AVStream *found = NULL;
2212 
2213  if (stream_identifier) { /* match based on "stream identifier descriptor" if present */
2214  for (i = 0; i < p->nb_streams; i++) {
2215  if (p->streams[i].stream_identifier == stream_identifier)
2216  if (!found || pmt_stream_idx == i) /* fallback to idx based guess if multiple streams have the same identifier */
2217  found = s->streams[p->streams[i].idx];
2218  }
2219  } else if (pmt_stream_idx < p->nb_streams) { /* match based on position within the PMT */
2220  found = s->streams[p->streams[pmt_stream_idx].idx];
2221  }
2222 
2223  if (found) {
2225  "re-using existing %s stream %d (pid=0x%x) for new pid=0x%x\n",
2227  i, found->id, pid);
2228  }
2229 
2230  return found;
2231 }
2232 
2233 static int parse_stream_identifier_desc(const uint8_t *p, const uint8_t *p_end)
2234 {
2235  const uint8_t **pp = &p;
2236  const uint8_t *desc_list_end;
2237  const uint8_t *desc_end;
2238  int desc_list_len;
2239  int desc_len, desc_tag;
2240 
2241  desc_list_len = get16(pp, p_end);
2242  if (desc_list_len < 0)
2243  return -1;
2244  desc_list_len &= 0xfff;
2245  desc_list_end = p + desc_list_len;
2246  if (desc_list_end > p_end)
2247  return -1;
2248 
2249  while (1) {
2250  desc_tag = get8(pp, desc_list_end);
2251  if (desc_tag < 0)
2252  return -1;
2253  desc_len = get8(pp, desc_list_end);
2254  if (desc_len < 0)
2255  return -1;
2256  desc_end = *pp + desc_len;
2257  if (desc_end > desc_list_end)
2258  return -1;
2259 
2260  if (desc_tag == 0x52) {
2261  return get8(pp, desc_end);
2262  }
2263  *pp = desc_end;
2264  }
2265 
2266  return -1;
2267 }
2268 
2269 static int is_pes_stream(int stream_type, uint32_t prog_reg_desc)
2270 {
2271  return !(stream_type == 0x13 ||
2272  (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) );
2273 }
2274 
2275 static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2276 {
2277  MpegTSContext *ts = filter->u.section_filter.opaque;
2278  MpegTSSectionFilter *tssf = &filter->u.section_filter;
2279  struct Program old_program;
2280  SectionHeader h1, *h = &h1;
2281  PESContext *pes;
2282  AVStream *st;
2283  const uint8_t *p, *p_end, *desc_list_end;
2284  int program_info_length, pcr_pid, pid, stream_type;
2285  int desc_list_len;
2286  uint32_t prog_reg_desc = 0; /* registration descriptor */
2287  int stream_identifier = -1;
2288  struct Program *prg;
2289 
2290  int mp4_descr_count = 0;
2291  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
2292  int i;
2293 
2294  av_log(ts->stream, AV_LOG_TRACE, "PMT: len %i\n", section_len);
2295  hex_dump_debug(ts->stream, section, section_len);
2296 
2297  p_end = section + section_len - 4;
2298  p = section;
2299  if (parse_section_header(h, &p, p_end) < 0)
2300  return;
2301  if (h->tid != PMT_TID)
2302  return;
2303  if (skip_identical(h, tssf))
2304  return;
2305 
2306  av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x sec_num=%d/%d version=%d tid=%d\n",
2307  h->id, h->sec_num, h->last_sec_num, h->version, h->tid);
2308 
2309  if (!ts->scan_all_pmts && ts->skip_changes)
2310  return;
2311 
2312  prg = get_program(ts, h->id);
2313  if (prg)
2314  old_program = *prg;
2315  else
2316  clear_program(&old_program);
2317 
2318  if (ts->skip_unknown_pmt && !prg)
2319  return;
2320  if (prg && prg->nb_pids && prg->pids[0] != ts->current_pid)
2321  return;
2322  if (!ts->skip_clear)
2323  clear_avprogram(ts, h->id);
2324  clear_program(prg);
2325  add_pid_to_program(prg, ts->current_pid);
2326 
2327  pcr_pid = get16(&p, p_end);
2328  if (pcr_pid < 0)
2329  return;
2330  pcr_pid &= 0x1fff;
2331  add_pid_to_program(prg, pcr_pid);
2332  update_av_program_info(ts->stream, h->id, pcr_pid, h->version);
2333 
2334  av_log(ts->stream, AV_LOG_TRACE, "pcr_pid=0x%x\n", pcr_pid);
2335 
2336  program_info_length = get16(&p, p_end);
2337  if (program_info_length < 0)
2338  return;
2339  program_info_length &= 0xfff;
2340  while (program_info_length >= 2) {
2341  uint8_t tag, len;
2342  tag = get8(&p, p_end);
2343  len = get8(&p, p_end);
2344 
2345  av_log(ts->stream, AV_LOG_TRACE, "program tag: 0x%02x len=%d\n", tag, len);
2346 
2347  if (len > program_info_length - 2)
2348  // something else is broken, exit the program_descriptors_loop
2349  break;
2350  program_info_length -= len + 2;
2351  if (tag == IOD_DESCRIPTOR) {
2352  get8(&p, p_end); // scope
2353  get8(&p, p_end); // label
2354  len -= 2;
2355  mp4_read_iods(ts->stream, p, len, mp4_descr + mp4_descr_count,
2356  &mp4_descr_count, MAX_MP4_DESCR_COUNT);
2357  } else if (tag == REGISTRATION_DESCRIPTOR && len >= 4) {
2358  prog_reg_desc = bytestream_get_le32(&p);
2359  len -= 4;
2360  }
2361  p += len;
2362  }
2363  p += program_info_length;
2364  if (p >= p_end)
2365  goto out;
2366 
2367  // stop parsing after pmt, we found header
2368  if (!ts->pkt)
2369  ts->stop_parse = 2;
2370 
2371  if (prg)
2372  prg->pmt_found = 1;
2373 
2374  for (i = 0; i < MAX_STREAMS_PER_PROGRAM; i++) {
2375  st = 0;
2376  pes = NULL;
2377  stream_type = get8(&p, p_end);
2378  if (stream_type < 0)
2379  break;
2380  pid = get16(&p, p_end);
2381  if (pid < 0)
2382  goto out;
2383  pid &= 0x1fff;
2384  if (pid == ts->current_pid)
2385  goto out;
2386 
2387  stream_identifier = parse_stream_identifier_desc(p, p_end) + 1;
2388 
2389  /* now create stream */
2390  if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
2391  pes = ts->pids[pid]->u.pes_filter.opaque;
2392  if (ts->merge_pmt_versions && !pes->st) {
2393  st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program);
2394  if (st) {
2395  pes->st = st;
2396  pes->stream_type = stream_type;
2397  pes->merged_st = 1;
2398  }
2399  }
2400  if (!pes->st) {
2401  pes->st = avformat_new_stream(pes->stream, NULL);
2402  if (!pes->st)
2403  goto out;
2404  pes->st->id = pes->pid;
2405  }
2406  st = pes->st;
2407  } else if (is_pes_stream(stream_type, prog_reg_desc)) {
2408  if (ts->pids[pid])
2409  mpegts_close_filter(ts, ts->pids[pid]); // wrongly added sdt filter probably
2410  pes = add_pes_stream(ts, pid, pcr_pid);
2411  if (ts->merge_pmt_versions && pes && !pes->st) {
2412  st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program);
2413  if (st) {
2414  pes->st = st;
2415  pes->stream_type = stream_type;
2416  pes->merged_st = 1;
2417  }
2418  }
2419  if (pes && !pes->st) {
2420  st = avformat_new_stream(pes->stream, NULL);
2421  if (!st)
2422  goto out;
2423  st->id = pes->pid;
2424  }
2425  } else {
2426  int idx = ff_find_stream_index(ts->stream, pid);
2427  if (idx >= 0) {
2428  st = ts->stream->streams[idx];
2429  }
2430  if (ts->merge_pmt_versions && !st) {
2431  st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program);
2432  }
2433  if (!st) {
2434  st = avformat_new_stream(ts->stream, NULL);
2435  if (!st)
2436  goto out;
2437  st->id = pid;
2439  if (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) {
2440  mpegts_find_stream_type(st, stream_type, SCTE_types);
2441  mpegts_open_section_filter(ts, pid, scte_data_cb, ts, 1);
2442  }
2443  }
2444  }
2445 
2446  if (!st)
2447  goto out;
2448 
2449  if (pes && !pes->stream_type)
2450  mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc);
2451 
2452  add_pid_to_program(prg, pid);
2453  if (prg) {
2454  prg->streams[i].idx = st->index;
2455  prg->streams[i].stream_identifier = stream_identifier;
2456  prg->nb_streams++;
2457  }
2458 
2459  av_program_add_stream_index(ts->stream, h->id, st->index);
2460 
2461  desc_list_len = get16(&p, p_end);
2462  if (desc_list_len < 0)
2463  goto out;
2464  desc_list_len &= 0xfff;
2465  desc_list_end = p + desc_list_len;
2466  if (desc_list_end > p_end)
2467  goto out;
2468  for (;;) {
2469  if (ff_parse_mpeg2_descriptor(ts->stream, st, stream_type, &p,
2470  desc_list_end, mp4_descr,
2471  mp4_descr_count, pid, ts) < 0)
2472  break;
2473 
2474  if (pes && prog_reg_desc == AV_RL32("HDMV") &&
2475  stream_type == 0x83 && pes->sub_st) {
2477  pes->sub_st->index);
2478  pes->sub_st->codecpar->codec_tag = st->codecpar->codec_tag;
2479  }
2480  }
2481  p = desc_list_end;
2482  }
2483 
2484  if (!ts->pids[pcr_pid])
2485  mpegts_open_pcr_filter(ts, pcr_pid);
2486 
2487 out:
2488  for (i = 0; i < mp4_descr_count; i++)
2489  av_free(mp4_descr[i].dec_config_descr);
2490 }
2491 
2492 static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2493 {
2494  MpegTSContext *ts = filter->u.section_filter.opaque;
2495  MpegTSSectionFilter *tssf = &filter->u.section_filter;
2496  SectionHeader h1, *h = &h1;
2497  const uint8_t *p, *p_end;
2498  int sid, pmt_pid;
2499  int nb_prg = 0;
2500  AVProgram *program;
2501 
2502  av_log(ts->stream, AV_LOG_TRACE, "PAT:\n");
2503  hex_dump_debug(ts->stream, section, section_len);
2504 
2505  p_end = section + section_len - 4;
2506  p = section;
2507  if (parse_section_header(h, &p, p_end) < 0)
2508  return;
2509  if (h->tid != PAT_TID)
2510  return;
2511  if (ts->skip_changes)
2512  return;
2513 
2514  if (skip_identical(h, tssf))
2515  return;
2516  ts->stream->ts_id = h->id;
2517 
2518  for (;;) {
2519  sid = get16(&p, p_end);
2520  if (sid < 0)
2521  break;
2522  pmt_pid = get16(&p, p_end);
2523  if (pmt_pid < 0)
2524  break;
2525  pmt_pid &= 0x1fff;
2526 
2527  if (pmt_pid == ts->current_pid)
2528  break;
2529 
2530  av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
2531 
2532  if (sid == 0x0000) {
2533  /* NIT info */
2534  } else {
2535  MpegTSFilter *fil = ts->pids[pmt_pid];
2536  struct Program *prg;
2537  program = av_new_program(ts->stream, sid);
2538  if (program) {
2539  program->program_num = sid;
2540  program->pmt_pid = pmt_pid;
2541  }
2542  if (fil)
2543  if ( fil->type != MPEGTS_SECTION
2544  || fil->pid != pmt_pid
2545  || fil->u.section_filter.section_cb != pmt_cb)
2546  mpegts_close_filter(ts, ts->pids[pmt_pid]);
2547 
2548  if (!ts->pids[pmt_pid])
2549  mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
2550  prg = add_program(ts, sid);
2551  if (prg) {
2552  unsigned prg_idx = prg - ts->prg;
2553  if (prg->nb_pids && prg->pids[0] != pmt_pid)
2554  clear_program(prg);
2555  add_pid_to_program(prg, pmt_pid);
2556  if (prg_idx > nb_prg)
2557  FFSWAP(struct Program, ts->prg[nb_prg], ts->prg[prg_idx]);
2558  if (prg_idx >= nb_prg)
2559  nb_prg++;
2560  }
2561  }
2562  }
2563  ts->nb_prg = nb_prg;
2564 
2565  if (sid < 0) {
2566  int i,j;
2567  for (j=0; j<ts->stream->nb_programs; j++) {
2568  for (i = 0; i < ts->nb_prg; i++)
2569  if (ts->prg[i].id == ts->stream->programs[j]->id)
2570  break;
2571  if (i==ts->nb_prg && !ts->skip_clear)
2572  clear_avprogram(ts, ts->stream->programs[j]->id);
2573  }
2574  }
2575 }
2576 
2577 static void eit_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2578 {
2579  MpegTSContext *ts = filter->u.section_filter.opaque;
2580  const uint8_t *p, *p_end;
2581  SectionHeader h1, *h = &h1;
2582 
2583  /*
2584  * Sometimes we receive EPG packets but SDT table do not have
2585  * eit_pres_following or eit_sched turned on, so we open EPG
2586  * stream directly here.
2587  */
2588  if (!ts->epg_stream) {
2590  if (!ts->epg_stream)
2591  return;
2592  ts->epg_stream->id = EIT_PID;
2595  }
2596 
2597  if (ts->epg_stream->discard == AVDISCARD_ALL)
2598  return;
2599 
2600  p_end = section + section_len - 4;
2601  p = section;
2602 
2603  if (parse_section_header(h, &p, p_end) < 0)
2604  return;
2605  if (h->tid < EIT_TID || h->tid > OEITS_END_TID)
2606  return;
2607 
2608  av_log(ts->stream, AV_LOG_TRACE, "EIT: tid received = %.02x\n", h->tid);
2609 
2610  /**
2611  * Service_id 0xFFFF is reserved, it indicates that the current EIT table
2612  * is scrambled.
2613  */
2614  if (h->id == 0xFFFF) {
2615  av_log(ts->stream, AV_LOG_TRACE, "Scrambled EIT table received.\n");
2616  return;
2617  }
2618 
2619  /**
2620  * In case we receive an EPG packet before mpegts context is fully
2621  * initialized.
2622  */
2623  if (!ts->pkt)
2624  return;
2625 
2626  new_data_packet(section, section_len, ts->pkt);
2627  ts->pkt->stream_index = ts->epg_stream->index;
2628  ts->stop_parse = 1;
2629 }
2630 
2631 static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2632 {
2633  MpegTSContext *ts = filter->u.section_filter.opaque;
2634  MpegTSSectionFilter *tssf = &filter->u.section_filter;
2635  SectionHeader h1, *h = &h1;
2636  const uint8_t *p, *p_end, *desc_list_end, *desc_end;
2637  int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
2638  char *name, *provider_name;
2639 
2640  av_log(ts->stream, AV_LOG_TRACE, "SDT:\n");
2641  hex_dump_debug(ts->stream, section, section_len);
2642 
2643  p_end = section + section_len - 4;
2644  p = section;
2645  if (parse_section_header(h, &p, p_end) < 0)
2646  return;
2647  if (h->tid != SDT_TID)
2648  return;
2649  if (ts->skip_changes)
2650  return;
2651  if (skip_identical(h, tssf))
2652  return;
2653 
2654  onid = get16(&p, p_end);
2655  if (onid < 0)
2656  return;
2657  val = get8(&p, p_end);
2658  if (val < 0)
2659  return;
2660  for (;;) {
2661  sid = get16(&p, p_end);
2662  if (sid < 0)
2663  break;
2664  val = get8(&p, p_end);
2665  if (val < 0)
2666  break;
2667  desc_list_len = get16(&p, p_end);
2668  if (desc_list_len < 0)
2669  break;
2670  desc_list_len &= 0xfff;
2671  desc_list_end = p + desc_list_len;
2672  if (desc_list_end > p_end)
2673  break;
2674  for (;;) {
2675  desc_tag = get8(&p, desc_list_end);
2676  if (desc_tag < 0)
2677  break;
2678  desc_len = get8(&p, desc_list_end);
2679  desc_end = p + desc_len;
2680  if (desc_len < 0 || desc_end > desc_list_end)
2681  break;
2682 
2683  av_log(ts->stream, AV_LOG_TRACE, "tag: 0x%02x len=%d\n",
2684  desc_tag, desc_len);
2685 
2686  switch (desc_tag) {
2687  case 0x48:
2688  service_type = get8(&p, p_end);
2689  if (service_type < 0)
2690  break;
2691  provider_name = getstr8(&p, p_end);
2692  if (!provider_name)
2693  break;
2694  name = getstr8(&p, p_end);
2695  if (name) {
2696  AVProgram *program = av_new_program(ts->stream, sid);
2697  if (program) {
2698  av_dict_set(&program->metadata, "service_name", name, 0);
2699  av_dict_set(&program->metadata, "service_provider",
2700  provider_name, 0);
2701  }
2702  }
2703  av_free(name);
2704  av_free(provider_name);
2705  break;
2706  default:
2707  break;
2708  }
2709  p = desc_end;
2710  }
2711  p = desc_list_end;
2712  }
2713 }
2714 
2715 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
2716  const uint8_t *packet);
2717 
2718 /* handle one TS packet */
2719 static int handle_packet(MpegTSContext *ts, const uint8_t *packet, int64_t pos)
2720 {
2721  MpegTSFilter *tss;
2722  int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,
2723  has_adaptation, has_payload;
2724  const uint8_t *p, *p_end;
2725 
2726  pid = AV_RB16(packet + 1) & 0x1fff;
2727  is_start = packet[1] & 0x40;
2728  tss = ts->pids[pid];
2729  if (ts->auto_guess && !tss && is_start) {
2730  add_pes_stream(ts, pid, -1);
2731  tss = ts->pids[pid];
2732  }
2733  if (!tss)
2734  return 0;
2735  if (is_start)
2736  tss->discard = discard_pid(ts, pid);
2737  if (tss->discard)
2738  return 0;
2739  ts->current_pid = pid;
2740 
2741  afc = (packet[3] >> 4) & 3;
2742  if (afc == 0) /* reserved value */
2743  return 0;
2744  has_adaptation = afc & 2;
2745  has_payload = afc & 1;
2746  is_discontinuity = has_adaptation &&
2747  packet[4] != 0 && /* with length > 0 */
2748  (packet[5] & 0x80); /* and discontinuity indicated */
2749 
2750  /* continuity check (currently not used) */
2751  cc = (packet[3] & 0xf);
2752  expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc;
2753  cc_ok = pid == 0x1FFF || // null packet PID
2754  is_discontinuity ||
2755  tss->last_cc < 0 ||
2756  expected_cc == cc;
2757 
2758  tss->last_cc = cc;
2759  if (!cc_ok) {
2760  av_log(ts->stream, AV_LOG_DEBUG,
2761  "Continuity check failed for pid %d expected %d got %d\n",
2762  pid, expected_cc, cc);
2763  if (tss->type == MPEGTS_PES) {
2764  PESContext *pc = tss->u.pes_filter.opaque;
2765  pc->flags |= AV_PKT_FLAG_CORRUPT;
2766  }
2767  }
2768 
2769  if (packet[1] & 0x80) {
2770  av_log(ts->stream, AV_LOG_DEBUG, "Packet had TEI flag set; marking as corrupt\n");
2771  if (tss->type == MPEGTS_PES) {
2772  PESContext *pc = tss->u.pes_filter.opaque;
2773  pc->flags |= AV_PKT_FLAG_CORRUPT;
2774  }
2775  }
2776 
2777  p = packet + 4;
2778  if (has_adaptation) {
2779  int64_t pcr_h;
2780  int pcr_l;
2781  if (parse_pcr(&pcr_h, &pcr_l, packet) == 0)
2782  tss->last_pcr = pcr_h * 300 + pcr_l;
2783  /* skip adaptation field */
2784  p += p[0] + 1;
2785  }
2786  /* if past the end of packet, ignore */
2787  p_end = packet + TS_PACKET_SIZE;
2788  if (p >= p_end || !has_payload)
2789  return 0;
2790 
2791  if (pos >= 0) {
2793  ts->pos47_full = pos - TS_PACKET_SIZE;
2794  }
2795 
2796  if (tss->type == MPEGTS_SECTION) {
2797  if (is_start) {
2798  /* pointer field present */
2799  len = *p++;
2800  if (len > p_end - p)
2801  return 0;
2802  if (len && cc_ok) {
2803  /* write remaining section bytes */
2804  write_section_data(ts, tss,
2805  p, len, 0);
2806  /* check whether filter has been closed */
2807  if (!ts->pids[pid])
2808  return 0;
2809  }
2810  p += len;
2811  if (p < p_end) {
2812  write_section_data(ts, tss,
2813  p, p_end - p, 1);
2814  }
2815  } else {
2816  if (cc_ok) {
2817  write_section_data(ts, tss,
2818  p, p_end - p, 0);
2819  }
2820  }
2821 
2822  // stop find_stream_info from waiting for more streams
2823  // when all programs have received a PMT
2824  if (ts->stream->ctx_flags & AVFMTCTX_NOHEADER && ts->scan_all_pmts <= 0) {
2825  int i;
2826  for (i = 0; i < ts->nb_prg; i++) {
2827  if (!ts->prg[i].pmt_found)
2828  break;
2829  }
2830  if (i == ts->nb_prg && ts->nb_prg > 0) {
2831  int types = 0;
2832  for (i = 0; i < ts->stream->nb_streams; i++) {
2833  AVStream *st = ts->stream->streams[i];
2834  if (st->codecpar->codec_type >= 0)
2835  types |= 1<<st->codecpar->codec_type;
2836  }
2837  if ((types & (1<<AVMEDIA_TYPE_AUDIO) && types & (1<<AVMEDIA_TYPE_VIDEO)) || pos > 100000) {
2838  av_log(ts->stream, AV_LOG_DEBUG, "All programs have pmt, headers found\n");
2840  }
2841  }
2842  }
2843 
2844  } else {
2845  int ret;
2846  // Note: The position here points actually behind the current packet.
2847  if (tss->type == MPEGTS_PES) {
2848  if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
2849  pos - ts->raw_packet_size)) < 0)
2850  return ret;
2851  }
2852  }
2853 
2854  return 0;
2855 }
2856 
2857 static int mpegts_resync(AVFormatContext *s, int seekback, const uint8_t *current_packet)
2858 {
2859  MpegTSContext *ts = s->priv_data;
2860  AVIOContext *pb = s->pb;
2861  int c, i;
2862  uint64_t pos = avio_tell(pb);
2863  int64_t back = FFMIN(seekback, pos);
2864 
2865  //Special case for files like 01c56b0dc1.ts
2866  if (current_packet[0] == 0x80 && current_packet[12] == 0x47) {
2867  avio_seek(pb, 12 - back, SEEK_CUR);
2868  return 0;
2869  }
2870 
2871  avio_seek(pb, -back, SEEK_CUR);
2872 
2873  for (i = 0; i < ts->resync_size; i++) {
2874  c = avio_r8(pb);
2875  if (avio_feof(pb))
2876  return AVERROR_EOF;
2877  if (c == 0x47) {
2878  int new_packet_size, ret;
2879  avio_seek(pb, -1, SEEK_CUR);
2880  pos = avio_tell(pb);
2882  if (ret < 0)
2883  return ret;
2884  new_packet_size = get_packet_size(s);
2885  if (new_packet_size > 0 && new_packet_size != ts->raw_packet_size) {
2886  av_log(ts->stream, AV_LOG_WARNING, "changing packet size to %d\n", new_packet_size);
2887  ts->raw_packet_size = new_packet_size;
2888  }
2889  avio_seek(pb, pos, SEEK_SET);
2890  return 0;
2891  }
2892  }
2894  "max resync size reached, could not find sync byte\n");
2895  /* no sync found */
2896  return AVERROR_INVALIDDATA;
2897 }
2898 
2899 /* return AVERROR_something if error or EOF. Return 0 if OK. */
2900 static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size,
2901  const uint8_t **data)
2902 {
2903  AVIOContext *pb = s->pb;
2904  int len;
2905 
2906  for (;;) {
2908  if (len != TS_PACKET_SIZE)
2909  return len < 0 ? len : AVERROR_EOF;
2910  /* check packet sync byte */
2911  if ((*data)[0] != 0x47) {
2912  /* find a new packet start */
2913 
2914  if (mpegts_resync(s, raw_packet_size, *data) < 0)
2915  return AVERROR(EAGAIN);
2916  else
2917  continue;
2918  } else {
2919  break;
2920  }
2921  }
2922  return 0;
2923 }
2924 
2925 static void finished_reading_packet(AVFormatContext *s, int raw_packet_size)
2926 {
2927  AVIOContext *pb = s->pb;
2928  int skip = raw_packet_size - TS_PACKET_SIZE;
2929  if (skip > 0)
2930  avio_skip(pb, skip);
2931 }
2932 
2933 static int handle_packets(MpegTSContext *ts, int64_t nb_packets)
2934 {
2935  AVFormatContext *s = ts->stream;
2936  uint8_t packet[TS_PACKET_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
2937  const uint8_t *data;
2938  int64_t packet_num;
2939  int ret = 0;
2940 
2941  if (avio_tell(s->pb) != ts->last_pos) {
2942  int i;
2943  av_log(ts->stream, AV_LOG_TRACE, "Skipping after seek\n");
2944  /* seek detected, flush pes buffer */
2945  for (i = 0; i < NB_PID_MAX; i++) {
2946  if (ts->pids[i]) {
2947  if (ts->pids[i]->type == MPEGTS_PES) {
2948  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
2949  av_buffer_unref(&pes->buffer);
2950  pes->data_index = 0;
2951  pes->state = MPEGTS_SKIP; /* skip until pes header */
2952  } else if (ts->pids[i]->type == MPEGTS_SECTION) {
2953  ts->pids[i]->u.section_filter.last_ver = -1;
2954  }
2955  ts->pids[i]->last_cc = -1;
2956  ts->pids[i]->last_pcr = -1;
2957  }
2958  }
2959  }
2960 
2961  ts->stop_parse = 0;
2962  packet_num = 0;
2963  memset(packet + TS_PACKET_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2964  for (;;) {
2965  packet_num++;
2966  if (nb_packets != 0 && packet_num >= nb_packets ||
2967  ts->stop_parse > 1) {
2968  ret = AVERROR(EAGAIN);
2969  break;
2970  }
2971  if (ts->stop_parse > 0)
2972  break;
2973 
2974  ret = read_packet(s, packet, ts->raw_packet_size, &data);
2975  if (ret != 0)
2976  break;
2977  ret = handle_packet(ts, data, avio_tell(s->pb));
2979  if (ret != 0)
2980  break;
2981  }
2982  ts->last_pos = avio_tell(s->pb);
2983  return ret;
2984 }
2985 
2986 static int mpegts_probe(const AVProbeData *p)
2987 {
2988  const int size = p->buf_size;
2989  int maxscore = 0;
2990  int sumscore = 0;
2991  int i;
2992  int check_count = size / TS_FEC_PACKET_SIZE;
2993 #define CHECK_COUNT 10
2994 #define CHECK_BLOCK 100
2995 
2996  if (!check_count)
2997  return 0;
2998 
2999  for (i = 0; i<check_count; i+=CHECK_BLOCK) {
3000  int left = FFMIN(check_count - i, CHECK_BLOCK);
3001  int score = analyze(p->buf + TS_PACKET_SIZE *i, TS_PACKET_SIZE *left, TS_PACKET_SIZE , 1);
3004  score = FFMAX3(score, dvhs_score, fec_score);
3005  sumscore += score;
3006  maxscore = FFMAX(maxscore, score);
3007  }
3008 
3009  sumscore = sumscore * CHECK_COUNT / check_count;
3010  maxscore = maxscore * CHECK_COUNT / CHECK_BLOCK;
3011 
3012  ff_dlog(0, "TS score: %d %d\n", sumscore, maxscore);
3013 
3014  if (check_count > CHECK_COUNT && sumscore > 6) {
3015  return AVPROBE_SCORE_MAX + sumscore - CHECK_COUNT;
3016  } else if (check_count >= CHECK_COUNT && sumscore > 6) {
3017  return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT;
3018  } else if (check_count >= CHECK_COUNT && maxscore > 6) {
3019  return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT;
3020  } else if (sumscore > 6) {
3021  return 2;
3022  } else {
3023  return 0;
3024  }
3025 }
3026 
3027 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
3028  * (-1) if not available */
3029 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet)
3030 {
3031  int afc, len, flags;
3032  const uint8_t *p;
3033  unsigned int v;
3034 
3035  afc = (packet[3] >> 4) & 3;
3036  if (afc <= 1)
3037  return AVERROR_INVALIDDATA;
3038  p = packet + 4;
3039  len = p[0];
3040  p++;
3041  if (len == 0)
3042  return AVERROR_INVALIDDATA;
3043  flags = *p++;
3044  len--;
3045  if (!(flags & 0x10))
3046  return AVERROR_INVALIDDATA;
3047  if (len < 6)
3048  return AVERROR_INVALIDDATA;
3049  v = AV_RB32(p);
3050  *ppcr_high = ((int64_t) v << 1) | (p[4] >> 7);
3051  *ppcr_low = ((p[4] & 1) << 8) | p[5];
3052  return 0;
3053 }
3054 
3055 static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos) {
3056 
3057  /* NOTE: We attempt to seek on non-seekable files as well, as the
3058  * probe buffer usually is big enough. Only warn if the seek failed
3059  * on files where the seek should work. */
3060  if (avio_seek(pb, pos, SEEK_SET) < 0)
3061  av_log(s, (pb->seekable & AVIO_SEEKABLE_NORMAL) ? AV_LOG_ERROR : AV_LOG_INFO, "Unable to seek back to the start\n");
3062 }
3063 
3065 {
3066  MpegTSContext *ts = s->priv_data;
3067  AVIOContext *pb = s->pb;
3068  int64_t pos, probesize = s->probesize;
3069  int64_t seekback = FFMAX(s->probesize, (int64_t)ts->resync_size + PROBE_PACKET_MAX_BUF);
3070 
3071  s->internal->prefer_codec_framerate = 1;
3072 
3073  if (ffio_ensure_seekback(pb, seekback) < 0)
3074  av_log(s, AV_LOG_WARNING, "Failed to allocate buffers for seekback\n");
3075 
3076  pos = avio_tell(pb);
3078  if (ts->raw_packet_size <= 0) {
3079  av_log(s, AV_LOG_WARNING, "Could not detect TS packet size, defaulting to non-FEC/DVHS\n");
3081  }
3082  ts->stream = s;
3083  ts->auto_guess = 0;
3084 
3085  if (s->iformat == &ff_mpegts_demuxer) {
3086  /* normal demux */
3087 
3088  /* first do a scan to get all the services */
3089  seek_back(s, pb, pos);
3090 
3094 
3095  handle_packets(ts, probesize / ts->raw_packet_size);
3096  /* if could not find service, enable auto_guess */
3097 
3098  ts->auto_guess = 1;
3099 
3100  av_log(ts->stream, AV_LOG_TRACE, "tuning done\n");
3101 
3102  s->ctx_flags |= AVFMTCTX_NOHEADER;
3103  } else {
3104  AVStream *st;
3105  int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
3106  int64_t pcrs[2], pcr_h;
3107  uint8_t packet[TS_PACKET_SIZE];
3108  const uint8_t *data;
3109 
3110  /* only read packets */
3111 
3112  st = avformat_new_stream(s, NULL);
3113  if (!st)
3114  return AVERROR(ENOMEM);
3115  avpriv_set_pts_info(st, 60, 1, 27000000);
3118 
3119  /* we iterate until we find two PCRs to estimate the bitrate */
3120  pcr_pid = -1;
3121  nb_pcrs = 0;
3122  nb_packets = 0;
3123  for (;;) {
3124  ret = read_packet(s, packet, ts->raw_packet_size, &data);
3125  if (ret < 0)
3126  return ret;
3127  pid = AV_RB16(data + 1) & 0x1fff;
3128  if ((pcr_pid == -1 || pcr_pid == pid) &&
3129  parse_pcr(&pcr_h, &pcr_l, data) == 0) {
3131  pcr_pid = pid;
3132  pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
3133  nb_pcrs++;
3134  if (nb_pcrs >= 2) {
3135  if (pcrs[1] - pcrs[0] > 0) {
3136  /* the difference needs to be positive to make sense for bitrate computation */
3137  break;
3138  } else {
3139  av_log(ts->stream, AV_LOG_WARNING, "invalid pcr pair %"PRId64" >= %"PRId64"\n", pcrs[0], pcrs[1]);
3140  pcrs[0] = pcrs[1];
3141  nb_pcrs--;
3142  }
3143  }
3144  } else {
3146  }
3147  nb_packets++;
3148  }
3149 
3150  /* NOTE1: the bitrate is computed without the FEC */
3151  /* NOTE2: it is only the bitrate of the start of the stream */
3152  ts->pcr_incr = pcrs[1] - pcrs[0];
3153  ts->cur_pcr = pcrs[0] - ts->pcr_incr * (nb_packets - 1);
3154  s->bit_rate = TS_PACKET_SIZE * 8 * 27000000LL / ts->pcr_incr;
3155  st->codecpar->bit_rate = s->bit_rate;
3156  st->start_time = ts->cur_pcr;
3157  av_log(ts->stream, AV_LOG_TRACE, "start=%0.3f pcr=%0.3f incr=%"PRId64"\n",
3158  st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
3159  }
3160 
3161  seek_back(s, pb, pos);
3162  return 0;
3163 }
3164 
3165 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
3166 
3168 {
3169  MpegTSContext *ts = s->priv_data;
3170  int ret, i;
3171  int64_t pcr_h, next_pcr_h, pos;
3172  int pcr_l, next_pcr_l;
3173  uint8_t pcr_buf[12];
3174  const uint8_t *data;
3175 
3176  if ((ret = av_new_packet(pkt, TS_PACKET_SIZE)) < 0)
3177  return ret;
3179  pkt->pos = avio_tell(s->pb);
3180  if (ret < 0) {
3181  return ret;
3182  }
3183  if (data != pkt->data)
3184  memcpy(pkt->data, data, TS_PACKET_SIZE);
3186  if (ts->mpeg2ts_compute_pcr) {
3187  /* compute exact PCR for each packet */
3188  if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
3189  /* we read the next PCR (XXX: optimize it by using a bigger buffer */
3190  pos = avio_tell(s->pb);
3191  for (i = 0; i < MAX_PACKET_READAHEAD; i++) {
3192  avio_seek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
3193  avio_read(s->pb, pcr_buf, 12);
3194  if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
3195  /* XXX: not precise enough */
3196  ts->pcr_incr =
3197  ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
3198  (i + 1);
3199  break;
3200  }
3201  }
3202  avio_seek(s->pb, pos, SEEK_SET);
3203  /* no next PCR found: we use previous increment */
3204  ts->cur_pcr = pcr_h * 300 + pcr_l;
3205  }
3206  pkt->pts = ts->cur_pcr;
3207  pkt->duration = ts->pcr_incr;
3208  ts->cur_pcr += ts->pcr_incr;
3209  }
3210  pkt->stream_index = 0;
3211  return 0;
3212 }
3213 
3215 {
3216  MpegTSContext *ts = s->priv_data;
3217  int ret, i;
3218 
3219  pkt->size = -1;
3220  ts->pkt = pkt;
3221  ret = handle_packets(ts, 0);
3222  if (ret < 0) {
3223  av_packet_unref(ts->pkt);
3224  /* flush pes data left */
3225  for (i = 0; i < NB_PID_MAX; i++)
3226  if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
3227  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
3228  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
3229  ret = new_pes_packet(pes, pkt);
3230  if (ret < 0)
3231  return ret;
3232  pes->state = MPEGTS_SKIP;
3233  ret = 0;
3234  break;
3235  }
3236  }
3237  }
3238 
3239  if (!ret && pkt->size < 0)
3241  return ret;
3242 }
3243 
3244 static void mpegts_free(MpegTSContext *ts)
3245 {
3246  int i;
3247 
3248  clear_programs(ts);
3249 
3250  for (i = 0; i < FF_ARRAY_ELEMS(ts->pools); i++)
3251  av_buffer_pool_uninit(&ts->pools[i]);
3252 
3253  for (i = 0; i < NB_PID_MAX; i++)
3254  if (ts->pids[i])
3255  mpegts_close_filter(ts, ts->pids[i]);
3256 }
3257 
3259 {
3260  MpegTSContext *ts = s->priv_data;
3261  mpegts_free(ts);
3262  return 0;
3263 }
3264 
3265 static av_unused int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
3266  int64_t *ppos, int64_t pos_limit)
3267 {
3268  MpegTSContext *ts = s->priv_data;
3269  int64_t pos, timestamp;
3270  uint8_t buf[TS_PACKET_SIZE];
3271  int pcr_l, pcr_pid =
3272  ((PESContext *)s->streams[stream_index]->priv_data)->pcr_pid;
3273  int pos47 = ts->pos47_full % ts->raw_packet_size;
3274  pos =
3275  ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) *
3276  ts->raw_packet_size + pos47;
3277  while(pos < pos_limit) {
3278  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
3279  return AV_NOPTS_VALUE;
3280  if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
3281  return AV_NOPTS_VALUE;
3282  if (buf[0] != 0x47) {
3283  if (mpegts_resync(s, TS_PACKET_SIZE, buf) < 0)
3284  return AV_NOPTS_VALUE;
3285  pos = avio_tell(s->pb);
3286  continue;
3287  }
3288  if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
3289  parse_pcr(&timestamp, &pcr_l, buf) == 0) {
3290  *ppos = pos;
3291  return timestamp;
3292  }
3293  pos += ts->raw_packet_size;
3294  }
3295 
3296  return AV_NOPTS_VALUE;
3297 }
3298 
3299 static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index,
3300  int64_t *ppos, int64_t pos_limit)
3301 {
3302  MpegTSContext *ts = s->priv_data;
3303  AVPacket *pkt;
3304  int64_t pos;
3305  int pos47 = ts->pos47_full % ts->raw_packet_size;
3306  pos = ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) * ts->raw_packet_size + pos47;
3308  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
3309  return AV_NOPTS_VALUE;
3310  pkt = av_packet_alloc();
3311  if (!pkt)
3312  return AV_NOPTS_VALUE;
3313  while(pos < pos_limit) {
3314  int ret = av_read_frame(s, pkt);
3315  if (ret < 0) {
3316  av_packet_free(&pkt);
3317  return AV_NOPTS_VALUE;
3318  }
3319  if (pkt->dts != AV_NOPTS_VALUE && pkt->pos >= 0) {
3321  av_add_index_entry(s->streams[pkt->stream_index], pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
3322  if (pkt->stream_index == stream_index && pkt->pos >= *ppos) {
3323  int64_t dts = pkt->dts;
3324  *ppos = pkt->pos;
3325  av_packet_free(&pkt);
3326  return dts;
3327  }
3328  }
3329  pos = pkt->pos;
3331  }
3332 
3333  av_packet_free(&pkt);
3334  return AV_NOPTS_VALUE;
3335 }
3336 
3337 /**************************************************************/
3338 /* parsing functions - called from other demuxers such as RTP */
3339 
3341 {
3342  MpegTSContext *ts;
3343 
3344  ts = av_mallocz(sizeof(MpegTSContext));
3345  if (!ts)
3346  return NULL;
3347  /* no stream case, currently used by RTP */
3349  ts->stream = s;
3350  ts->auto_guess = 1;
3351 
3355 
3356  return ts;
3357 }
3358 
3359 /* return the consumed length if a packet was output, or -1 if no
3360  * packet is output */
3362  const uint8_t *buf, int len)
3363 {
3364  int len1;
3365 
3366  len1 = len;
3367  ts->pkt = pkt;
3368  for (;;) {
3369  ts->stop_parse = 0;
3370  if (len < TS_PACKET_SIZE)
3371  return AVERROR_INVALIDDATA;
3372  if (buf[0] != 0x47) {
3373  buf++;
3374  len--;
3375  } else {
3376  handle_packet(ts, buf, len1 - len + TS_PACKET_SIZE);
3377  buf += TS_PACKET_SIZE;
3378  len -= TS_PACKET_SIZE;
3379  if (ts->stop_parse == 1)
3380  break;
3381  }
3382  }
3383  return len1 - len;
3384 }
3385 
3387 {
3388  mpegts_free(ts);
3389  av_free(ts);
3390 }
3391 
3393  .name = "mpegts",
3394  .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
3395  .priv_data_size = sizeof(MpegTSContext),
3400  .read_timestamp = mpegts_get_dts,
3402  .priv_class = &mpegts_class,
3403 };
3404 
3406  .name = "mpegtsraw",
3407  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"),
3408  .priv_data_size = sizeof(MpegTSContext),
3412  .read_timestamp = mpegts_get_dts,
3414  .priv_class = &mpegtsraw_class,
3415 };
parse_MP4DecConfigDescrTag
static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1529
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:891
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:404
parse_mp4_descr_arr
static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1471
new_pes_packet
static int new_pes_packet(PESContext *pes, AVPacket *pkt)
Definition: mpegts.c:989
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:266
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:1433
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:311
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:425
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:4374
MAX_LEVEL
#define MAX_LEVEL
Definition: mpegts.c:1427
AV_CODEC_ID_PCM_BLURAY
@ AV_CODEC_ID_PCM_BLURAY
Definition: codec_id.h:337
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:1034
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
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
TS_DVHS_PACKET_SIZE
#define TS_DVHS_PACKET_SIZE
Definition: mpegts.h:28
AVStreamInternal::avctx
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:202
pmt_cb
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:2275
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:78
MpegTSFilter::pid
int pid
Definition: mpegts.c:98
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:675
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:856
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
avpriv_mpegts_parse_packet
int avpriv_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt, const uint8_t *buf, int len)
Definition: mpegts.c:3361
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
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
avcodec_get_type
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
Definition: codec_desc.c:3532
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:896
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:4103
mpegts_close_filter
static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
Definition: mpegts.c:553
AV_CODEC_ID_DIRAC
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:166
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:858
av_unused
#define av_unused
Definition: attributes.h:131
MP4DescrParseContext::max_descr_count
int max_descr_count
Definition: mpegts.c:1434
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:1175
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:874
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:527
PESContext::total_size
int total_size
Definition: mpegts.c:257
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1009
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
MpegTSState
MpegTSState
Definition: mpegts.c:232
MP4SLDescrTag
#define MP4SLDescrTag
Definition: isom.h:313
AVStreamInternal::probe_packets
int probe_packets
Number of packets to buffer for codec probing.
Definition: internal.h:383
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
MP4DescrParseContext::s
AVFormatContext * s
Definition: mpegts.c:1429
buffer_pool_get
static AVBufferRef * buffer_pool_get(MpegTSContext *ts, int size)
Definition: mpegts.c:1107
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:1276
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
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: utils.c:1668
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:715
Stream::idx
int idx
Definition: mpegts.c:111
AV_CODEC_ID_HDMV_PGS_SUBTITLE
@ AV_CODEC_ID_HDMV_PGS_SUBTITLE
Definition: codec_id.h:526
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:466
MAX_PES_PAYLOAD
#define MAX_PES_PAYLOAD
Definition: mpegts.c:50
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:70
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:560
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:785
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:3258
mpegts_raw_read_packet
static int mpegts_raw_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegts.c:3167
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:2206
update_av_program_info
static void update_av_program_info(AVFormatContext *s, unsigned int programid, unsigned int pid, int version)
Definition: mpegts.c:344
MP4ODescrTag
#define MP4ODescrTag
Definition: isom.h:308
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
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: utils.c:1940
pat_cb
static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:2492
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:1638
AVProgram::discard
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:1032
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:831
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:538
SectionHeader::last_sec_num
uint8_t last_sec_num
Definition: mpegts.c:646
val
static double val(void *priv, double ch)
Definition: aeval.c:75
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:309
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:4456
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:423
MpegTSFilter::u
union MpegTSFilter::@266 u
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:521
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:807
PESContext::header
uint8_t header[MAX_PES_HEADER_SIZE]
Definition: mpegts.c:263
avassert.h
AVStreamInternal::stream_identifier
int stream_identifier
Stream Identifier This is the MPEG-TS stream identifier +1 0 means unknown.
Definition: internal.h:399
MPEGTS_OPTIONS
#define MPEGTS_OPTIONS
Definition: mpegts.c:182
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:764
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:3386
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:626
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:405
Mp4Descr::sl
SLConfigDescr sl
Definition: mpegts.h:193
opus_coupled_stream_cnt
static const uint8_t opus_coupled_stream_cnt[9]
Definition: mpegts.c:1762
AVFormatContext::ctx_flags
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1156
AVProgram::id
int id
Definition: avformat.h:1030
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:1781
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:3029
AV_CODEC_ID_S302M
@ AV_CODEC_ID_S302M
Definition: codec_id.h:339
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:373
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:567
FFMAX3
#define FFMAX3(a, b, c)
Definition: common.h:104
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:94
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:3265
mpegts_class
static const AVClass mpegts_class
Definition: mpegts.c:204
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1275
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:631
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
AVStreamInternal::pts_wrap_behavior
int pts_wrap_behavior
Options for behavior, when a wrap is detected.
Definition: internal.h:334
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
FF_PROFILE_ARIB_PROFILE_C
#define FF_PROFILE_ARIB_PROFILE_C
Definition: avcodec.h:1637
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:1522
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
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:1482
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:1766
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:545
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
MP4ESDescrTag
#define MP4ESDescrTag
Definition: isom.h:310
MP4DescrParseContext::active_descr
Mp4Descr * active_descr
Definition: mpegts.c:1432
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1107
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:994
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:125
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:1056
isom.h
AV_CODEC_ID_TIMED_ID3
@ AV_CODEC_ID_TIMED_ID3
Definition: codec_id.h:559
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:865
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:5340
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:2577
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:308
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:3055
SLConfigDescr::ocr_len
int ocr_len
Definition: mpegts.h:181
AVProgram::stream_index
unsigned int * stream_index
Definition: avformat.h:1033
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:905
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:565
add_pes_stream
static PESContext * add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
Definition: mpegts.c:1403
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:557
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:1439
MAX_PES_HEADER_SIZE
#define MAX_PES_HEADER_SIZE
Definition: mpegts.c:243
MAX_PACKET_READAHEAD
#define MAX_PACKET_READAHEAD
Definition: mpegts.c:3165
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:1494
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:1120
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:982
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:462
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:1163
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:424
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
ffio_init_context
int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:78
AVMediaType
AVMediaType
Definition: avutil.h:199
MP4DescrParseContext::descr
Mp4Descr * descr
Definition: mpegts.c:1431
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:116
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
SectionHeader::tid
uint8_t tid
Definition: mpegts.c:642
reset_pes_packet_state
static void reset_pes_packet_state(PESContext *pes)
Definition: mpegts.c:973
AVStreamInternal::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:272
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4799
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:426
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:2925
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
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:3299
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:482
AVStreamInternal::pts_wrap_reference
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: internal.h:322
mpegts_read_packet
static int mpegts_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegts.c:3214
parse_MP4ESDescrTag
static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1508
buffer.h
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:805
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:607
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
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:212
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:981
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
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:59
version
version
Definition: libkvazaar.c:307
handle_packet
static int handle_packet(MpegTSContext *ts, const uint8_t *packet, int64_t pos)
Definition: mpegts.c:2719
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:1461
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:2269
FF_PROFILE_ARIB_PROFILE_A
#define FF_PROFILE_ARIB_PROFILE_A
Definition: avcodec.h:1636
i
int i
Definition: input.c:406
SectionHeader
Definition: mpegts.c:641
ISO_639_LANGUAGE_DESCRIPTOR
#define ISO_639_LANGUAGE_DESCRIPTOR
Definition: mpegts.h:158
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
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
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
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:2233
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:3392
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
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:552
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:2857
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
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:243
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1029
handle_packets
static int handle_packets(MpegTSContext *ts, int64_t nb_packets)
Definition: mpegts.c:2933
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:830
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
MP4DescrParseContext::pb
AVIOContext pb
Definition: mpegts.c:1430
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:894
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:806
MP4DescrParseContext
Definition: mpegts.c:1428
tag
uint32_t tag
Definition: movenc.c:1594
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:854
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:847
MpegTSSectionFilter::last_ver
int last_ver
Definition: mpegts.c:87
AVFormatContext::ts_id
int ts_id
Transport stream id.
Definition: avformat.h:1448
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:243
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
AVStreamInternal::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
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:749
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:1654
scte_data_cb
static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1733
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:1670
dict.h
AV_DISPOSITION_DESCRIPTIONS
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:828
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:76
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:848
R8_CHECK_CLIP_MAX
#define R8_CHECK_CLIP_MAX(dst, maxv)
probe
static int probe(const AVProbeData *p)
Definition: act.c:36
mpegts_probe
static int mpegts_probe(const AVProbeData *p)
Definition: mpegts.c:2986
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:220
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: utils.c:1868
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
NB_PID_MAX
#define NB_PID_MAX
Definition: mpegts.h:32
AVDOVIDecoderConfigurationRecord::bl_present_flag
uint8_t bl_present_flag
Definition: dovi_meta.h: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:616
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:1543
avpriv_mpegts_parse_open
MpegTSContext * avpriv_mpegts_parse_open(AVFormatContext *s)
Definition: mpegts.c:3340
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:3244
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
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:327
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:43
read_sl_header
static int read_sl_header(PESContext *pes, SLConfigDescr *sl, const uint8_t *buf, int buf_size)
Definition: mpegts.c:1036
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:469
AVStreamInternal::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:219
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:3064
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
MPEGTS_PCR
@ MPEGTS_PCR
Definition: mpegts.c:67
Program::id
unsigned int id
Definition: mpegts.c:118
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: utils.c:1819
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:4878
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
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:1436
Stream
Definition: mpegts.c:110
d
d
Definition: ffmpeg_filter.c:156
MP4DescrParseContext::level
int level
Definition: mpegts.c:1435
bytestream.h
convert_header.str
string str
Definition: convert_header.py:20
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:768
MpegTSContext::skip_unknown_pmt
int skip_unknown_pmt
Definition: mpegts.c:159
raw_options
static const AVOption raw_options[]
Definition: mpegts.c:211
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:1770
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:471
ff_mpegtsraw_demuxer
const AVInputFormat ff_mpegtsraw_demuxer
Definition: mpegts.c:3405
parse_mp4_descr
static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len, int target_tag)
Definition: mpegts.c:1585
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AV_CODEC_ID_HDMV_TEXT_SUBTITLE
@ AV_CODEC_ID_HDMV_TEXT_SUBTITLE
Definition: codec_id.h:543
TS_PACKET_SIZE
#define TS_PACKET_SIZE
Definition: mpegts.h:29
MpegTSSectionFilter::section_cb
SectionCallback * section_cb
Definition: mpegts.c:93
PROBE_PACKET_MARGIN
#define PROBE_PACKET_MARGIN
Definition: mpegts.c:62
h
h
Definition: vp9dsp_template.c:2038
get_ts64
static uint64_t get_ts64(GetBitContext *gb, int bits)
Definition: mpegts.c:1029
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:880
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:2900
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:842
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:1039
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:687
sdt_cb
static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:2631
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:3264
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:354
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:551
StreamType::codec_type
enum AVMediaType codec_type
Definition: mpegts.c:786