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