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 
67 enum MpegTSFilterType {
68  MPEGTS_PES,
69  MPEGTS_SECTION,
70  MPEGTS_PCR,
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 {
79  PESCallback *pes_cb;
80  void *opaque;
81 } MpegTSPESFilter;
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 {
88  int section_index;
89  int section_h_size;
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;
96  SectionCallback *section_cb;
97  void *opaque;
98 } MpegTSSectionFilter;
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;
106  enum MpegTSFilterType type;
107  union {
108  MpegTSPESFilter pes_filter;
109  MpegTSSectionFilter section_filter;
110  } u;
111 };
112 
113 struct Stream {
114  int idx;
115  int stream_identifier;
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;
125  struct Stream streams[MAX_STREAMS_PER_PROGRAM];
126 
127  /** have we found pmt for this program */
128  int pmt_found;
129 };
130 
131 struct MpegTSContext {
132  const AVClass *class;
133  /* user data */
134  AVFormatContext *stream;
135  /** raw packet size, including FEC if present */
136  int raw_packet_size;
137 
138  int64_t pos47_full;
139 
140  /** if true, all pids are analyzed to find streams */
141  int auto_guess;
142 
143  /** compute exact PCR for each transport stream packet */
144  int mpeg2ts_compute_pcr;
145 
146  /** fix dvb teletext pts */
147  int fix_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 */
154  int stop_parse;
155  /** packet containing Audio/Video data */
156  AVPacket *pkt;
157  /** to detect seek */
158  int64_t last_pos;
159 
160  int skip_changes;
161  int skip_clear;
162  int skip_unknown_pmt;
163 
164  int scan_all_pmts;
165 
166  int resync_size;
167  int merge_pmt_versions;
168  int max_packet_size;
169 
170  /******************************************/
171  /* private mpegts data */
172  /* scan context */
173  /** structure to keep track of Program->pids mapping */
174  unsigned int nb_prg;
175  struct Program *prg;
176 
177  int8_t crc_validity[NB_PID_MAX];
178  /** filters for various streams specified by PMT + for the PAT and PMT */
179  MpegTSFilter *pids[NB_PID_MAX];
180  int current_pid;
181 
182  AVStream *epg_stream;
183  AVBufferPool* pools[32];
184 };
185 
186 #define MPEGTS_OPTIONS \
187  { "resync_size", "set size limit for looking up a new synchronization", offsetof(MpegTSContext, resync_size), AV_OPT_TYPE_INT, { .i64 = MAX_RESYNC_SIZE}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM }
188 
189 static const AVOption options[] = {
190  MPEGTS_OPTIONS,
191  {"fix_teletext_pts", "try to fix pts values of dvb teletext streams", offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_BOOL,
192  {.i64 = 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
193  {"ts_packetsize", "output option carrying the raw packet size", offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
194  {.i64 = 0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },
195  {"scan_all_pmts", "scan and combine all PMTs", offsetof(MpegTSContext, scan_all_pmts), AV_OPT_TYPE_BOOL,
196  {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM },
197  {"skip_unknown_pmt", "skip PMTs for programs not advertised in the PAT", offsetof(MpegTSContext, skip_unknown_pmt), AV_OPT_TYPE_BOOL,
198  {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
199  {"merge_pmt_versions", "re-use streams when PMT's version/pids change", offsetof(MpegTSContext, merge_pmt_versions), AV_OPT_TYPE_BOOL,
200  {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
201  {"skip_changes", "skip changing / adding streams / programs", offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_BOOL,
202  {.i64 = 0}, 0, 1, 0 },
203  {"skip_clear", "skip clearing programs", offsetof(MpegTSContext, skip_clear), AV_OPT_TYPE_BOOL,
204  {.i64 = 0}, 0, 1, 0 },
205  {"max_packet_size", "maximum size of emitted packet", offsetof(MpegTSContext, max_packet_size), AV_OPT_TYPE_INT,
206  {.i64 = 204800}, 1, INT_MAX/2, AV_OPT_FLAG_DECODING_PARAM },
207  { NULL },
208 };
209 
210 static const AVClass mpegts_class = {
211  .class_name = "mpegts demuxer",
212  .item_name = av_default_item_name,
213  .option = options,
214  .version = LIBAVUTIL_VERSION_INT,
215 };
216 
217 static const AVOption raw_options[] = {
218  MPEGTS_OPTIONS,
219  { "compute_pcr", "compute exact PCR for each transport stream packet",
220  offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_BOOL,
221  { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
222  { "ts_packetsize", "output option carrying the raw packet size",
223  offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
224  { .i64 = 0 }, 0, 0,
225  AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },
226  { NULL },
227 };
228 
229 static const AVClass mpegtsraw_class = {
230  .class_name = "mpegtsraw demuxer",
231  .item_name = av_default_item_name,
232  .option = raw_options,
233  .version = LIBAVUTIL_VERSION_INT,
234 };
235 
236 /* TS stream handling */
237 
238 enum MpegTSState {
239  MPEGTS_HEADER = 0,
240  MPEGTS_PESHEADER,
241  MPEGTS_PESHEADER_FILL,
242  MPEGTS_PAYLOAD,
243  MPEGTS_SKIP,
244 };
245 
246 /* enough for PES header + length */
247 #define PES_START_SIZE 6
248 #define PES_HEADER_SIZE 9
249 #define MAX_PES_HEADER_SIZE (9 + 255)
250 
251 typedef struct PESContext {
252  int pid;
253  int pcr_pid; /**< if -1 then all packets containing PCR are considered */
254  int stream_type;
255  MpegTSContext *ts;
256  AVFormatContext *stream;
257  AVStream *st;
258  AVStream *sub_st; /**< stream for the embedded AC3 stream in HDMV TrueHD */
259  enum MpegTSState state;
260  /* used to get the format */
261  int data_index;
262  int flags; /**< copied to the AVPacket flags */
263  int PES_packet_length;
264  int pes_header_size;
265  int extended_stream_id;
266  uint8_t stream_id;
267  int64_t pts, dts;
268  int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */
269  uint8_t header[MAX_PES_HEADER_SIZE];
270  AVBufferRef *buffer;
271  SLConfigDescr sl;
272  int merged_st;
273 } PESContext;
274 
275 extern const AVInputFormat ff_mpegts_demuxer;
276 
277 static struct Program * get_program(MpegTSContext *ts, unsigned int programid)
278 {
279  int i;
280  for (i = 0; i < ts->nb_prg; i++) {
281  if (ts->prg[i].id == programid) {
282  return &ts->prg[i];
283  }
284  }
285  return NULL;
286 }
287 
288 static void clear_avprogram(MpegTSContext *ts, unsigned int programid)
289 {
290  AVProgram *prg = NULL;
291  int i;
292 
293  for (i = 0; i < ts->stream->nb_programs; i++)
294  if (ts->stream->programs[i]->id == programid) {
295  prg = ts->stream->programs[i];
296  break;
297  }
298  if (!prg)
299  return;
300  prg->nb_stream_indexes = 0;
301 }
302 
303 static void clear_program(struct Program *p)
304 {
305  if (!p)
306  return;
307  p->nb_pids = 0;
308  p->nb_streams = 0;
309  p->pmt_found = 0;
310 }
311 
312 static void clear_programs(MpegTSContext *ts)
313 {
314  av_freep(&ts->prg);
315  ts->nb_prg = 0;
316 }
317 
318 static struct Program * add_program(MpegTSContext *ts, unsigned int programid)
319 {
320  struct Program *p = get_program(ts, programid);
321  if (p)
322  return p;
323  if (av_reallocp_array(&ts->prg, ts->nb_prg + 1, sizeof(*ts->prg)) < 0) {
324  ts->nb_prg = 0;
325  return NULL;
326  }
327  p = &ts->prg[ts->nb_prg];
328  p->id = programid;
329  clear_program(p);
330  ts->nb_prg++;
331  return p;
332 }
333 
334 static void add_pid_to_program(struct Program *p, unsigned int pid)
335 {
336  int i;
337  if (!p)
338  return;
339 
340  if (p->nb_pids >= MAX_PIDS_PER_PROGRAM)
341  return;
342 
343  for (i = 0; i < p->nb_pids; i++)
344  if (p->pids[i] == pid)
345  return;
346 
347  p->pids[p->nb_pids++] = pid;
348 }
349 
350 static void update_av_program_info(AVFormatContext *s, unsigned int programid,
351  unsigned int pid, int version)
352 {
353  int i;
354  for (i = 0; i < s->nb_programs; i++) {
355  AVProgram *program = s->programs[i];
356  if (program->id == programid) {
357  int old_pcr_pid = program->pcr_pid,
358  old_version = program->pmt_version;
359  program->pcr_pid = pid;
360  program->pmt_version = version;
361 
362  if (old_version != -1 && old_version != version) {
363  av_log(s, AV_LOG_VERBOSE,
364  "detected PMT change (program=%d, version=%d/%d, pcr_pid=0x%x/0x%x)\n",
365  programid, old_version, version, old_pcr_pid, pid);
366  }
367  break;
368  }
369  }
370 }
371 
372 /**
373  * @brief discard_pid() decides if the pid is to be discarded according
374  * to caller's programs selection
375  * @param ts : - TS context
376  * @param pid : - pid
377  * @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
378  * 0 otherwise
379  */
380 static int discard_pid(MpegTSContext *ts, unsigned int pid)
381 {
382  int i, j, k;
383  int used = 0, discarded = 0;
384  struct Program *p;
385 
386  if (pid == PAT_PID)
387  return 0;
388 
389  /* If none of the programs have .discard=AVDISCARD_ALL then there's
390  * no way we have to discard this packet */
391  for (k = 0; k < ts->stream->nb_programs; k++)
392  if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
393  break;
394  if (k == ts->stream->nb_programs)
395  return 0;
396 
397  for (i = 0; i < ts->nb_prg; i++) {
398  p = &ts->prg[i];
399  for (j = 0; j < p->nb_pids; j++) {
400  if (p->pids[j] != pid)
401  continue;
402  // is program with id p->id set to be discarded?
403  for (k = 0; k < ts->stream->nb_programs; k++) {
404  if (ts->stream->programs[k]->id == p->id) {
405  if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
406  discarded++;
407  else
408  used++;
409  }
410  }
411  }
412  }
413 
414  return !used && discarded;
415 }
416 
417 /**
418  * Assemble PES packets out of TS packets, and then call the "section_cb"
419  * function when they are complete.
420  */
421 static void write_section_data(MpegTSContext *ts, MpegTSFilter *tss1,
422  const uint8_t *buf, int buf_size, int is_start)
423 {
424  MpegTSSectionFilter *tss = &tss1->u.section_filter;
425  uint8_t *cur_section_buf = NULL;
426  int len, offset;
427 
428  if (is_start) {
429  memcpy(tss->section_buf, buf, buf_size);
430  tss->section_index = buf_size;
431  tss->section_h_size = -1;
432  tss->end_of_section_reached = 0;
433  } else {
434  if (tss->end_of_section_reached)
435  return;
436  len = MAX_SECTION_SIZE - tss->section_index;
437  if (buf_size < len)
438  len = buf_size;
439  memcpy(tss->section_buf + tss->section_index, buf, len);
440  tss->section_index += len;
441  }
442 
443  offset = 0;
444  cur_section_buf = tss->section_buf;
445  while (cur_section_buf - tss->section_buf < MAX_SECTION_SIZE && cur_section_buf[0] != 0xff) {
446  /* compute section length if possible */
447  if (tss->section_h_size == -1 && tss->section_index - offset >= 3) {
448  len = (AV_RB16(cur_section_buf + 1) & 0xfff) + 3;
449  if (len > MAX_SECTION_SIZE)
450  return;
451  tss->section_h_size = len;
452  }
453 
454  if (tss->section_h_size != -1 &&
455  tss->section_index >= offset + tss->section_h_size) {
456  int crc_valid = 1;
457  tss->end_of_section_reached = 1;
458 
459  if (tss->check_crc) {
460  crc_valid = !av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, cur_section_buf, tss->section_h_size);
461  if (tss->section_h_size >= 4)
462  tss->crc = AV_RB32(cur_section_buf + tss->section_h_size - 4);
463 
464  if (crc_valid) {
465  ts->crc_validity[ tss1->pid ] = 100;
466  }else if (ts->crc_validity[ tss1->pid ] > -10) {
467  ts->crc_validity[ tss1->pid ]--;
468  }else
469  crc_valid = 2;
470  }
471  if (crc_valid) {
472  tss->section_cb(tss1, cur_section_buf, tss->section_h_size);
473  if (crc_valid != 1)
474  tss->last_ver = -1;
475  }
476 
477  cur_section_buf += tss->section_h_size;
478  offset += tss->section_h_size;
479  tss->section_h_size = -1;
480  } else {
481  tss->section_h_size = -1;
482  tss->end_of_section_reached = 0;
483  break;
484  }
485  }
486 }
487 
488 static MpegTSFilter *mpegts_open_filter(MpegTSContext *ts, unsigned int pid,
489  enum MpegTSFilterType type)
490 {
491  MpegTSFilter *filter;
492 
493  av_log(ts->stream, AV_LOG_TRACE, "Filter: pid=0x%x type=%d\n", pid, type);
494 
495  if (pid >= NB_PID_MAX || ts->pids[pid])
496  return NULL;
497  filter = av_mallocz(sizeof(MpegTSFilter));
498  if (!filter)
499  return NULL;
500  ts->pids[pid] = filter;
501 
502  filter->type = type;
503  filter->pid = pid;
504  filter->es_id = -1;
505  filter->last_cc = -1;
506  filter->last_pcr= -1;
507 
508  return filter;
509 }
510 
511 static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts,
512  unsigned int pid,
513  SectionCallback *section_cb,
514  void *opaque,
515  int check_crc)
516 {
517  MpegTSFilter *filter;
518  MpegTSSectionFilter *sec;
519  uint8_t *section_buf = av_mallocz(MAX_SECTION_SIZE);
520 
521  if (!section_buf)
522  return NULL;
523 
524  if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_SECTION))) {
525  av_free(section_buf);
526  return NULL;
527  }
528  sec = &filter->u.section_filter;
529  sec->section_cb = section_cb;
530  sec->opaque = opaque;
531  sec->section_buf = section_buf;
532  sec->check_crc = check_crc;
533  sec->last_ver = -1;
534 
535  return filter;
536 }
537 
538 static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
539  PESCallback *pes_cb,
540  void *opaque)
541 {
542  MpegTSFilter *filter;
543  MpegTSPESFilter *pes;
544 
545  if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_PES)))
546  return NULL;
547 
548  pes = &filter->u.pes_filter;
549  pes->pes_cb = pes_cb;
550  pes->opaque = opaque;
551  return filter;
552 }
553 
554 static MpegTSFilter *mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid)
555 {
556  return mpegts_open_filter(ts, pid, MPEGTS_PCR);
557 }
558 
559 static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
560 {
561  int pid;
562 
563  pid = filter->pid;
564  if (filter->type == MPEGTS_SECTION)
565  av_freep(&filter->u.section_filter.section_buf);
566  else if (filter->type == MPEGTS_PES) {
567  PESContext *pes = filter->u.pes_filter.opaque;
568  av_buffer_unref(&pes->buffer);
569  /* referenced private data will be freed later in
570  * avformat_close_input (pes->st->priv_data == pes) */
571  if (!pes->st || pes->merged_st) {
572  av_freep(&filter->u.pes_filter.opaque);
573  }
574  }
575 
576  av_free(filter);
577  ts->pids[pid] = NULL;
578 }
579 
580 static int analyze(const uint8_t *buf, int size, int packet_size,
581  int probe)
582 {
583  int stat[TS_MAX_PACKET_SIZE];
584  int stat_all = 0;
585  int i;
586  int best_score = 0;
587 
588  memset(stat, 0, packet_size * sizeof(*stat));
589 
590  for (i = 0; i < size - 3; i++) {
591  if (buf[i] == 0x47) {
592  int pid = AV_RB16(buf+1) & 0x1FFF;
593  int asc = buf[i + 3] & 0x30;
594  if (!probe || pid == 0x1FFF || asc) {
595  int x = i % packet_size;
596  stat[x]++;
597  stat_all++;
598  if (stat[x] > best_score) {
599  best_score = stat[x];
600  }
601  }
602  }
603  }
604 
605  return best_score - FFMAX(stat_all - 10*best_score, 0)/10;
606 }
607 
608 /* autodetect fec presence */
609 static int get_packet_size(AVFormatContext* s)
610 {
611  int score, fec_score, dvhs_score;
612  int margin;
613  int ret;
614 
615  /*init buffer to store stream for probing */
616  uint8_t buf[PROBE_PACKET_MAX_BUF] = {0};
617  int buf_size = 0;
618  int max_iterations = 16;
619 
620  while (buf_size < PROBE_PACKET_MAX_BUF && max_iterations--) {
621  ret = avio_read_partial(s->pb, buf + buf_size, PROBE_PACKET_MAX_BUF - buf_size);
622  if (ret < 0)
623  return AVERROR_INVALIDDATA;
624  buf_size += ret;
625 
626  score = analyze(buf, buf_size, TS_PACKET_SIZE, 0);
627  dvhs_score = analyze(buf, buf_size, TS_DVHS_PACKET_SIZE, 0);
628  fec_score = analyze(buf, buf_size, TS_FEC_PACKET_SIZE, 0);
629  av_log(s, AV_LOG_TRACE, "Probe: %d, score: %d, dvhs_score: %d, fec_score: %d \n",
630  buf_size, score, dvhs_score, fec_score);
631 
632  margin = mid_pred(score, fec_score, dvhs_score);
633 
634  if (buf_size < PROBE_PACKET_MAX_BUF)
635  margin += PROBE_PACKET_MARGIN; /*if buffer not filled */
636 
637  if (score > margin)
638  return TS_PACKET_SIZE;
639  else if (dvhs_score > margin)
640  return TS_DVHS_PACKET_SIZE;
641  else if (fec_score > margin)
642  return TS_FEC_PACKET_SIZE;
643  }
644  return AVERROR_INVALIDDATA;
645 }
646 
647 typedef struct SectionHeader {
648  uint8_t tid;
649  uint16_t id;
650  uint8_t version;
651  uint8_t current_next;
652  uint8_t sec_num;
653  uint8_t last_sec_num;
654 } SectionHeader;
655 
656 static int skip_identical(const SectionHeader *h, MpegTSSectionFilter *tssf)
657 {
658  if (h->version == tssf->last_ver && tssf->last_crc == tssf->crc)
659  return 1;
660 
661  tssf->last_ver = h->version;
662  tssf->last_crc = tssf->crc;
663 
664  return 0;
665 }
666 
667 static inline int get8(const uint8_t **pp, const uint8_t *p_end)
668 {
669  const uint8_t *p;
670  int c;
671 
672  p = *pp;
673  if (p >= p_end)
674  return AVERROR_INVALIDDATA;
675  c = *p++;
676  *pp = p;
677  return c;
678 }
679 
680 static inline int get16(const uint8_t **pp, const uint8_t *p_end)
681 {
682  const uint8_t *p;
683  int c;
684 
685  p = *pp;
686  if (1 >= p_end - p)
687  return AVERROR_INVALIDDATA;
688  c = AV_RB16(p);
689  p += 2;
690  *pp = p;
691  return c;
692 }
693 
694 /* read and allocate a DVB string preceded by its length */
695 static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
696 {
697  int len;
698  const uint8_t *p;
699  char *str;
700 
701  p = *pp;
702  len = get8(&p, p_end);
703  if (len < 0)
704  return NULL;
705  if (len > p_end - p)
706  return NULL;
707 #if CONFIG_ICONV
708  if (len) {
709  const char *encodings[] = {
710  "ISO6937", "ISO-8859-5", "ISO-8859-6", "ISO-8859-7",
711  "ISO-8859-8", "ISO-8859-9", "ISO-8859-10", "ISO-8859-11",
712  "", "ISO-8859-13", "ISO-8859-14", "ISO-8859-15", "", "", "", "",
713  "", "UCS-2BE", "KSC_5601", "GB2312", "UCS-2BE", "UTF-8", "", "",
714  "", "", "", "", "", "", "", ""
715  };
716  iconv_t cd;
717  char *in, *out;
718  size_t inlen = len, outlen = inlen * 6 + 1;
719  if (len >= 3 && p[0] == 0x10 && !p[1] && p[2] && p[2] <= 0xf && p[2] != 0xc) {
720  char iso8859[12];
721  snprintf(iso8859, sizeof(iso8859), "ISO-8859-%d", p[2]);
722  inlen -= 3;
723  in = (char *)p + 3;
724  cd = iconv_open("UTF-8", iso8859);
725  } else if (p[0] < 0x20) {
726  inlen -= 1;
727  in = (char *)p + 1;
728  cd = iconv_open("UTF-8", encodings[*p]);
729  } else {
730  in = (char *)p;
731  cd = iconv_open("UTF-8", encodings[0]);
732  }
733  if (cd == (iconv_t)-1)
734  goto no_iconv;
735  str = out = av_malloc(outlen);
736  if (!str) {
737  iconv_close(cd);
738  return NULL;
739  }
740  if (iconv(cd, &in, &inlen, &out, &outlen) == -1) {
741  iconv_close(cd);
742  av_freep(&str);
743  goto no_iconv;
744  }
745  iconv_close(cd);
746  *out = 0;
747  *pp = p + len;
748  return str;
749  }
750 no_iconv:
751 #endif
752  str = av_malloc(len + 1);
753  if (!str)
754  return NULL;
755  memcpy(str, p, len);
756  str[len] = '\0';
757  p += len;
758  *pp = p;
759  return str;
760 }
761 
762 static int parse_section_header(SectionHeader *h,
763  const uint8_t **pp, const uint8_t *p_end)
764 {
765  int val;
766 
767  val = get8(pp, p_end);
768  if (val < 0)
769  return val;
770  h->tid = val;
771  *pp += 2;
772  val = get16(pp, p_end);
773  if (val < 0)
774  return val;
775  h->id = val;
776  val = get8(pp, p_end);
777  if (val < 0)
778  return val;
779  h->version = (val >> 1) & 0x1f;
780  h->current_next = val & 0x01;
781  val = get8(pp, p_end);
782  if (val < 0)
783  return val;
784  h->sec_num = val;
785  val = get8(pp, p_end);
786  if (val < 0)
787  return val;
788  h->last_sec_num = val;
789  return 0;
790 }
791 
792 typedef struct StreamType {
793  uint32_t stream_type;
794  enum AVMediaType codec_type;
795  enum AVCodecID codec_id;
796 } StreamType;
797 
798 static const StreamType ISO_types[] = {
799  { 0x01, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO },
800  { 0x02, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG2VIDEO },
801  { 0x03, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 },
802  { 0x04, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_MP3 },
803  { 0x0f, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC },
804  { 0x10, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_MPEG4 },
805  /* Makito encoder sets stream type 0x11 for AAC,
806  * so auto-detect LOAS/LATM instead of hardcoding it. */
807 #if !CONFIG_LOAS_DEMUXER
808  { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM }, /* LATM syntax */
809 #endif
810  { 0x1b, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264 },
811  { 0x1c, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC },
812  { 0x20, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264 },
813  { 0x21, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_JPEG2000 },
814  { 0x24, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC },
815  { 0x42, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_CAVS },
816  { 0xd1, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
817  { 0xd2, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_AVS2 },
818  { 0xd4, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_AVS3 },
819  { 0xea, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },
820  { 0 },
821 };
822 
823 static const StreamType HDMV_types[] = {
824  { 0x80, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_PCM_BLURAY },
825  { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
826  { 0x82, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
827  { 0x83, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_TRUEHD },
828  { 0x84, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 },
829  { 0x85, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD */
830  { 0x86, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD MASTER*/
831  { 0xa1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC3 Secondary Audio */
832  { 0xa2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS Express Secondary Audio */
833  { 0x90, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_PGS_SUBTITLE },
834  { 0x92, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_HDMV_TEXT_SUBTITLE },
835  { 0 },
836 };
837 
838 /* SCTE types */
839 static const StreamType SCTE_types[] = {
840  { 0x86, AVMEDIA_TYPE_DATA, AV_CODEC_ID_SCTE_35 },
841  { 0 },
842 };
843 
844 /* ATSC ? */
845 static const StreamType MISC_types[] = {
846  { 0x81, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
847  { 0x8a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
848  { 0 },
849 };
850 
851 /* HLS Sample Encryption Types */
852 static const StreamType HLS_SAMPLE_ENC_types[] = {
853  { 0xdb, AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_H264},
854  { 0xcf, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC },
855  { 0xc1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
856  { 0xc2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3},
857  { 0 },
858 };
859 
860 static const StreamType REGD_types[] = {
861  { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
862  { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
863  { MKTAG('A', 'C', '-', '4'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC4 },
864  { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M },
865  { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
866  { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
867  { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
868  { MKTAG('E', 'A', 'C', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 },
869  { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC },
870  { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
871  { MKTAG('V', 'A', 'N', 'C'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_2038 },
872  { MKTAG('I', 'D', '3', ' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
873  { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },
874  { MKTAG('O', 'p', 'u', 's'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_OPUS },
875  { 0 },
876 };
877 
878 static const StreamType METADATA_types[] = {
879  { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
880  { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
881  { 0 },
882 };
883 
884 /* descriptor present */
885 static const StreamType DESC_types[] = {
886  { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */
887  { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
888  { 0x7b, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
889  { 0x56, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_TELETEXT },
890  { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
891  { 0 },
892 };
893 
894 static void mpegts_find_stream_type(AVStream *st,
895  uint32_t stream_type,
896  const StreamType *types)
897 {
898  FFStream *const sti = ffstream(st);
899  for (; types->stream_type; types++)
900  if (stream_type == types->stream_type) {
901  if (st->codecpar->codec_type != types->codec_type ||
902  st->codecpar->codec_id != types->codec_id) {
903  st->codecpar->codec_type = types->codec_type;
904  st->codecpar->codec_id = types->codec_id;
905  sti->need_context_update = 1;
906  }
907  sti->request_probe = 0;
908  return;
909  }
910 }
911 
912 static int mpegts_set_stream_info(AVStream *st, PESContext *pes,
913  uint32_t stream_type, uint32_t prog_reg_desc)
914 {
915  FFStream *const sti = ffstream(st);
916  int old_codec_type = st->codecpar->codec_type;
917  int old_codec_id = st->codecpar->codec_id;
918  int old_codec_tag = st->codecpar->codec_tag;
919 
920  if (avcodec_is_open(sti->avctx)) {
921  av_log(pes->stream, AV_LOG_DEBUG, "cannot set stream info, internal codec is open\n");
922  return 0;
923  }
924 
925  avpriv_set_pts_info(st, 33, 1, 90000);
926  st->priv_data = pes;
927  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
928  st->codecpar->codec_id = AV_CODEC_ID_NONE;
929  sti->need_parsing = AVSTREAM_PARSE_FULL;
930  pes->st = st;
931  pes->stream_type = stream_type;
932 
933  av_log(pes->stream, AV_LOG_DEBUG,
934  "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
935  st->index, pes->stream_type, pes->pid, (char *)&prog_reg_desc);
936 
937  st->codecpar->codec_tag = pes->stream_type;
938 
939  mpegts_find_stream_type(st, pes->stream_type, ISO_types);
940  if (pes->stream_type == 4 || pes->stream_type == 0x0f)
941  sti->request_probe = 50;
942  if ((prog_reg_desc == AV_RL32("HDMV") ||
943  prog_reg_desc == AV_RL32("HDPR")) &&
944  st->codecpar->codec_id == AV_CODEC_ID_NONE) {
945  mpegts_find_stream_type(st, pes->stream_type, HDMV_types);
946  if (pes->stream_type == 0x83) {
947  // HDMV TrueHD streams also contain an AC3 coded version of the
948  // audio track - add a second stream for this
949  AVStream *sub_st;
950  // priv_data cannot be shared between streams
951  PESContext *sub_pes = av_memdup(pes, sizeof(*sub_pes));
952  if (!sub_pes)
953  return AVERROR(ENOMEM);
954 
955  sub_st = avformat_new_stream(pes->stream, NULL);
956  if (!sub_st) {
957  av_free(sub_pes);
958  return AVERROR(ENOMEM);
959  }
960 
961  sub_st->id = pes->pid;
962  avpriv_set_pts_info(sub_st, 33, 1, 90000);
963  sub_st->priv_data = sub_pes;
964  sub_st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
965  sub_st->codecpar->codec_id = AV_CODEC_ID_AC3;
966  ffstream(sub_st)->need_parsing = AVSTREAM_PARSE_FULL;
967  sub_pes->sub_st = pes->sub_st = sub_st;
968  }
969  }
970  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
971  mpegts_find_stream_type(st, pes->stream_type, MISC_types);
972  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
973  mpegts_find_stream_type(st, pes->stream_type, HLS_SAMPLE_ENC_types);
974  if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
975  st->codecpar->codec_id = old_codec_id;
976  st->codecpar->codec_type = old_codec_type;
977  }
978  if ((st->codecpar->codec_id == AV_CODEC_ID_NONE ||
979  (sti->request_probe > 0 && sti->request_probe < AVPROBE_SCORE_STREAM_RETRY / 5)) &&
980  sti->probe_packets > 0 &&
981  stream_type == STREAM_TYPE_PRIVATE_DATA) {
982  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
983  st->codecpar->codec_id = AV_CODEC_ID_BIN_DATA;
984  sti->request_probe = AVPROBE_SCORE_STREAM_RETRY / 5;
985  }
986 
987  /* queue a context update if properties changed */
988  if (old_codec_type != st->codecpar->codec_type ||
989  old_codec_id != st->codecpar->codec_id ||
990  old_codec_tag != st->codecpar->codec_tag)
991  sti->need_context_update = 1;
992 
993  return 0;
994 }
995 
996 static void reset_pes_packet_state(PESContext *pes)
997 {
998  pes->pts = AV_NOPTS_VALUE;
999  pes->dts = AV_NOPTS_VALUE;
1000  pes->data_index = 0;
1001  pes->flags = 0;
1002  av_buffer_unref(&pes->buffer);
1003 }
1004 
1005 static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt)
1006 {
1007  av_packet_unref(pkt);
1008  pkt->data = (uint8_t *)buffer;
1009  pkt->size = len;
1010 }
1011 
1012 static int new_pes_packet(PESContext *pes, AVPacket *pkt)
1013 {
1014  uint8_t *sd;
1015 
1016  av_packet_unref(pkt);
1017 
1018  pkt->buf = pes->buffer;
1019  pkt->data = pes->buffer->data;
1020  pkt->size = pes->data_index;
1021 
1022  if (pes->PES_packet_length &&
1023  pes->pes_header_size + pes->data_index != pes->PES_packet_length +
1024  PES_START_SIZE) {
1025  av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n");
1026  pes->flags |= AV_PKT_FLAG_CORRUPT;
1027  }
1028  memset(pkt->data + pkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1029 
1030  // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
1031  if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76)
1032  pkt->stream_index = pes->sub_st->index;
1033  else
1034  pkt->stream_index = pes->st->index;
1035  pkt->pts = pes->pts;
1036  pkt->dts = pes->dts;
1037  /* store position of first TS packet of this PES packet */
1038  pkt->pos = pes->ts_packet_pos;
1039  pkt->flags = pes->flags;
1040 
1041  pes->buffer = NULL;
1042  reset_pes_packet_state(pes);
1043 
1044  sd = av_packet_new_side_data(pkt, AV_PKT_DATA_MPEGTS_STREAM_ID, 1);
1045  if (!sd)
1046  return AVERROR(ENOMEM);
1047  *sd = pes->stream_id;
1048 
1049  return 0;
1050 }
1051 
1052 static uint64_t get_ts64(GetBitContext *gb, int bits)
1053 {
1054  if (get_bits_left(gb) < bits)
1055  return AV_NOPTS_VALUE;
1056  return get_bits64(gb, bits);
1057 }
1058 
1059 static int read_sl_header(PESContext *pes, SLConfigDescr *sl,
1060  const uint8_t *buf, int buf_size)
1061 {
1062  GetBitContext gb;
1063  int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;
1064  int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;
1065  int dts_flag = -1, cts_flag = -1;
1066  int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE;
1067  uint8_t buf_padded[128 + AV_INPUT_BUFFER_PADDING_SIZE];
1068  int buf_padded_size = FFMIN(buf_size, sizeof(buf_padded) - AV_INPUT_BUFFER_PADDING_SIZE);
1069 
1070  memcpy(buf_padded, buf, buf_padded_size);
1071 
1072  init_get_bits(&gb, buf_padded, buf_padded_size * 8);
1073 
1074  if (sl->use_au_start)
1075  au_start_flag = get_bits1(&gb);
1076  if (sl->use_au_end)
1077  au_end_flag = get_bits1(&gb);
1078  if (!sl->use_au_start && !sl->use_au_end)
1079  au_start_flag = au_end_flag = 1;
1080  if (sl->ocr_len > 0)
1081  ocr_flag = get_bits1(&gb);
1082  if (sl->use_idle)
1083  idle_flag = get_bits1(&gb);
1084  if (sl->use_padding)
1085  padding_flag = get_bits1(&gb);
1086  if (padding_flag)
1087  padding_bits = get_bits(&gb, 3);
1088 
1089  if (!idle_flag && (!padding_flag || padding_bits != 0)) {
1090  if (sl->packet_seq_num_len)
1091  skip_bits_long(&gb, sl->packet_seq_num_len);
1092  if (sl->degr_prior_len)
1093  if (get_bits1(&gb))
1094  skip_bits(&gb, sl->degr_prior_len);
1095  if (ocr_flag)
1096  skip_bits_long(&gb, sl->ocr_len);
1097  if (au_start_flag) {
1098  if (sl->use_rand_acc_pt)
1099  get_bits1(&gb);
1100  if (sl->au_seq_num_len > 0)
1101  skip_bits_long(&gb, sl->au_seq_num_len);
1102  if (sl->use_timestamps) {
1103  dts_flag = get_bits1(&gb);
1104  cts_flag = get_bits1(&gb);
1105  }
1106  }
1107  if (sl->inst_bitrate_len)
1108  inst_bitrate_flag = get_bits1(&gb);
1109  if (dts_flag == 1)
1110  dts = get_ts64(&gb, sl->timestamp_len);
1111  if (cts_flag == 1)
1112  cts = get_ts64(&gb, sl->timestamp_len);
1113  if (sl->au_len > 0)
1114  skip_bits_long(&gb, sl->au_len);
1115  if (inst_bitrate_flag)
1116  skip_bits_long(&gb, sl->inst_bitrate_len);
1117  }
1118 
1119  if (dts != AV_NOPTS_VALUE)
1120  pes->dts = dts;
1121  if (cts != AV_NOPTS_VALUE)
1122  pes->pts = cts;
1123 
1124  if (sl->timestamp_len && sl->timestamp_res)
1125  avpriv_set_pts_info(pes->st, sl->timestamp_len, 1, sl->timestamp_res);
1126 
1127  return (get_bits_count(&gb) + 7) >> 3;
1128 }
1129 
1130 static AVBufferRef *buffer_pool_get(MpegTSContext *ts, int size)
1131 {
1132  int index = av_log2(size + AV_INPUT_BUFFER_PADDING_SIZE);
1133  if (!ts->pools[index]) {
1134  int pool_size = FFMIN(ts->max_packet_size + AV_INPUT_BUFFER_PADDING_SIZE, 2 << index);
1135  ts->pools[index] = av_buffer_pool_init(pool_size, NULL);
1136  if (!ts->pools[index])
1137  return NULL;
1138  }
1139  return av_buffer_pool_get(ts->pools[index]);
1140 }
1141 
1142 /* return non zero if a packet could be constructed */
1143 static int mpegts_push_data(MpegTSFilter *filter,
1144  const uint8_t *buf, int buf_size, int is_start,
1145  int64_t pos)
1146 {
1147  PESContext *pes = filter->u.pes_filter.opaque;
1148  MpegTSContext *ts = pes->ts;
1149  const uint8_t *p;
1150  int ret, len;
1151 
1152  if (!ts->pkt)
1153  return 0;
1154 
1155  if (is_start) {
1156  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
1157  ret = new_pes_packet(pes, ts->pkt);
1158  if (ret < 0)
1159  return ret;
1160  ts->stop_parse = 1;
1161  } else {
1162  reset_pes_packet_state(pes);
1163  }
1164  pes->state = MPEGTS_HEADER;
1165  pes->ts_packet_pos = pos;
1166  }
1167  p = buf;
1168  while (buf_size > 0) {
1169  switch (pes->state) {
1170  case MPEGTS_HEADER:
1171  len = PES_START_SIZE - pes->data_index;
1172  if (len > buf_size)
1173  len = buf_size;
1174  memcpy(pes->header + pes->data_index, p, len);
1175  pes->data_index += len;
1176  p += len;
1177  buf_size -= len;
1178  if (pes->data_index == PES_START_SIZE) {
1179  /* we got all the PES or section header. We can now
1180  * decide */
1181  if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
1182  pes->header[2] == 0x01) {
1183  /* it must be an MPEG-2 PES stream */
1184  pes->stream_id = pes->header[3];
1185  av_log(pes->stream, AV_LOG_TRACE, "pid=%x stream_id=%#x\n", pes->pid, pes->stream_id);
1186 
1187  if ((pes->st && pes->st->discard == AVDISCARD_ALL &&
1188  (!pes->sub_st ||
1189  pes->sub_st->discard == AVDISCARD_ALL)) ||
1190  pes->stream_id == STREAM_ID_PADDING_STREAM)
1191  goto skip;
1192 
1193  /* stream not present in PMT */
1194  if (!pes->st) {
1195  if (ts->skip_changes)
1196  goto skip;
1197  if (ts->merge_pmt_versions)
1198  goto skip; /* wait for PMT to merge new stream */
1199 
1200  pes->st = avformat_new_stream(ts->stream, NULL);
1201  if (!pes->st)
1202  return AVERROR(ENOMEM);
1203  pes->st->id = pes->pid;
1204  mpegts_set_stream_info(pes->st, pes, 0, 0);
1205  }
1206 
1207  pes->PES_packet_length = AV_RB16(pes->header + 4);
1208  /* NOTE: zero length means the PES size is unbounded */
1209 
1210  if (pes->stream_id != STREAM_ID_PROGRAM_STREAM_MAP &&
1211  pes->stream_id != STREAM_ID_PRIVATE_STREAM_2 &&
1212  pes->stream_id != STREAM_ID_ECM_STREAM &&
1213  pes->stream_id != STREAM_ID_EMM_STREAM &&
1214  pes->stream_id != STREAM_ID_PROGRAM_STREAM_DIRECTORY &&
1215  pes->stream_id != STREAM_ID_DSMCC_STREAM &&
1216  pes->stream_id != STREAM_ID_TYPE_E_STREAM) {
1217  FFStream *const pes_sti = ffstream(pes->st);
1218  pes->state = MPEGTS_PESHEADER;
1219  if (pes->st->codecpar->codec_id == AV_CODEC_ID_NONE && !pes_sti->request_probe) {
1220  av_log(pes->stream, AV_LOG_TRACE,
1221  "pid=%x stream_type=%x probing\n",
1222  pes->pid,
1223  pes->stream_type);
1224  pes_sti->request_probe = 1;
1225  }
1226  } else {
1227  pes->pes_header_size = 6;
1228  pes->state = MPEGTS_PAYLOAD;
1229  pes->data_index = 0;
1230  }
1231  } else {
1232  /* otherwise, it should be a table */
1233  /* skip packet */
1234 skip:
1235  pes->state = MPEGTS_SKIP;
1236  continue;
1237  }
1238  }
1239  break;
1240  /**********************************************/
1241  /* PES packing parsing */
1242  case MPEGTS_PESHEADER:
1243  len = PES_HEADER_SIZE - pes->data_index;
1244  if (len < 0)
1245  return AVERROR_INVALIDDATA;
1246  if (len > buf_size)
1247  len = buf_size;
1248  memcpy(pes->header + pes->data_index, p, len);
1249  pes->data_index += len;
1250  p += len;
1251  buf_size -= len;
1252  if (pes->data_index == PES_HEADER_SIZE) {
1253  pes->pes_header_size = pes->header[8] + 9;
1254  pes->state = MPEGTS_PESHEADER_FILL;
1255  }
1256  break;
1257  case MPEGTS_PESHEADER_FILL:
1258  len = pes->pes_header_size - pes->data_index;
1259  if (len < 0)
1260  return AVERROR_INVALIDDATA;
1261  if (len > buf_size)
1262  len = buf_size;
1263  memcpy(pes->header + pes->data_index, p, len);
1264  pes->data_index += len;
1265  p += len;
1266  buf_size -= len;
1267  if (pes->data_index == pes->pes_header_size) {
1268  const uint8_t *r;
1269  unsigned int flags, pes_ext, skip;
1270 
1271  flags = pes->header[7];
1272  r = pes->header + 9;
1273  pes->pts = AV_NOPTS_VALUE;
1274  pes->dts = AV_NOPTS_VALUE;
1275  if ((flags & 0xc0) == 0x80) {
1276  pes->dts = pes->pts = ff_parse_pes_pts(r);
1277  r += 5;
1278  } else if ((flags & 0xc0) == 0xc0) {
1279  pes->pts = ff_parse_pes_pts(r);
1280  r += 5;
1281  pes->dts = ff_parse_pes_pts(r);
1282  r += 5;
1283  }
1284  pes->extended_stream_id = -1;
1285  if (flags & 0x01) { /* PES extension */
1286  pes_ext = *r++;
1287  /* Skip PES private data, program packet sequence counter and P-STD buffer */
1288  skip = (pes_ext >> 4) & 0xb;
1289  skip += skip & 0x9;
1290  r += skip;
1291  if ((pes_ext & 0x41) == 0x01 &&
1292  (r + 2) <= (pes->header + pes->pes_header_size)) {
1293  /* PES extension 2 */
1294  if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)
1295  pes->extended_stream_id = r[1];
1296  }
1297  }
1298 
1299  /* we got the full header. We parse it and get the payload */
1300  pes->state = MPEGTS_PAYLOAD;
1301  pes->data_index = 0;
1302  if (pes->stream_type == 0x12 && buf_size > 0) {
1303  int sl_header_bytes = read_sl_header(pes, &pes->sl, p,
1304  buf_size);
1305  pes->pes_header_size += sl_header_bytes;
1306  p += sl_header_bytes;
1307  buf_size -= sl_header_bytes;
1308  }
1309  if (pes->stream_type == STREAM_TYPE_METADATA &&
1310  pes->stream_id == STREAM_ID_METADATA_STREAM &&
1311  pes->st->codecpar->codec_id == AV_CODEC_ID_SMPTE_KLV &&
1312  buf_size >= 5) {
1313  /* skip metadata access unit header - see MISB ST 1402 */
1314  pes->pes_header_size += 5;
1315  p += 5;
1316  buf_size -= 5;
1317  }
1318  if ( pes->ts->fix_teletext_pts
1319  && ( pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT
1320  || pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
1321  ) {
1322  AVProgram *p = NULL;
1323  int pcr_found = 0;
1324  while ((p = av_find_program_from_stream(pes->stream, p, pes->st->index))) {
1325  if (p->pcr_pid != -1 && p->discard != AVDISCARD_ALL) {
1326  MpegTSFilter *f = pes->ts->pids[p->pcr_pid];
1327  if (f) {
1328  AVStream *st = NULL;
1329  if (f->type == MPEGTS_PES) {
1330  PESContext *pcrpes = f->u.pes_filter.opaque;
1331  if (pcrpes)
1332  st = pcrpes->st;
1333  } else if (f->type == MPEGTS_PCR) {
1334  int i;
1335  for (i = 0; i < p->nb_stream_indexes; i++) {
1336  AVStream *pst = pes->stream->streams[p->stream_index[i]];
1337  if (pst->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
1338  st = pst;
1339  }
1340  }
1341  if (f->last_pcr != -1 && !f->discard) {
1342  // teletext packets do not always have correct timestamps,
1343  // the standard says they should be handled after 40.6 ms at most,
1344  // and the pcr error to this packet should be no more than 100 ms.
1345  // TODO: we should interpolate the PCR, not just use the last one
1346  int64_t pcr = f->last_pcr / 300;
1347  pcr_found = 1;
1348  if (st) {
1349  const FFStream *const sti = ffstream(st);
1350  FFStream *const pes_sti = ffstream(pes->st);
1351 
1352  pes_sti->pts_wrap_reference = sti->pts_wrap_reference;
1353  pes_sti->pts_wrap_behavior = sti->pts_wrap_behavior;
1354  }
1355  if (pes->dts == AV_NOPTS_VALUE || pes->dts < pcr) {
1356  pes->pts = pes->dts = pcr;
1357  } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT &&
1358  pes->dts > pcr + 3654 + 9000) {
1359  pes->pts = pes->dts = pcr + 3654 + 9000;
1360  } else if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
1361  pes->dts > pcr + 10*90000) { //10sec
1362  pes->pts = pes->dts = pcr + 3654 + 9000;
1363  }
1364  break;
1365  }
1366  }
1367  }
1368  }
1369 
1370  if (pes->st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT &&
1371  !pcr_found) {
1372  av_log(pes->stream, AV_LOG_VERBOSE,
1373  "Forcing DTS/PTS to be unset for a "
1374  "non-trustworthy PES packet for PID %d as "
1375  "PCR hasn't been received yet.\n",
1376  pes->pid);
1377  pes->dts = pes->pts = AV_NOPTS_VALUE;
1378  }
1379  }
1380  }
1381  break;
1382  case MPEGTS_PAYLOAD:
1383  do {
1384  int max_packet_size = ts->max_packet_size;
1385  if (pes->PES_packet_length && pes->PES_packet_length + PES_START_SIZE > pes->pes_header_size)
1386  max_packet_size = pes->PES_packet_length + PES_START_SIZE - pes->pes_header_size;
1387 
1388  if (pes->data_index > 0 &&
1389  pes->data_index + buf_size > max_packet_size) {
1390  ret = new_pes_packet(pes, ts->pkt);
1391  if (ret < 0)
1392  return ret;
1393  pes->PES_packet_length = 0;
1394  max_packet_size = ts->max_packet_size;
1395  ts->stop_parse = 1;
1396  } else if (pes->data_index == 0 &&
1397  buf_size > max_packet_size) {
1398  // pes packet size is < ts size packet and pes data is padded with 0xff
1399  // not sure if this is legal in ts but see issue #2392
1400  buf_size = max_packet_size;
1401  }
1402 
1403  if (!pes->buffer) {
1404  pes->buffer = buffer_pool_get(ts, max_packet_size);
1405  if (!pes->buffer)
1406  return AVERROR(ENOMEM);
1407  }
1408 
1409  memcpy(pes->buffer->data + pes->data_index, p, buf_size);
1410  pes->data_index += buf_size;
1411  /* emit complete packets with known packet size
1412  * decreases demuxer delay for infrequent packets like subtitles from
1413  * a couple of seconds to milliseconds for properly muxed files. */
1414  if (!ts->stop_parse && pes->PES_packet_length &&
1415  pes->pes_header_size + pes->data_index == pes->PES_packet_length + PES_START_SIZE) {
1416  ts->stop_parse = 1;
1417  ret = new_pes_packet(pes, ts->pkt);
1418  pes->state = MPEGTS_SKIP;
1419  if (ret < 0)
1420  return ret;
1421  }
1422  } while (0);
1423  buf_size = 0;
1424  break;
1425  case MPEGTS_SKIP:
1426  buf_size = 0;
1427  break;
1428  }
1429  }
1430 
1431  return 0;
1432 }
1433 
1434 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
1435 {
1436  MpegTSFilter *tss;
1437  PESContext *pes;
1438 
1439  /* if no pid found, then add a pid context */
1440  pes = av_mallocz(sizeof(PESContext));
1441  if (!pes)
1442  return 0;
1443  pes->ts = ts;
1444  pes->stream = ts->stream;
1445  pes->pid = pid;
1446  pes->pcr_pid = pcr_pid;
1447  pes->state = MPEGTS_SKIP;
1448  pes->pts = AV_NOPTS_VALUE;
1449  pes->dts = AV_NOPTS_VALUE;
1450  tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
1451  if (!tss) {
1452  av_free(pes);
1453  return 0;
1454  }
1455  return pes;
1456 }
1457 
1458 #define MAX_LEVEL 4
1459 typedef struct MP4DescrParseContext {
1460  AVFormatContext *s;
1461  FFIOContext pb;
1462  Mp4Descr *descr;
1463  Mp4Descr *active_descr;
1464  int descr_count;
1465  int max_descr_count;
1466  int level;
1467  int predefined_SLConfigDescriptor_seen;
1468 } MP4DescrParseContext;
1469 
1470 static int init_MP4DescrParseContext(MP4DescrParseContext *d, AVFormatContext *s,
1471  const uint8_t *buf, unsigned size,
1472  Mp4Descr *descr, int max_descr_count)
1473 {
1474  if (size > (1 << 30))
1475  return AVERROR_INVALIDDATA;
1476 
1477  ffio_init_read_context(&d->pb, buf, size);
1478 
1479  d->s = s;
1480  d->level = 0;
1481  d->descr_count = 0;
1482  d->descr = descr;
1483  d->active_descr = NULL;
1484  d->max_descr_count = max_descr_count;
1485 
1486  return 0;
1487 }
1488 
1489 static void update_offsets(AVIOContext *pb, int64_t *off, int *len)
1490 {
1491  int64_t new_off = avio_tell(pb);
1492  (*len) -= new_off - *off;
1493  *off = new_off;
1494 }
1495 
1496 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1497  int target_tag);
1498 
1499 static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
1500 {
1501  while (len > 0) {
1502  int ret = parse_mp4_descr(d, off, len, 0);
1503  if (ret < 0)
1504  return ret;
1505  update_offsets(&d->pb.pub, &off, &len);
1506  }
1507  return 0;
1508 }
1509 
1510 static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1511 {
1512  AVIOContext *const pb = &d->pb.pub;
1513  avio_rb16(pb); // ID
1514  avio_r8(pb);
1515  avio_r8(pb);
1516  avio_r8(pb);
1517  avio_r8(pb);
1518  avio_r8(pb);
1519  update_offsets(pb, &off, &len);
1520  return parse_mp4_descr_arr(d, off, len);
1521 }
1522 
1523 static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1524 {
1525  int id_flags;
1526  if (len < 2)
1527  return 0;
1528  id_flags = avio_rb16(&d->pb.pub);
1529  if (!(id_flags & 0x0020)) { // URL_Flag
1530  update_offsets(&d->pb.pub, &off, &len);
1531  return parse_mp4_descr_arr(d, off, len); // ES_Descriptor[]
1532  } else {
1533  return 0;
1534  }
1535 }
1536 
1537 static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1538 {
1539  AVIOContext *const pb = &d->pb.pub;
1540  int es_id = 0;
1541  int ret = 0;
1542 
1543  if (d->descr_count >= d->max_descr_count)
1544  return AVERROR_INVALIDDATA;
1545  ff_mp4_parse_es_descr(pb, &es_id);
1546  d->active_descr = d->descr + (d->descr_count++);
1547 
1548  d->active_descr->es_id = es_id;
1549  update_offsets(pb, &off, &len);
1550  if ((ret = parse_mp4_descr(d, off, len, MP4DecConfigDescrTag)) < 0)
1551  return ret;
1552  update_offsets(pb, &off, &len);
1553  if (len > 0)
1554  ret = parse_mp4_descr(d, off, len, MP4SLDescrTag);
1555  d->active_descr = NULL;
1556  return ret;
1557 }
1558 
1559 static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off,
1560  int len)
1561 {
1562  Mp4Descr *descr = d->active_descr;
1563  if (!descr)
1564  return AVERROR_INVALIDDATA;
1565  d->active_descr->dec_config_descr = av_malloc(len);
1566  if (!descr->dec_config_descr)
1567  return AVERROR(ENOMEM);
1568  descr->dec_config_descr_len = len;
1569  avio_read(&d->pb.pub, descr->dec_config_descr, len);
1570  return 0;
1571 }
1572 
1573 static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1574 {
1575  Mp4Descr *descr = d->active_descr;
1576  AVIOContext *const pb = &d->pb.pub;
1577  int predefined;
1578  if (!descr)
1579  return AVERROR_INVALIDDATA;
1580 
1581 #define R8_CHECK_CLIP_MAX(dst, maxv) do { \
1582  descr->sl.dst = avio_r8(pb); \
1583  if (descr->sl.dst > maxv) { \
1584  descr->sl.dst = maxv; \
1585  return AVERROR_INVALIDDATA; \
1586  } \
1587 } while (0)
1588 
1589  predefined = avio_r8(pb);
1590  if (!predefined) {
1591  int lengths;
1592  int flags = avio_r8(pb);
1593  descr->sl.use_au_start = !!(flags & 0x80);
1594  descr->sl.use_au_end = !!(flags & 0x40);
1595  descr->sl.use_rand_acc_pt = !!(flags & 0x20);
1596  descr->sl.use_padding = !!(flags & 0x08);
1597  descr->sl.use_timestamps = !!(flags & 0x04);
1598  descr->sl.use_idle = !!(flags & 0x02);
1599  descr->sl.timestamp_res = avio_rb32(pb);
1600  avio_rb32(pb);
1601  R8_CHECK_CLIP_MAX(timestamp_len, 63);
1602  R8_CHECK_CLIP_MAX(ocr_len, 63);
1603  R8_CHECK_CLIP_MAX(au_len, 31);
1604  descr->sl.inst_bitrate_len = avio_r8(pb);
1605  lengths = avio_rb16(pb);
1606  descr->sl.degr_prior_len = lengths >> 12;
1607  descr->sl.au_seq_num_len = (lengths >> 7) & 0x1f;
1608  descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f;
1609  } else if (!d->predefined_SLConfigDescriptor_seen){
1610  avpriv_report_missing_feature(d->s, "Predefined SLConfigDescriptor");
1611  d->predefined_SLConfigDescriptor_seen = 1;
1612  }
1613  return 0;
1614 }
1615 
1616 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1617  int target_tag)
1618 {
1619  int tag;
1620  AVIOContext *const pb = &d->pb.pub;
1621  int len1 = ff_mp4_read_descr(d->s, pb, &tag);
1622  int ret = 0;
1623 
1624  update_offsets(pb, &off, &len);
1625  if (len < 0 || len1 > len || len1 <= 0) {
1626  av_log(d->s, AV_LOG_ERROR,
1627  "Tag %x length violation new length %d bytes remaining %d\n",
1628  tag, len1, len);
1629  return AVERROR_INVALIDDATA;
1630  }
1631 
1632  if (d->level++ >= MAX_LEVEL) {
1633  av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n");
1634  ret = AVERROR_INVALIDDATA;
1635  goto done;
1636  }
1637 
1638  if (target_tag && tag != target_tag) {
1639  av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag,
1640  target_tag);
1641  ret = AVERROR_INVALIDDATA;
1642  goto done;
1643  }
1644 
1645  switch (tag) {
1646  case MP4IODescrTag:
1647  ret = parse_MP4IODescrTag(d, off, len1);
1648  break;
1649  case MP4ODescrTag:
1650  ret = parse_MP4ODescrTag(d, off, len1);
1651  break;
1652  case MP4ESDescrTag:
1653  ret = parse_MP4ESDescrTag(d, off, len1);
1654  break;
1655  case MP4DecConfigDescrTag:
1656  ret = parse_MP4DecConfigDescrTag(d, off, len1);
1657  break;
1658  case MP4SLDescrTag:
1659  ret = parse_MP4SLDescrTag(d, off, len1);
1660  break;
1661  }
1662 
1663 
1664 done:
1665  d->level--;
1666  avio_seek(pb, off + len1, SEEK_SET);
1667  return ret;
1668 }
1669 
1670 static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
1671  Mp4Descr *descr, int *descr_count, int max_descr_count)
1672 {
1673  MP4DescrParseContext d;
1674  int ret;
1675 
1676  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1677  if (ret < 0)
1678  return ret;
1679 
1680  ret = parse_mp4_descr(&d, avio_tell(&d.pb.pub), size, MP4IODescrTag);
1681 
1682  *descr_count = d.descr_count;
1683  return ret;
1684 }
1685 
1686 static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size,
1687  Mp4Descr *descr, int *descr_count, int max_descr_count)
1688 {
1689  MP4DescrParseContext d;
1690  int ret;
1691 
1692  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1693  if (ret < 0)
1694  return ret;
1695 
1696  ret = parse_mp4_descr_arr(&d, avio_tell(&d.pb.pub), size);
1697 
1698  *descr_count = d.descr_count;
1699  return ret;
1700 }
1701 
1702 static void m4sl_cb(MpegTSFilter *filter, const uint8_t *section,
1703  int section_len)
1704 {
1705  MpegTSContext *ts = filter->u.section_filter.opaque;
1706  MpegTSSectionFilter *tssf = &filter->u.section_filter;
1707  SectionHeader h;
1708  const uint8_t *p, *p_end;
1709  int mp4_descr_count = 0;
1710  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
1711  int i, pid;
1712  AVFormatContext *s = ts->stream;
1713 
1714  p_end = section + section_len - 4;
1715  p = section;
1716  if (parse_section_header(&h, &p, p_end) < 0)
1717  return;
1718  if (h.tid != M4OD_TID)
1719  return;
1720  if (skip_identical(&h, tssf))
1721  return;
1722 
1723  mp4_read_od(s, p, (unsigned) (p_end - p), mp4_descr, &mp4_descr_count,
1724  MAX_MP4_DESCR_COUNT);
1725 
1726  for (pid = 0; pid < NB_PID_MAX; pid++) {
1727  if (!ts->pids[pid])
1728  continue;
1729  for (i = 0; i < mp4_descr_count; i++) {
1730  PESContext *pes;
1731  AVStream *st;
1732  FFStream *sti;
1733  FFIOContext pb;
1734  if (ts->pids[pid]->es_id != mp4_descr[i].es_id)
1735  continue;
1736  if (ts->pids[pid]->type != MPEGTS_PES) {
1737  av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);
1738  continue;
1739  }
1740  pes = ts->pids[pid]->u.pes_filter.opaque;
1741  st = pes->st;
1742  if (!st)
1743  continue;
1744  sti = ffstream(st);
1745 
1746  pes->sl = mp4_descr[i].sl;
1747 
1748  ffio_init_read_context(&pb, mp4_descr[i].dec_config_descr,
1749  mp4_descr[i].dec_config_descr_len);
1750  ff_mp4_read_dec_config_descr(s, st, &pb.pub);
1751  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1752  st->codecpar->extradata_size > 0)
1753  sti->need_parsing = 0;
1754  if (st->codecpar->codec_id == AV_CODEC_ID_H264 &&
1755  st->codecpar->extradata_size > 0)
1756  sti->need_parsing = 0;
1757 
1758  st->codecpar->codec_type = avcodec_get_type(st->codecpar->codec_id);
1759  sti->need_context_update = 1;
1760  }
1761  }
1762  for (i = 0; i < mp4_descr_count; i++)
1763  av_free(mp4_descr[i].dec_config_descr);
1764 }
1765 
1766 static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section,
1767  int section_len)
1768 {
1769  AVProgram *prg = NULL;
1770  MpegTSContext *ts = filter->u.section_filter.opaque;
1771 
1772  int idx = ff_find_stream_index(ts->stream, filter->pid);
1773  if (idx < 0)
1774  return;
1775 
1776  /**
1777  * In case we receive an SCTE-35 packet before mpegts context is fully
1778  * initialized.
1779  */
1780  if (!ts->pkt)
1781  return;
1782 
1783  new_data_packet(section, section_len, ts->pkt);
1784  ts->pkt->stream_index = idx;
1785  prg = av_find_program_from_stream(ts->stream, NULL, idx);
1786  if (prg && prg->pcr_pid != -1 && prg->discard != AVDISCARD_ALL) {
1787  MpegTSFilter *f = ts->pids[prg->pcr_pid];
1788  if (f && f->last_pcr != -1)
1789  ts->pkt->pts = ts->pkt->dts = f->last_pcr/300;
1790  }
1791  ts->stop_parse = 1;
1792 
1793 }
1794 
1795 static const uint8_t opus_coupled_stream_cnt[9] = {
1796  1, 0, 1, 1, 2, 2, 2, 3, 3
1797 };
1798 
1799 static const uint8_t opus_stream_cnt[9] = {
1800  1, 1, 1, 2, 2, 3, 4, 4, 5,
1801 };
1802 
1803 static const uint8_t opus_channel_map[8][8] = {
1804  { 0 },
1805  { 0,1 },
1806  { 0,2,1 },
1807  { 0,1,2,3 },
1808  { 0,4,1,2,3 },
1809  { 0,4,1,2,3,5 },
1810  { 0,4,1,2,3,5,6 },
1811  { 0,6,1,2,3,4,5,7 },
1812 };
1813 
1814 int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type,
1815  const uint8_t **pp, const uint8_t *desc_list_end,
1816  Mp4Descr *mp4_descr, int mp4_descr_count, int pid,
1817  MpegTSContext *ts)
1818 {
1819  FFStream *const sti = ffstream(st);
1820  const uint8_t *desc_end;
1821  int desc_len, desc_tag, desc_es_id, ext_desc_tag, channels, channel_config_code;
1822  char language[252];
1823  int i;
1824 
1825  desc_tag = get8(pp, desc_list_end);
1826  if (desc_tag < 0)
1827  return AVERROR_INVALIDDATA;
1828  desc_len = get8(pp, desc_list_end);
1829  if (desc_len < 0)
1830  return AVERROR_INVALIDDATA;
1831  desc_end = *pp + desc_len;
1832  if (desc_end > desc_list_end)
1833  return AVERROR_INVALIDDATA;
1834 
1835  av_log(fc, AV_LOG_TRACE, "tag: 0x%02x len=%d\n", desc_tag, desc_len);
1836 
1837  if ((st->codecpar->codec_id == AV_CODEC_ID_NONE || sti->request_probe > 0) &&
1838  stream_type == STREAM_TYPE_PRIVATE_DATA)
1839  mpegts_find_stream_type(st, desc_tag, DESC_types);
1840 
1841  switch (desc_tag) {
1842  case VIDEO_STREAM_DESCRIPTOR:
1843  if (get8(pp, desc_end) & 0x1) {
1844  st->disposition |= AV_DISPOSITION_STILL_IMAGE;
1845  }
1846  break;
1847  case SL_DESCRIPTOR:
1848  desc_es_id = get16(pp, desc_end);
1849  if (desc_es_id < 0)
1850  break;
1851  if (ts && ts->pids[pid])
1852  ts->pids[pid]->es_id = desc_es_id;
1853  for (i = 0; i < mp4_descr_count; i++)
1854  if (mp4_descr[i].dec_config_descr_len &&
1855  mp4_descr[i].es_id == desc_es_id) {
1856  FFIOContext pb;
1857  ffio_init_read_context(&pb, mp4_descr[i].dec_config_descr,
1858  mp4_descr[i].dec_config_descr_len);
1859  ff_mp4_read_dec_config_descr(fc, st, &pb.pub);
1860  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1861  st->codecpar->extradata_size > 0) {
1862  sti->need_parsing = 0;
1863  sti->need_context_update = 1;
1864  }
1865  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4SYSTEMS)
1866  mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);
1867  }
1868  break;
1869  case FMC_DESCRIPTOR:
1870  if (get16(pp, desc_end) < 0)
1871  break;
1872  if (mp4_descr_count > 0 &&
1873  (st->codecpar->codec_id == AV_CODEC_ID_AAC_LATM ||
1874  (sti->request_probe == 0 && st->codecpar->codec_id == AV_CODEC_ID_NONE) ||
1875  sti->request_probe > 0) &&
1876  mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {
1877  FFIOContext pb;
1878  ffio_init_read_context(&pb, mp4_descr->dec_config_descr,
1879  mp4_descr->dec_config_descr_len);
1880  ff_mp4_read_dec_config_descr(fc, st, &pb.pub);
1881  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1882  st->codecpar->extradata_size > 0) {
1883  sti->request_probe = sti->need_parsing = 0;
1884  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
1885  sti->need_context_update = 1;
1886  }
1887  }
1888  break;
1889  case 0x56: /* DVB teletext descriptor */
1890  {
1891  uint8_t *extradata = NULL;
1892  int language_count = desc_len / 5, ret;
1893 
1894  if (desc_len > 0 && desc_len % 5 != 0)
1895  return AVERROR_INVALIDDATA;
1896 
1897  if (language_count > 0) {
1898  /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1899  av_assert0(language_count <= sizeof(language) / 4);
1900 
1901  if (st->codecpar->extradata == NULL) {
1902  ret = ff_alloc_extradata(st->codecpar, language_count * 2);
1903  if (ret < 0)
1904  return ret;
1905  }
1906 
1907  if (st->codecpar->extradata_size < language_count * 2)
1908  return AVERROR_INVALIDDATA;
1909 
1910  extradata = st->codecpar->extradata;
1911 
1912  for (i = 0; i < language_count; i++) {
1913  language[i * 4 + 0] = get8(pp, desc_end);
1914  language[i * 4 + 1] = get8(pp, desc_end);
1915  language[i * 4 + 2] = get8(pp, desc_end);
1916  language[i * 4 + 3] = ',';
1917 
1918  memcpy(extradata, *pp, 2);
1919  extradata += 2;
1920 
1921  *pp += 2;
1922  }
1923 
1924  language[i * 4 - 1] = 0;
1925  av_dict_set(&st->metadata, "language", language, 0);
1926  sti->need_context_update = 1;
1927  }
1928  }
1929  break;
1930  case 0x59: /* subtitling descriptor */
1931  {
1932  /* 8 bytes per DVB subtitle substream data:
1933  * ISO_639_language_code (3 bytes),
1934  * subtitling_type (1 byte),
1935  * composition_page_id (2 bytes),
1936  * ancillary_page_id (2 bytes) */
1937  int language_count = desc_len / 8, ret;
1938 
1939  if (desc_len > 0 && desc_len % 8 != 0)
1940  return AVERROR_INVALIDDATA;
1941 
1942  if (language_count > 1) {
1943  avpriv_request_sample(fc, "DVB subtitles with multiple languages");
1944  }
1945 
1946  if (language_count > 0) {
1947  uint8_t *extradata;
1948 
1949  /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1950  av_assert0(language_count <= sizeof(language) / 4);
1951 
1952  if (st->codecpar->extradata == NULL) {
1953  ret = ff_alloc_extradata(st->codecpar, language_count * 5);
1954  if (ret < 0)
1955  return ret;
1956  }
1957 
1958  if (st->codecpar->extradata_size < language_count * 5)
1959  return AVERROR_INVALIDDATA;
1960 
1961  extradata = st->codecpar->extradata;
1962 
1963  for (i = 0; i < language_count; i++) {
1964  language[i * 4 + 0] = get8(pp, desc_end);
1965  language[i * 4 + 1] = get8(pp, desc_end);
1966  language[i * 4 + 2] = get8(pp, desc_end);
1967  language[i * 4 + 3] = ',';
1968 
1969  /* hearing impaired subtitles detection using subtitling_type */
1970  switch (*pp[0]) {
1971  case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */
1972  case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */
1973  case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */
1974  case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */
1975  case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */
1976  case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */
1977  st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
1978  break;
1979  }
1980 
1981  extradata[4] = get8(pp, desc_end); /* subtitling_type */
1982  memcpy(extradata, *pp, 4); /* composition_page_id and ancillary_page_id */
1983  extradata += 5;
1984 
1985  *pp += 4;
1986  }
1987 
1988  language[i * 4 - 1] = 0;
1989  av_dict_set(&st->metadata, "language", language, 0);
1990  sti->need_context_update = 1;
1991  }
1992  }
1993  break;
1994  case ISO_639_LANGUAGE_DESCRIPTOR:
1995  for (i = 0; i + 4 <= desc_len; i += 4) {
1996  language[i + 0] = get8(pp, desc_end);
1997  language[i + 1] = get8(pp, desc_end);
1998  language[i + 2] = get8(pp, desc_end);
1999  language[i + 3] = ',';
2000  switch (get8(pp, desc_end)) {
2001  case 0x01:
2002  st->disposition |= AV_DISPOSITION_CLEAN_EFFECTS;
2003  break;
2004  case 0x02:
2005  st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
2006  break;
2007  case 0x03:
2008  st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
2009  st->disposition |= AV_DISPOSITION_DESCRIPTIONS;
2010  break;
2011  }
2012  }
2013  if (i && language[0]) {
2014  language[i - 1] = 0;
2015  /* don't overwrite language, as it may already have been set by
2016  * another, more specific descriptor (e.g. supplementary audio) */
2017  av_dict_set(&st->metadata, "language", language, AV_DICT_DONT_OVERWRITE);
2018  }
2019  break;
2020  case REGISTRATION_DESCRIPTOR:
2021  st->codecpar->codec_tag = bytestream_get_le32(pp);
2022  av_log(fc, AV_LOG_TRACE, "reg_desc=%.4s\n", (char *)&st->codecpar->codec_tag);
2023  if (st->codecpar->codec_id == AV_CODEC_ID_NONE || sti->request_probe > 0) {
2024  mpegts_find_stream_type(st, st->codecpar->codec_tag, REGD_types);
2025  if (st->codecpar->codec_tag == MKTAG('B', 'S', 'S', 'D'))
2026  sti->request_probe = 50;
2027  }
2028  break;
2029  case 0x52: /* stream identifier descriptor */
2030  sti->stream_identifier = 1 + get8(pp, desc_end);
2031  break;
2032  case METADATA_DESCRIPTOR:
2033  if (get16(pp, desc_end) == 0xFFFF)
2034  *pp += 4;
2035  if (get8(pp, desc_end) == 0xFF) {
2036  st->codecpar->codec_tag = bytestream_get_le32(pp);
2037  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2038  mpegts_find_stream_type(st, st->codecpar->codec_tag, METADATA_types);
2039  }
2040  break;
2041  case 0x7f: /* DVB extension descriptor */
2042  ext_desc_tag = get8(pp, desc_end);
2043  if (ext_desc_tag < 0)
2044  return AVERROR_INVALIDDATA;
2045  if (st->codecpar->codec_id == AV_CODEC_ID_OPUS &&
2046  ext_desc_tag == 0x80) { /* User defined (provisional Opus) */
2047  if (!st->codecpar->extradata) {
2048  st->codecpar->extradata = av_mallocz(sizeof(opus_default_extradata) +
2049  AV_INPUT_BUFFER_PADDING_SIZE);
2050  if (!st->codecpar->extradata)
2051  return AVERROR(ENOMEM);
2052 
2053  st->codecpar->extradata_size = sizeof(opus_default_extradata);
2054  memcpy(st->codecpar->extradata, opus_default_extradata, sizeof(opus_default_extradata));
2055 
2056  channel_config_code = get8(pp, desc_end);
2057  if (channel_config_code < 0)
2058  return AVERROR_INVALIDDATA;
2059  if (channel_config_code <= 0x8) {
2060  st->codecpar->extradata[9] = channels = channel_config_code ? channel_config_code : 2;
2061  AV_WL32(&st->codecpar->extradata[12], 48000);
2062  st->codecpar->extradata[18] = channel_config_code ? (channels > 2) : /* Dual Mono */ 255;
2063  st->codecpar->extradata[19] = opus_stream_cnt[channel_config_code];
2064  st->codecpar->extradata[20] = opus_coupled_stream_cnt[channel_config_code];
2065  memcpy(&st->codecpar->extradata[21], opus_channel_map[channels - 1], channels);
2066  st->codecpar->extradata_size = st->codecpar->extradata[18] ? 21 + channels : 19;
2067  } else {
2068  avpriv_request_sample(fc, "Opus in MPEG-TS - channel_config_code > 0x8");
2069  }
2070  sti->need_parsing = AVSTREAM_PARSE_FULL;
2071  sti->need_context_update = 1;
2072  }
2073  }
2074  if (ext_desc_tag == 0x06) { /* supplementary audio descriptor */
2075  int flags;
2076 
2077  if (desc_len < 1)
2078  return AVERROR_INVALIDDATA;
2079  flags = get8(pp, desc_end);
2080 
2081  if ((flags & 0x80) == 0) /* mix_type */
2082  st->disposition |= AV_DISPOSITION_DEPENDENT;
2083 
2084  switch ((flags >> 2) & 0x1F) { /* editorial_classification */
2085  case 0x01:
2086  st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
2087  st->disposition |= AV_DISPOSITION_DESCRIPTIONS;
2088  break;
2089  case 0x02:
2090  st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
2091  break;
2092  case 0x03:
2093  st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
2094  break;
2095  }
2096 
2097  if (flags & 0x01) { /* language_code_present */
2098  if (desc_len < 4)
2099  return AVERROR_INVALIDDATA;
2100  language[0] = get8(pp, desc_end);
2101  language[1] = get8(pp, desc_end);
2102  language[2] = get8(pp, desc_end);
2103  language[3] = 0;
2104 
2105  /* This language always has to override a possible
2106  * ISO 639 language descriptor language */
2107  if (language[0])
2108  av_dict_set(&st->metadata, "language", language, 0);
2109  }
2110  }
2111  break;
2112  case 0x6a: /* ac-3_descriptor */
2113  {
2114  int component_type_flag = get8(pp, desc_end) & (1 << 7);
2115  if (component_type_flag) {
2116  int component_type = get8(pp, desc_end);
2117  int service_type_mask = 0x38; // 0b00111000
2118  int service_type = ((component_type & service_type_mask) >> 3);
2119  if (service_type == 0x02 /* 0b010 */) {
2120  st->disposition |= AV_DISPOSITION_DESCRIPTIONS;
2121  av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition);
2122  }
2123  }
2124  }
2125  break;
2126  case 0x7a: /* enhanced_ac-3_descriptor */
2127  {
2128  int component_type_flag = get8(pp, desc_end) & (1 << 7);
2129  if (component_type_flag) {
2130  int component_type = get8(pp, desc_end);
2131  int service_type_mask = 0x38; // 0b00111000
2132  int service_type = ((component_type & service_type_mask) >> 3);
2133  if (service_type == 0x02 /* 0b010 */) {
2134  st->disposition |= AV_DISPOSITION_DESCRIPTIONS;
2135  av_log(ts ? ts->stream : fc, AV_LOG_DEBUG, "New track disposition for id %u: %u\n", st->id, st->disposition);
2136  }
2137  }
2138  }
2139  break;
2140  case 0xfd: /* ARIB data coding type descriptor */
2141  // STD-B24, fascicle 3, chapter 4 defines private_stream_1
2142  // for captions
2143  if (stream_type == STREAM_TYPE_PRIVATE_DATA) {
2144  // This structure is defined in STD-B10, part 1, listing 5.4 and
2145  // part 2, 6.2.20).
2146  // Listing of data_component_ids is in STD-B10, part 2, Annex J.
2147  // Component tag limits are documented in TR-B14, fascicle 2,
2148  // Vol. 3, Section 2, 4.2.8.1
2149  int actual_component_tag = sti->stream_identifier - 1;
2150  int picked_profile = AV_PROFILE_UNKNOWN;
2151  int data_component_id = get16(pp, desc_end);
2152  if (data_component_id < 0)
2153  return AVERROR_INVALIDDATA;
2154 
2155  switch (data_component_id) {
2156  case 0x0008:
2157  // [0x30..0x37] are component tags utilized for
2158  // non-mobile captioning service ("profile A").
2159  if (actual_component_tag >= 0x30 &&
2160  actual_component_tag <= 0x37) {
2161  picked_profile = AV_PROFILE_ARIB_PROFILE_A;
2162  }
2163  break;
2164  case 0x0012:
2165  // component tag 0x87 signifies a mobile/partial reception
2166  // (1seg) captioning service ("profile C").
2167  if (actual_component_tag == 0x87) {
2168  picked_profile = AV_PROFILE_ARIB_PROFILE_C;
2169  }
2170  break;
2171  default:
2172  break;
2173  }
2174 
2175  if (picked_profile == AV_PROFILE_UNKNOWN)
2176  break;
2177 
2178  st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
2179  st->codecpar->codec_id = AV_CODEC_ID_ARIB_CAPTION;
2180  if (st->codecpar->profile != picked_profile) {
2181  st->codecpar->profile = picked_profile;
2182  sti->need_context_update = 1;
2183  }
2184  sti->request_probe = 0;
2185  sti->need_parsing = 0;
2186  }
2187  break;
2188  case 0xb0: /* DOVI video stream descriptor */
2189  {
2190  uint32_t buf;
2191  AVDOVIDecoderConfigurationRecord *dovi;
2192  size_t dovi_size;
2193  int dependency_pid;
2194 
2195  if (desc_end - *pp < 4) // (8 + 8 + 7 + 6 + 1 + 1 + 1) / 8
2196  return AVERROR_INVALIDDATA;
2197 
2198  dovi = av_dovi_alloc(&dovi_size);
2199  if (!dovi)
2200  return AVERROR(ENOMEM);
2201 
2202  dovi->dv_version_major = get8(pp, desc_end);
2203  dovi->dv_version_minor = get8(pp, desc_end);
2204  buf = get16(pp, desc_end);
2205  dovi->dv_profile = (buf >> 9) & 0x7f; // 7 bits
2206  dovi->dv_level = (buf >> 3) & 0x3f; // 6 bits
2207  dovi->rpu_present_flag = (buf >> 2) & 0x01; // 1 bit
2208  dovi->el_present_flag = (buf >> 1) & 0x01; // 1 bit
2209  dovi->bl_present_flag = buf & 0x01; // 1 bit
2210  if (!dovi->bl_present_flag && desc_end - *pp >= 2) {
2211  buf = get16(pp, desc_end);
2212  dependency_pid = buf >> 3; // 13 bits
2213  }
2214  if (desc_end - *pp >= 1) { // 8 bits
2215  buf = get8(pp, desc_end);
2216  dovi->dv_bl_signal_compatibility_id = (buf >> 4) & 0x0f; // 4 bits
2217  } else {
2218  // 0 stands for None
2219  // Dolby Vision V1.2.93 profiles and levels
2220  dovi->dv_bl_signal_compatibility_id = 0;
2221  }
2222 
2223  if (!av_packet_side_data_add(&st->codecpar->coded_side_data,
2224  &st->codecpar->nb_coded_side_data,
2225  AV_PKT_DATA_DOVI_CONF,
2226  (uint8_t *)dovi, dovi_size, 0)) {
2227  av_free(dovi);
2228  return AVERROR(ENOMEM);
2229  }
2230 
2231  av_log(fc, AV_LOG_TRACE, "DOVI, version: %d.%d, profile: %d, level: %d, "
2232  "rpu flag: %d, el flag: %d, bl flag: %d, dependency_pid: %d, compatibility id: %d\n",
2233  dovi->dv_version_major, dovi->dv_version_minor,
2234  dovi->dv_profile, dovi->dv_level,
2235  dovi->rpu_present_flag,
2236  dovi->el_present_flag,
2237  dovi->bl_present_flag,
2238  dependency_pid,
2239  dovi->dv_bl_signal_compatibility_id);
2240  }
2241  break;
2242  default:
2243  break;
2244  }
2245  *pp = desc_end;
2246  return 0;
2247 }
2248 
2249 static AVStream *find_matching_stream(MpegTSContext *ts, int pid, unsigned int programid,
2250  int stream_identifier, int pmt_stream_idx, struct Program *p)
2251 {
2252  AVFormatContext *s = ts->stream;
2253  AVStream *found = NULL;
2254 
2255  if (stream_identifier) { /* match based on "stream identifier descriptor" if present */
2256  for (int i = 0; i < p->nb_streams; i++) {
2257  if (p->streams[i].stream_identifier == stream_identifier)
2258  if (!found || pmt_stream_idx == i) /* fallback to idx based guess if multiple streams have the same identifier */
2259  found = s->streams[p->streams[i].idx];
2260  }
2261  } else if (pmt_stream_idx < p->nb_streams) { /* match based on position within the PMT */
2262  found = s->streams[p->streams[pmt_stream_idx].idx];
2263  }
2264 
2265  if (found) {
2266  av_log(ts->stream, AV_LOG_VERBOSE,
2267  "re-using existing %s stream %d (pid=0x%x) for new pid=0x%x\n",
2268  av_get_media_type_string(found->codecpar->codec_type),
2269  found->index, found->id, pid);
2270  }
2271 
2272  return found;
2273 }
2274 
2275 static int parse_stream_identifier_desc(const uint8_t *p, const uint8_t *p_end)
2276 {
2277  const uint8_t **pp = &p;
2278  const uint8_t *desc_list_end;
2279  const uint8_t *desc_end;
2280  int desc_list_len;
2281  int desc_len, desc_tag;
2282 
2283  desc_list_len = get16(pp, p_end);
2284  if (desc_list_len < 0)
2285  return -1;
2286  desc_list_len &= 0xfff;
2287  desc_list_end = p + desc_list_len;
2288  if (desc_list_end > p_end)
2289  return -1;
2290 
2291  while (1) {
2292  desc_tag = get8(pp, desc_list_end);
2293  if (desc_tag < 0)
2294  return -1;
2295  desc_len = get8(pp, desc_list_end);
2296  if (desc_len < 0)
2297  return -1;
2298  desc_end = *pp + desc_len;
2299  if (desc_end > desc_list_end)
2300  return -1;
2301 
2302  if (desc_tag == 0x52) {
2303  return get8(pp, desc_end);
2304  }
2305  *pp = desc_end;
2306  }
2307 
2308  return -1;
2309 }
2310 
2311 static int is_pes_stream(int stream_type, uint32_t prog_reg_desc)
2312 {
2313  return !(stream_type == 0x13 ||
2314  (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) );
2315 }
2316 
2317 static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2318 {
2319  MpegTSContext *ts = filter->u.section_filter.opaque;
2320  MpegTSSectionFilter *tssf = &filter->u.section_filter;
2321  struct Program old_program;
2322  SectionHeader h1, *h = &h1;
2323  PESContext *pes;
2324  AVStream *st;
2325  const uint8_t *p, *p_end, *desc_list_end;
2326  int program_info_length, pcr_pid, pid, stream_type;
2327  int desc_list_len;
2328  uint32_t prog_reg_desc = 0; /* registration descriptor */
2329  int stream_identifier = -1;
2330  struct Program *prg;
2331 
2332  int mp4_descr_count = 0;
2333  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
2334  int i;
2335 
2336  av_log(ts->stream, AV_LOG_TRACE, "PMT: len %i\n", section_len);
2337  hex_dump_debug(ts->stream, section, section_len);
2338 
2339  p_end = section + section_len - 4;
2340  p = section;
2341  if (parse_section_header(h, &p, p_end) < 0)
2342  return;
2343  if (h->tid != PMT_TID)
2344  return;
2345  if (!h->current_next)
2346  return;
2347  if (skip_identical(h, tssf))
2348  return;
2349 
2350  av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x sec_num=%d/%d version=%d tid=%d\n",
2351  h->id, h->sec_num, h->last_sec_num, h->version, h->tid);
2352 
2353  if (!ts->scan_all_pmts && ts->skip_changes)
2354  return;
2355 
2356  prg = get_program(ts, h->id);
2357  if (prg)
2358  old_program = *prg;
2359  else
2360  clear_program(&old_program);
2361 
2362  if (ts->skip_unknown_pmt && !prg)
2363  return;
2364  if (prg && prg->nb_pids && prg->pids[0] != ts->current_pid)
2365  return;
2366  if (!ts->skip_clear)
2367  clear_avprogram(ts, h->id);
2368  clear_program(prg);
2369  add_pid_to_program(prg, ts->current_pid);
2370 
2371  pcr_pid = get16(&p, p_end);
2372  if (pcr_pid < 0)
2373  return;
2374  pcr_pid &= 0x1fff;
2375  add_pid_to_program(prg, pcr_pid);
2376  update_av_program_info(ts->stream, h->id, pcr_pid, h->version);
2377 
2378  av_log(ts->stream, AV_LOG_TRACE, "pcr_pid=0x%x\n", pcr_pid);
2379 
2380  program_info_length = get16(&p, p_end);
2381  if (program_info_length < 0)
2382  return;
2383  program_info_length &= 0xfff;
2384  while (program_info_length >= 2) {
2385  uint8_t tag, len;
2386  tag = get8(&p, p_end);
2387  len = get8(&p, p_end);
2388 
2389  av_log(ts->stream, AV_LOG_TRACE, "program tag: 0x%02x len=%d\n", tag, len);
2390 
2391  program_info_length -= 2;
2392  if (len > program_info_length)
2393  // something else is broken, exit the program_descriptors_loop
2394  break;
2395  program_info_length -= len;
2396  if (tag == IOD_DESCRIPTOR) {
2397  get8(&p, p_end); // scope
2398  get8(&p, p_end); // label
2399  len -= 2;
2400  mp4_read_iods(ts->stream, p, len, mp4_descr + mp4_descr_count,
2401  &mp4_descr_count, MAX_MP4_DESCR_COUNT);
2402  } else if (tag == REGISTRATION_DESCRIPTOR && len >= 4) {
2403  prog_reg_desc = bytestream_get_le32(&p);
2404  len -= 4;
2405  }
2406  p += len;
2407  }
2408  p += program_info_length;
2409  if (p >= p_end)
2410  goto out;
2411 
2412  // stop parsing after pmt, we found header
2413  if (!ts->pkt)
2414  ts->stop_parse = 2;
2415 
2416  if (prg)
2417  prg->pmt_found = 1;
2418 
2419  for (i = 0; i < MAX_STREAMS_PER_PROGRAM; i++) {
2420  st = 0;
2421  pes = NULL;
2422  stream_type = get8(&p, p_end);
2423  if (stream_type < 0)
2424  break;
2425  pid = get16(&p, p_end);
2426  if (pid < 0)
2427  goto out;
2428  pid &= 0x1fff;
2429  if (pid == ts->current_pid)
2430  goto out;
2431 
2432  stream_identifier = parse_stream_identifier_desc(p, p_end) + 1;
2433 
2434  /* now create stream */
2435  if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
2436  pes = ts->pids[pid]->u.pes_filter.opaque;
2437  if (ts->merge_pmt_versions && !pes->st) {
2438  st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program);
2439  if (st) {
2440  pes->st = st;
2441  pes->stream_type = stream_type;
2442  pes->merged_st = 1;
2443  }
2444  }
2445  if (!pes->st) {
2446  pes->st = avformat_new_stream(pes->stream, NULL);
2447  if (!pes->st)
2448  goto out;
2449  pes->st->id = pes->pid;
2450  }
2451  st = pes->st;
2452  } else if (is_pes_stream(stream_type, prog_reg_desc)) {
2453  if (ts->pids[pid])
2454  mpegts_close_filter(ts, ts->pids[pid]); // wrongly added sdt filter probably
2455  pes = add_pes_stream(ts, pid, pcr_pid);
2456  if (ts->merge_pmt_versions && pes && !pes->st) {
2457  st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program);
2458  if (st) {
2459  pes->st = st;
2460  pes->stream_type = stream_type;
2461  pes->merged_st = 1;
2462  }
2463  }
2464  if (pes && !pes->st) {
2465  st = avformat_new_stream(pes->stream, NULL);
2466  if (!st)
2467  goto out;
2468  st->id = pes->pid;
2469  }
2470  } else {
2471  int idx = ff_find_stream_index(ts->stream, pid);
2472  if (idx >= 0) {
2473  st = ts->stream->streams[idx];
2474  }
2475  if (ts->merge_pmt_versions && !st) {
2476  st = find_matching_stream(ts, pid, h->id, stream_identifier, i, &old_program);
2477  }
2478  if (!st) {
2479  st = avformat_new_stream(ts->stream, NULL);
2480  if (!st)
2481  goto out;
2482  st->id = pid;
2483  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2484  if (stream_type == 0x86 && prog_reg_desc == AV_RL32("CUEI")) {
2485  mpegts_find_stream_type(st, stream_type, SCTE_types);
2486  mpegts_open_section_filter(ts, pid, scte_data_cb, ts, 1);
2487  }
2488  }
2489  }
2490 
2491  if (!st)
2492  goto out;
2493 
2494  if (pes && !pes->stream_type)
2495  mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc);
2496 
2497  add_pid_to_program(prg, pid);
2498  if (prg) {
2499  prg->streams[i].idx = st->index;
2500  prg->streams[i].stream_identifier = stream_identifier;
2501  prg->nb_streams++;
2502  }
2503 
2504  av_program_add_stream_index(ts->stream, h->id, st->index);
2505 
2506  desc_list_len = get16(&p, p_end);
2507  if (desc_list_len < 0)
2508  goto out;
2509  desc_list_len &= 0xfff;
2510  desc_list_end = p + desc_list_len;
2511  if (desc_list_end > p_end)
2512  goto out;
2513  for (;;) {
2514  if (ff_parse_mpeg2_descriptor(ts->stream, st, stream_type, &p,
2515  desc_list_end, mp4_descr,
2516  mp4_descr_count, pid, ts) < 0)
2517  break;
2518 
2519  if (pes && prog_reg_desc == AV_RL32("HDMV") &&
2520  stream_type == 0x83 && pes->sub_st) {
2521  av_program_add_stream_index(ts->stream, h->id,
2522  pes->sub_st->index);
2523  pes->sub_st->codecpar->codec_tag = st->codecpar->codec_tag;
2524  }
2525  }
2526  p = desc_list_end;
2527  }
2528 
2529  if (!ts->pids[pcr_pid])
2530  mpegts_open_pcr_filter(ts, pcr_pid);
2531 
2532 out:
2533  for (i = 0; i < mp4_descr_count; i++)
2534  av_free(mp4_descr[i].dec_config_descr);
2535 }
2536 
2537 static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
2538 {
2539  MpegTSContext *ts = filter->u.section_filter.opaque;
2540  MpegTSSectionFilter *tssf = &filter->u.section_filter;
2541  SectionHeader h1, *h = &h1;
2542  const uint8_t *p, *p_end;
2543  int sid, pmt_pid;
2544  int nb_prg = 0;
2545  AVProgram *program;
2546 
2547  av_log(ts->stream, AV_LOG_TRACE, "PAT:\n");
2548  hex_dump_debug(ts->stream, section, section_len);
2549 
2550  p_end = section + section_len - 4;
2551  p = section;
2552  if (parse_section_header(h, &p, p_end) < 0)
2553  return;
2554  if (h->tid != PAT_TID)
2555  return;
2556  if (!h->current_next)
2557  return;
2558  if (ts->skip_changes)
2559  return;
2560 
2561  if (skip_identical(h, tssf))
2562  return;
2563  ts->stream->ts_id = h->id;
2564 
2565  for (;;) {
2566  sid = get16(&p, p_end);
2567  if (sid < 0)
2568  break;
2569  pmt_pid = get16(&p, p_end);
2570  if (pmt_pid < 0)
2571  break;
2572  pmt_pid &= 0x1fff;
2573 
2574  if (pmt_pid == ts->current_pid)
2575  break;
2576 
2577  av_log(ts->stream, AV_LOG_TRACE, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
2578 
2579  if (sid == 0x0000) {
2580  /* NIT info */
2581  } else {
2582  MpegTSFilter *fil = ts->pids[pmt_pid];
2583  struct Program *prg;
2584  program = av_new_program(ts->stream, sid);
2585  if (program) {
2586  program->program_num = sid;
2587  program->pmt_pid = pmt_pid;
2588  }
2589  if (fil)
2590  if ( fil->type != MPEGTS_SECTION
2591  || fil->pid != pmt_pid
2592  || fil->u.section_filter.section_cb != pmt_cb)
2593  mpegts_close_filter(ts, ts->pids[pmt_pid]);
2594 
2595  if (!ts->pids[pmt_pid])
2596  mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
2597  prg = add_program(ts, sid);
2598  if (prg) {
2599  unsigned prg_idx = prg - ts->prg;
2600  if (prg->nb_pids && prg->pids[0] != pmt_pid)
2601  clear_program(prg);
2602  add_pid_to_program(prg, pmt_pid);
2603  if (prg_idx > nb_prg)
2604  FFSWAP(struct Program, ts->prg[nb_prg], ts->prg[prg_idx]);
2605  if (prg_idx >= nb_prg)
2606  nb_prg++;
2607  } else
2608  nb_prg = 0;
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) {
2637  ts->epg_stream = avformat_new_stream(ts->stream, NULL);
2638  if (!ts->epg_stream)
2639  return;
2640  ts->epg_stream->id = EIT_PID;
2641  ts->epg_stream->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2642  ts->epg_stream->codecpar->codec_id = AV_CODEC_ID_EPG;
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) {
2842  av_assert0(pos >= TS_PACKET_SIZE);
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");
2882  ts->stream->ctx_flags &= ~AVFMTCTX_NOHEADER;
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);
2923  ret = ffio_ensure_seekback(pb, PROBE_PACKET_MAX_BUF);
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  }
2935  av_log(s, AV_LOG_ERROR,
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 (;;) {
2949  len = ffio_read_indirect(pb, buf, TS_PACKET_SIZE, data);
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;
2978  uint8_t packet[TS_PACKET_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
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;
3005  memset(packet + TS_PACKET_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
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 
3016  ret = read_packet(s, packet, ts->raw_packet_size, &data);
3017  if (ret != 0)
3018  break;
3019  ret = handle_packet(ts, data, avio_tell(s->pb));
3020  finished_reading_packet(s, ts->raw_packet_size);
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);
3044  int dvhs_score = analyze(p->buf + TS_DVHS_PACKET_SIZE*i, TS_DVHS_PACKET_SIZE*left, TS_DVHS_PACKET_SIZE, 1);
3045  int fec_score = analyze(p->buf + TS_FEC_PACKET_SIZE *i, TS_FEC_PACKET_SIZE *left, TS_FEC_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 
3106 static int mpegts_read_header(AVFormatContext *s)
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 
3113  ffformatcontext(s)->prefer_codec_framerate = 1;
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);
3119  ts->raw_packet_size = get_packet_size(s);
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");
3122  ts->raw_packet_size = TS_PACKET_SIZE;
3123  }
3124  ts->stream = s;
3125  ts->auto_guess = 0;
3126 
3127  if (s->iformat == &ff_mpegts_demuxer) {
3128  /* normal demux */
3129 
3130  /* first do a scan to get all the services */
3131  seek_back(s, pb, pos);
3132 
3133  mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);
3134  mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);
3135  mpegts_open_section_filter(ts, EIT_PID, eit_cb, ts, 1);
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);
3158  st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
3159  st->codecpar->codec_id = AV_CODEC_ID_MPEG2TS;
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 (;;) {
3166  ret = read_packet(s, packet, ts->raw_packet_size, &data);
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) {
3172  finished_reading_packet(s, ts->raw_packet_size);
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 {
3187  finished_reading_packet(s, ts->raw_packet_size);
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 
3209 static int mpegts_raw_read_packet(AVFormatContext *s, AVPacket *pkt)
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;
3220  ret = read_packet(s, pkt->data, ts->raw_packet_size, &data);
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);
3227  finished_reading_packet(s, ts->raw_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 
3256 static int mpegts_read_packet(AVFormatContext *s, AVPacket *pkt)
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)
3282  ret = AVERROR_INVALIDDATA;
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 
3300 static int mpegts_read_close(AVFormatContext *s)
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;
3349  ff_read_frame_flush(s);
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) {
3362  ff_reduce_index(s, pkt->stream_index);
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;
3372  av_packet_unref(pkt);
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 
3382 MpegTSContext *avpriv_mpegts_parse_open(AVFormatContext *s)
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 */
3390  ts->raw_packet_size = TS_PACKET_SIZE;
3391  ts->max_packet_size = 2048000;
3392  ts->stream = s;
3393  ts->auto_guess = 1;
3394 
3395  mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1);
3396  mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1);
3397  mpegts_open_section_filter(ts, EIT_PID, eit_cb, ts, 1);
3398 
3399  return ts;
3400 }
3401 
3402 /* return the consumed length if a packet was output, or -1 if no
3403  * packet is output */
3404 int avpriv_mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt,
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 
3429 void avpriv_mpegts_parse_close(MpegTSContext *ts)
3430 {
3431  mpegts_free(ts);
3432  av_free(ts);
3433 }
3434 
3435 const AVInputFormat ff_mpegts_demuxer = {
3436  .name = "mpegts",
3437  .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
3438  .priv_data_size = sizeof(MpegTSContext),
3439  .read_probe = mpegts_probe,
3440  .read_header = mpegts_read_header,
3441  .read_packet = mpegts_read_packet,
3442  .read_close = mpegts_read_close,
3443  .read_timestamp = mpegts_get_dts,
3444  .flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
3445  .priv_class = &mpegts_class,
3446 };
3447 
3448 const AVInputFormat ff_mpegtsraw_demuxer = {
3449  .name = "mpegtsraw",
3450  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"),
3451  .priv_data_size = sizeof(MpegTSContext),
3452  .read_header = mpegts_read_header,
3453  .read_packet = mpegts_raw_read_packet,
3454  .read_close = mpegts_read_close,
3455  .read_timestamp = mpegts_get_dts,
3456  .flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
3457  .priv_class = &mpegtsraw_class,
3458 };
parse_MP4DecConfigDescrTag
static int parse_MP4DecConfigDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1559
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:912
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:423
parse_mp4_descr_arr
static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1499
new_pes_packet
static int new_pes_packet(PESContext *pes, AVPacket *pkt)
Definition: mpegts.c:1012
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:793
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:1464
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:341
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:445
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:241
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:1458
AV_CODEC_ID_PCM_BLURAY
@ AV_CODEC_ID_PCM_BLURAY
Definition: codec_id.h:354
FFFormatContext::prefer_codec_framerate
int prefer_codec_framerate
Definition: internal.h:181
PAT_PID
#define PAT_PID
Definition: mpegts.h:37
AV_OPT_FLAG_READONLY
#define AV_OPT_FLAG_READONLY
The option may not be set through the AVOptions API, only read.
Definition: opt.h:294
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:478
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:1044
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:68
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:2317
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:719
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:262
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:866
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:3747
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:912
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:339
STREAM_ID_EMM_STREAM
#define STREAM_ID_EMM_STREAM
Definition: mpegts.h:150
mpegts_close_filter
static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter)
Definition: mpegts.c:559
STREAM_ID_PADDING_STREAM
#define STREAM_ID_PADDING_STREAM
Definition: mpegts.h:145
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:143
SLConfigDescr::au_seq_num_len
int au_seq_num_len
Definition: mpegts.h:187
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:267
METADATA_types
static const StreamType METADATA_types[]
Definition: mpegts.c:878
av_unused
#define av_unused
Definition: attributes.h:131
MP4DescrParseContext::max_descr_count
int max_descr_count
Definition: mpegts.c:1465
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:1183
ff_mp4_read_dec_config_descr
int ff_mp4_read_dec_config_descr(AVFormatContext *fc, AVStream *st, AVIOContext *pb)
Definition: isom.c:328
mpegts_find_stream_type
static void mpegts_find_stream_type(AVStream *st, uint32_t stream_type, const StreamType *types)
Definition: mpegts.c:894
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:491
AV_CODEC_ID_DVB_TELETEXT
@ AV_CODEC_ID_DVB_TELETEXT
Definition: codec_id.h:557
clear_avprogram
static void clear_avprogram(MpegTSContext *ts, unsigned int programid)
Definition: mpegts.c:288
CHECK_BLOCK
#define CHECK_BLOCK
AVOption
AVOption.
Definition: opt.h:251
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:695
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:852
MpegTSState
MpegTSState
Definition: mpegts.c:238
MP4SLDescrTag
#define MP4SLDescrTag
Definition: isom.h:343
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
MP4DescrParseContext::s
AVFormatContext * s
Definition: mpegts.c:1460
buffer_pool_get
static AVBufferRef * buffer_pool_get(MpegTSContext *ts, int size)
Definition: mpegts.c:1130
PES_HEADER_SIZE
#define PES_HEADER_SIZE
Definition: mpegts.c:248
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:464
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1283
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:509
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:134
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:455
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:1462
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:708
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:556
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:334
PESContext::pts
int64_t pts
Definition: mpegts.c:267
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:486
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:174
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:590
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:253
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:708
SectionHeader::id
uint16_t id
Definition: mpegts.c:649
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:180
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:464
PROBE_PACKET_MAX_BUF
#define PROBE_PACKET_MAX_BUF
Definition: mpegts.c:64
mpegtsraw_class
static const AVClass mpegtsraw_class
Definition: mpegts.c:229
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:259
MpegTSFilter::pes_filter
MpegTSPESFilter pes_filter
Definition: mpegts.c:108
METADATA_DESCRIPTOR
#define METADATA_DESCRIPTOR
Definition: mpegts.h:164
SLConfigDescr::inst_bitrate_len
int inst_bitrate_len
Definition: mpegts.h:185
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:761
REGISTRATION_DESCRIPTOR
#define REGISTRATION_DESCRIPTOR
Definition: mpegts.h:159
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:2249
update_av_program_info
static void update_av_program_info(AVFormatContext *s, unsigned int programid, unsigned int pid, int version)
Definition: mpegts.c:350
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:420
MP4ODescrTag
#define MP4ODescrTag
Definition: isom.h:338
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:158
STREAM_ID_DSMCC_STREAM
#define STREAM_ID_DSMCC_STREAM
Definition: mpegts.h:151
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:2537
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:178
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:1670
AVProgram::discard
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:1042
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:811
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:513
FFStream::avctx
struct AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:226
SectionHeader::last_sec_num
uint8_t last_sec_num
Definition: mpegts.c:653
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:339
PESContext::sl
SLConfigDescr sl
Definition: mpegts.c:271
SLConfigDescr::use_rand_acc_pt
int use_rand_acc_pt
Definition: mpegts.h:177
SDT_PID
#define SDT_PID
Definition: mpegts.h:43
av_new_program
AVProgram * av_new_program(AVFormatContext *ac, int id)
Definition: avformat.c:281
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:443
PESContext::stream
AVFormatContext * stream
Definition: mpegts.c:256
SLConfigDescr::timestamp_len
int timestamp_len
Definition: mpegts.h:182
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:153
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:551
PESContext::sub_st
AVStream * sub_st
stream for the embedded AC3 stream in HDMV TrueHD
Definition: mpegts.c:258
ff_mp4_parse_es_descr
void ff_mp4_parse_es_descr(AVIOContext *pb, int *es_id)
Definition: isom.c:303
SectionHeader::current_next
uint8_t current_next
Definition: mpegts.c:651
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:764
PESContext::header
uint8_t header[MAX_PES_HEADER_SIZE]
Definition: mpegts.c:269
avassert.h
MPEGTS_OPTIONS
#define MPEGTS_OPTIONS
Definition: mpegts.c:186
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:808
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
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVInputFormat
Definition: avformat.h:549
StreamType::codec_id
enum AVCodecID codec_id
Definition: mpegts.c:795
PESContext
Definition: mpegts.c:251
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:547
Mp4Descr::sl
SLConfigDescr sl
Definition: mpegts.h:195
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:1795
AVFormatContext::ctx_flags
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1164
AVProgram::id
int id
Definition: avformat.h:1040
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:1814
MpegTSContext::pools
AVBufferPool * pools[32]
Definition: mpegts.c:183
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:356
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:598
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:210
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1282
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:554
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:454
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:186
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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:488
AVDOVIDecoderConfigurationRecord::dv_profile
uint8_t dv_profile
Definition: dovi_meta.h:55
PES_START_SIZE
#define PES_START_SIZE
Definition: mpegts.c:247
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:652
STREAM_ID_TYPE_E_STREAM
#define STREAM_ID_TYPE_E_STREAM
Definition: mpegts.h:152
nb_streams
static int nb_streams
Definition: ffprobe.c:328
PESContext::stream_type
int stream_type
Definition: mpegts.c:254
parse_MP4IODescrTag
static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1510
PMT_TID
#define PMT_TID
Definition: mpegts.h:81
skip_identical
static int skip_identical(const SectionHeader *h, MpegTSSectionFilter *tssf)
Definition: mpegts.c:656
opus_stream_cnt
static const uint8_t opus_stream_cnt[9]
Definition: mpegts.c:1799
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:228
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:243
MpegTSPESFilter::opaque
void * opaque
Definition: mpegts.c:80
get8
static int get8(const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:667
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:380
AV_CODEC_ID_ARIB_CAPTION
@ AV_CODEC_ID_ARIB_CAPTION
Definition: codec_id.h:575
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:312
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:391
MP4ESDescrTag
#define MP4ESDescrTag
Definition: isom.h:340
AV_CODEC_ID_AVS3
@ AV_CODEC_ID_AVS3
Definition: codec_id.h:248
MP4DescrParseContext::active_descr
Mp4Descr * active_descr
Definition: mpegts.c:1463
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1115
FMC_DESCRIPTOR
#define FMC_DESCRIPTOR
Definition: mpegts.h:163
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:474
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
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:312
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:239
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:1066
MpegTSFilter::u
union MpegTSFilter::@313 u
isom.h
AV_CODEC_ID_TIMED_ID3
@ AV_CODEC_ID_TIMED_ID3
Definition: codec_id.h:589
MpegTSContext::current_pid
int current_pid
Definition: mpegts.c:180
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:192
MpegTSFilter::es_id
int es_id
Definition: mpegts.c:102
MPEGTS_PESHEADER
@ MPEGTS_PESHEADER
Definition: mpegts.c:240
DESC_types
static const StreamType DESC_types[]
Definition: mpegts.c:885
PESContext::extended_stream_id
int extended_stream_id
Definition: mpegts.c:265
Mp4Descr::dec_config_descr_len
int dec_config_descr_len
Definition: mpegts.h:193
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:554
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:452
SectionHeader::version
uint8_t version
Definition: mpegts.c:650
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:183
AVProgram::stream_index
unsigned int * stream_index
Definition: avformat.h:1043
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:921
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:596
add_pes_stream
static PESContext * add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
Definition: mpegts.c:1434
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:792
AV_CODEC_ID_SMPTE_KLV
@ AV_CODEC_ID_SMPTE_KLV
Definition: codec_id.h:587
ff_mp4_read_descr
int ff_mp4_read_descr(AVFormatContext *fc, AVIOContext *pb, int *tag)
Definition: isom.c:294
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:511
SLConfigDescr::packet_seq_num_len
int packet_seq_num_len
Definition: mpegts.h:188
mpegts_open_pes_filter
static MpegTSFilter * mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid, PESCallback *pes_cb, void *opaque)
Definition: mpegts.c:538
PESContext::ts
MpegTSContext * ts
Definition: mpegts.c:255
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:1470
MAX_PES_HEADER_SIZE
#define MAX_PES_HEADER_SIZE
Definition: mpegts.c:249
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:1523
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:1143
SLConfigDescr::use_au_start
int use_au_start
Definition: mpegts.h:175
new_data_packet
static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt)
Definition: mpegts.c:1005
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:482
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:444
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
SCTE_types
static const StreamType SCTE_types[]
Definition: mpegts.c:839
MPEGTS_PES
@ MPEGTS_PES
Definition: mpegts.c:68
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
AVMediaType
AVMediaType
Definition: avutil.h:199
MP4DescrParseContext::descr
Mp4Descr * descr
Definition: mpegts.c:1462
AVPacket::size
int size
Definition: packet.h:492
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:271
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:648
reset_pes_packet_state
static void reset_pes_packet_state(PESContext *pes)
Definition: mpegts.c:996
FFIOContext::pub
AVIOContext pub
Definition: avio_internal.h:29
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:446
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:242
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:216
STREAM_ID_PRIVATE_STREAM_2
#define STREAM_ID_PRIVATE_STREAM_2
Definition: mpegts.h:146
SLConfigDescr::use_au_end
int use_au_end
Definition: mpegts.h:176
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:115
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:502
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:371
parse_MP4ESDescrTag
static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1537
buffer.h
AV_DISPOSITION_HEARING_IMPAIRED
#define AV_DISPOSITION_HEARING_IMPAIRED
The stream is intended for hearing impaired audiences.
Definition: avformat.h:756
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:490
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:650
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:1071
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:693
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:337
PESContext::pid
int pid
Definition: mpegts.c:252
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:497
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:388
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:1489
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:2311
SectionHeader
Definition: mpegts.c:647
ISO_639_LANGUAGE_DESCRIPTOR
#define ISO_639_LANGUAGE_DESCRIPTOR
Definition: mpegts.h:160
MP4DescrParseContext::pb
FFIOContext pb
Definition: mpegts.c:1461
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:484
avio_internal.h
IOD_DESCRIPTOR
#define IOD_DESCRIPTOR
Definition: mpegts.h:161
parse_stream_identifier_desc
static int parse_stream_identifier_desc(const uint8_t *p, const uint8_t *p_end)
Definition: mpegts.c:2275
MAX_MP4_DESCR_COUNT
#define MAX_MP4_DESCR_COUNT
Definition: mpegts.c:55
PESContext::data_index
int data_index
Definition: mpegts.c:261
AV_CODEC_ID_SMPTE_2038
@ AV_CODEC_ID_SMPTE_2038
Definition: codec_id.h:591
internal.h
get_program
static struct Program * get_program(MpegTSContext *ts, unsigned int programid)
Definition: mpegts.c:277
PAT_TID
#define PAT_TID
Definition: mpegts.h:79
ff_mpegts_demuxer
const AVInputFormat ff_mpegts_demuxer
Definition: mpegts.c:3435
MpegTSContext::pids
MpegTSFilter * pids[NB_PID_MAX]
filters for various streams specified by PMT + for the PAT and PMT
Definition: mpegts.c:179
PESContext::pes_header_size
int pes_header_size
Definition: mpegts.c:264
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:680
parse_section_header
static int parse_section_header(SectionHeader *h, const uint8_t **pp, const uint8_t *p_end)
Definition: mpegts.c:762
MpegTSContext::epg_stream
AVStream * epg_stream
Definition: mpegts.c:182
common.h
AV_CODEC_ID_EPG
@ AV_CODEC_ID_EPG
Definition: codec_id.h:582
packet
enum AVPacketSideDataType packet
Definition: decode.c:1425
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:177
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:282
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
PESContext::st
AVStream * st
Definition: mpegts.c:257
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:1039
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:175
AV_DISPOSITION_DEPENDENT
#define AV_DISPOSITION_DEPENDENT
The audio stream is intended to be mixed with another stream before presentation.
Definition: avformat.h:807
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:223
SLConfigDescr::au_len
int au_len
Definition: mpegts.h:184
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:910
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:760
MP4DescrParseContext
Definition: mpegts.c:1459
tag
uint32_t tag
Definition: movenc.c:1737
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:853
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:841
MpegTSSectionFilter::last_ver
int last_ver
Definition: mpegts.c:90
AVFormatContext::ts_id
int ts_id
Transport stream id.
Definition: avformat.h:1456
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:278
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:194
SLConfigDescr::use_timestamps
int use_timestamps
Definition: mpegts.h:179
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:793
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:1686
scte_data_cb
static void scte_data_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
Definition: mpegts.c:1766
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:1702
dict.h
AV_DISPOSITION_DESCRIPTIONS
#define AV_DISPOSITION_DESCRIPTIONS
The subtitle stream contains a textual description of the video content.
Definition: avformat.h:796
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:847
R8_CHECK_CLIP_MAX
#define R8_CHECK_CLIP_MAX(dst, maxv)
probe
static int probe(const AVProbeData *p)
Definition: act.c:38
mpegts_probe
static int mpegts_probe(const AVProbeData *p)
Definition: mpegts.c:3028
PESContext::PES_packet_length
int PES_packet_length
Definition: mpegts.c:263
AV_OPT_FLAG_EXPORT
#define AV_OPT_FLAG_EXPORT
The option is intended for exporting values to the caller.
Definition: opt.h:289
clear_program
static void clear_program(struct Program *p)
Definition: mpegts.c:303
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:162
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
defs.h
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:659
PESContext::stream_id
uint8_t stream_id
Definition: mpegts.c:266
parse_MP4SLDescrTag
static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
Definition: mpegts.c:1573
avpriv_mpegts_parse_open
MpegTSContext * avpriv_mpegts_parse_open(AVFormatContext *s)
Definition: mpegts.c:3382
PESContext::buffer
AVBufferRef * buffer
Definition: mpegts.c:270
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:823
AVDOVIDecoderConfigurationRecord::el_present_flag
uint8_t el_present_flag
Definition: dovi_meta.h:58
AVPacket::stream_index
int stream_index
Definition: packet.h:493
AVPROBE_SCORE_STREAM_RETRY
#define AVPROBE_SCORE_STREAM_RETRY
Definition: avformat.h:460
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:365
SLConfigDescr::timestamp_res
int timestamp_res
Definition: mpegts.h:181
ISO_types
static const StreamType ISO_types[]
Definition: mpegts.c:798
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:29
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:1059
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:482
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:268
Program::id
unsigned int id
Definition: mpegts.c:121
STREAM_ID_ECM_STREAM
#define STREAM_ID_ECM_STREAM
Definition: mpegts.h:149
MpegTSSectionFilter::opaque
void * opaque
Definition: mpegts.c:97
PESContext::merged_st
int merged_st
Definition: mpegts.c:272
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:468
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
STREAM_ID_PROGRAM_STREAM_DIRECTORY
#define STREAM_ID_PROGRAM_STREAM_DIRECTORY
Definition: mpegts.h:155
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:545
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:511
MP4DescrParseContext::predefined_SLConfigDescriptor_seen
int predefined_SLConfigDescriptor_seen
Definition: mpegts.c:1467
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
Stream
Definition: mpegts.c:113
d
d
Definition: ffmpeg_filter.c:368
MP4DescrParseContext::level
int level
Definition: mpegts.c:1466
bytestream.h
FFStream::stream_identifier
int stream_identifier
Stream Identifier This is the MPEG-TS stream identifier +1 0 means unknown.
Definition: internal.h:404
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:691
MpegTSContext::skip_unknown_pmt
int skip_unknown_pmt
Definition: mpegts.c:162
raw_options
static const AVOption raw_options[]
Definition: mpegts.c:217
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:243
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:1803
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:84
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:491
ff_mpegtsraw_demuxer
const AVInputFormat ff_mpegtsraw_demuxer
Definition: mpegts.c:3448
parse_mp4_descr
static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len, int target_tag)
Definition: mpegts.c:1616
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:573
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:1052
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:890
get_packet_size
static int get_packet_size(AVFormatContext *s)
Definition: mpegts.c:609
analyze
static int analyze(const uint8_t *buf, int size, int packet_size, int probe)
Definition: mpegts.c:580
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:421
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
REGD_types
static const StreamType REGD_types[]
Definition: mpegts.c:860
MISC_types
static const StreamType MISC_types[]
Definition: mpegts.c:845
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:318
options
static const AVOption options[]
Definition: mpegts.c:189
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:268
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AVProgram::pcr_pid
int pcr_pid
Definition: avformat.h:1049
FFStream::pts_wrap_reference
int64_t pts_wrap_reference
Internal data to check for wrapping of the time stamp.
Definition: internal.h:325
Mp4Descr
Definition: mpegts.h:191
SLConfigDescr
Definition: mpegts.h:174
avio_read_partial
int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:731
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:393
AV_CODEC_ID_SCTE_35
@ AV_CODEC_ID_SCTE_35
Contain timestamp estimated through PCR of program stream.
Definition: codec_id.h:581
StreamType::codec_type
enum AVMediaType codec_type
Definition: mpegts.c:794
Generated on Thu Apr 18 2024 22:42:38 for FFmpeg by   doxygen 1.8.17