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