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