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