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