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