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