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