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