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