FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mpegts.c
Go to the documentation of this file.
1 /*
2  * MPEG2 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/intreadwrite.h"
25 #include "libavutil/log.h"
26 #include "libavutil/dict.h"
27 #include "libavutil/mathematics.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/avassert.h"
30 #include "libavcodec/bytestream.h"
31 #include "libavcodec/get_bits.h"
32 #include "avformat.h"
33 #include "mpegts.h"
34 #include "internal.h"
35 #include "avio_internal.h"
36 #include "seek.h"
37 #include "mpeg.h"
38 #include "isom.h"
39 
40 /* maximum size in which we look for synchronisation if
41  * synchronisation is lost */
42 #define MAX_RESYNC_SIZE 65536
43 
44 #define MAX_PES_PAYLOAD 200 * 1024
45 
46 #define MAX_MP4_DESCR_COUNT 16
47 
48 #define MOD_UNLIKELY(modulus, dividend, divisor, prev_dividend) \
49  do { \
50  if ((prev_dividend) == 0 || (dividend) - (prev_dividend) != (divisor)) \
51  (modulus) = (dividend) % (divisor); \
52  (prev_dividend) = (dividend); \
53  } while (0)
54 
59 };
60 
61 typedef struct MpegTSFilter MpegTSFilter;
62 
63 typedef int PESCallback (MpegTSFilter *f, const uint8_t *buf, int len,
64  int is_start, int64_t pos);
65 
66 typedef struct MpegTSPESFilter {
68  void *opaque;
70 
71 typedef void SectionCallback (MpegTSFilter *f, const uint8_t *buf, int len);
72 
73 typedef void SetServiceCallback (void *opaque, int ret);
74 
75 typedef struct MpegTSSectionFilter {
79  unsigned int check_crc : 1;
80  unsigned int end_of_section_reached : 1;
82  void *opaque;
84 
85 struct MpegTSFilter {
86  int pid;
87  int es_id;
88  int last_cc; /* last cc code (-1 if first packet) */
89  int64_t last_pcr;
91  union {
94  } u;
95 };
96 
97 #define MAX_PIDS_PER_PROGRAM 64
98 struct Program {
99  unsigned int id; // program id/service id
100  unsigned int nb_pids;
101  unsigned int pids[MAX_PIDS_PER_PROGRAM];
102 
103  /** have we found pmt for this program */
105 };
106 
108  const AVClass *class;
109  /* user data */
111  /** raw packet size, including FEC if present */
113 
114  int size_stat[3];
116 #define SIZE_STAT_THRESHOLD 10
117 
118  int64_t pos47_full;
119 
120  /** if true, all pids are analyzed to find streams */
122 
123  /** compute exact PCR for each transport stream packet */
125 
126  /** fix dvb teletext pts */
128 
129  int64_t cur_pcr; /**< used to estimate the exact PCR */
130  int pcr_incr; /**< used to estimate the exact PCR */
131 
132  /* data needed to handle file based ts */
133  /** stop parsing loop */
135  /** packet containing Audio/Video data */
137  /** to detect seek */
138  int64_t last_pos;
139 
142 
144 
145  /******************************************/
146  /* private mpegts data */
147  /* scan context */
148  /** structure to keep track of Program->pids mapping */
149  unsigned int nb_prg;
150  struct Program *prg;
151 
153  /** filters for various streams specified by PMT + for the PAT and PMT */
156 };
157 
158 #define MPEGTS_OPTIONS \
159  { "resync_size", "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 }
160 
161 static const AVOption options[] = {
163  {"fix_teletext_pts", "Try to fix pts values of dvb teletext streams.", offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_INT,
164  {.i64 = 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
165  {"ts_packetsize", "Output option carrying the raw packet size.", offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
167  {"skip_changes", "Skip changing / adding streams / programs.", offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_INT,
168  {.i64 = 0}, 0, 1, 0 },
169  {"skip_clear", "Skip clearing programs.", offsetof(MpegTSContext, skip_clear), AV_OPT_TYPE_INT,
170  {.i64 = 0}, 0, 1, 0 },
171  { NULL },
172 };
173 
174 static const AVClass mpegts_class = {
175  .class_name = "mpegts demuxer",
176  .item_name = av_default_item_name,
177  .option = options,
178  .version = LIBAVUTIL_VERSION_INT,
179 };
180 
181 static const AVOption raw_options[] = {
183  { "compute_pcr", "Compute exact PCR for each transport stream packet.",
184  offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_INT,
185  { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
186  { "ts_packetsize", "Output option carrying the raw packet size.",
187  offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
188  { .i64 = 0 }, 0, 0,
190  { NULL },
191 };
192 
193 static const AVClass mpegtsraw_class = {
194  .class_name = "mpegtsraw demuxer",
195  .item_name = av_default_item_name,
196  .option = raw_options,
197  .version = LIBAVUTIL_VERSION_INT,
198 };
199 
200 /* TS stream handling */
201 
208 };
209 
210 /* enough for PES header + length */
211 #define PES_START_SIZE 6
212 #define PES_HEADER_SIZE 9
213 #define MAX_PES_HEADER_SIZE (9 + 255)
214 
215 typedef struct PESContext {
216  int pid;
217  int pcr_pid; /**< if -1 then all packets containing PCR are considered */
222  AVStream *sub_st; /**< stream for the embedded AC3 stream in HDMV TrueHD */
224  /* used to get the format */
226  int flags; /**< copied to the AVPacket flags */
230  int64_t pts, dts;
231  int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */
235 } PESContext;
236 
238 
239 static struct Program * get_program(MpegTSContext *ts, unsigned int programid)
240 {
241  int i;
242  for (i = 0; i < ts->nb_prg; i++) {
243  if (ts->prg[i].id == programid) {
244  return &ts->prg[i];
245  }
246  }
247  return NULL;
248 }
249 
250 static void clear_avprogram(MpegTSContext *ts, unsigned int programid)
251 {
252  AVProgram *prg = NULL;
253  int i;
254 
255  for (i = 0; i < ts->stream->nb_programs; i++)
256  if (ts->stream->programs[i]->id == programid) {
257  prg = ts->stream->programs[i];
258  break;
259  }
260  if (!prg)
261  return;
262  prg->nb_stream_indexes = 0;
263 }
264 
265 static void clear_program(MpegTSContext *ts, unsigned int programid)
266 {
267  int i;
268 
269  clear_avprogram(ts, programid);
270  for (i = 0; i < ts->nb_prg; i++)
271  if (ts->prg[i].id == programid) {
272  ts->prg[i].nb_pids = 0;
273  ts->prg[i].pmt_found = 0;
274  }
275 }
276 
278 {
279  av_freep(&ts->prg);
280  ts->nb_prg = 0;
281 }
282 
283 static void add_pat_entry(MpegTSContext *ts, unsigned int programid)
284 {
285  struct Program *p;
286  if (av_reallocp_array(&ts->prg, ts->nb_prg + 1, sizeof(*ts->prg)) < 0) {
287  ts->nb_prg = 0;
288  return;
289  }
290  p = &ts->prg[ts->nb_prg];
291  p->id = programid;
292  p->nb_pids = 0;
293  p->pmt_found = 0;
294  ts->nb_prg++;
295 }
296 
297 static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid,
298  unsigned int pid)
299 {
300  struct Program *p = get_program(ts, programid);
301  if (!p)
302  return;
303 
304  if (p->nb_pids >= MAX_PIDS_PER_PROGRAM)
305  return;
306  p->pids[p->nb_pids++] = pid;
307 }
308 
309 static void set_pmt_found(MpegTSContext *ts, unsigned int programid)
310 {
311  struct Program *p = get_program(ts, programid);
312  if (!p)
313  return;
314 
315  p->pmt_found = 1;
316 }
317 
318 static void set_pcr_pid(AVFormatContext *s, unsigned int programid, unsigned int pid)
319 {
320  int i;
321  for (i = 0; i < s->nb_programs; i++) {
322  if (s->programs[i]->id == programid) {
323  s->programs[i]->pcr_pid = pid;
324  break;
325  }
326  }
327 }
328 
329 /**
330  * @brief discard_pid() decides if the pid is to be discarded according
331  * to caller's programs selection
332  * @param ts : - TS context
333  * @param pid : - pid
334  * @return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL
335  * 0 otherwise
336  */
337 static int discard_pid(MpegTSContext *ts, unsigned int pid)
338 {
339  int i, j, k;
340  int used = 0, discarded = 0;
341  struct Program *p;
342 
343  /* If none of the programs have .discard=AVDISCARD_ALL then there's
344  * no way we have to discard this packet */
345  for (k = 0; k < ts->stream->nb_programs; k++)
346  if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
347  break;
348  if (k == ts->stream->nb_programs)
349  return 0;
350 
351  for (i = 0; i < ts->nb_prg; i++) {
352  p = &ts->prg[i];
353  for (j = 0; j < p->nb_pids; j++) {
354  if (p->pids[j] != pid)
355  continue;
356  // is program with id p->id set to be discarded?
357  for (k = 0; k < ts->stream->nb_programs; k++) {
358  if (ts->stream->programs[k]->id == p->id) {
359  if (ts->stream->programs[k]->discard == AVDISCARD_ALL)
360  discarded++;
361  else
362  used++;
363  }
364  }
365  }
366  }
367 
368  return !used && discarded;
369 }
370 
371 /**
372  * Assemble PES packets out of TS packets, and then call the "section_cb"
373  * function when they are complete.
374  */
376  const uint8_t *buf, int buf_size, int is_start)
377 {
378  MpegTSSectionFilter *tss = &tss1->u.section_filter;
379  int len;
380 
381  if (is_start) {
382  memcpy(tss->section_buf, buf, buf_size);
383  tss->section_index = buf_size;
384  tss->section_h_size = -1;
385  tss->end_of_section_reached = 0;
386  } else {
387  if (tss->end_of_section_reached)
388  return;
389  len = 4096 - tss->section_index;
390  if (buf_size < len)
391  len = buf_size;
392  memcpy(tss->section_buf + tss->section_index, buf, len);
393  tss->section_index += len;
394  }
395 
396  /* compute section length if possible */
397  if (tss->section_h_size == -1 && tss->section_index >= 3) {
398  len = (AV_RB16(tss->section_buf + 1) & 0xfff) + 3;
399  if (len > 4096)
400  return;
401  tss->section_h_size = len;
402  }
403 
404  if (tss->section_h_size != -1 &&
405  tss->section_index >= tss->section_h_size) {
406  int crc_valid = 1;
407  tss->end_of_section_reached = 1;
408 
409  if (tss->check_crc) {
410  crc_valid = !av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, tss->section_buf, tss->section_h_size);
411  if (crc_valid) {
412  ts->crc_validity[ tss1->pid ] = 100;
413  }else if (ts->crc_validity[ tss1->pid ] > -10) {
414  ts->crc_validity[ tss1->pid ]--;
415  }else
416  crc_valid = 2;
417  }
418  if (crc_valid)
419  tss->section_cb(tss1, tss->section_buf, tss->section_h_size);
420  }
421 }
422 
423 static MpegTSFilter *mpegts_open_filter(MpegTSContext *ts, unsigned int pid,
424  enum MpegTSFilterType type)
425 {
427 
428  av_dlog(ts->stream, "Filter: pid=0x%x\n", pid);
429 
430  if (pid >= NB_PID_MAX || ts->pids[pid])
431  return NULL;
432  filter = av_mallocz(sizeof(MpegTSFilter));
433  if (!filter)
434  return NULL;
435  ts->pids[pid] = filter;
436 
437  filter->type = type;
438  filter->pid = pid;
439  filter->es_id = -1;
440  filter->last_cc = -1;
441  filter->last_pcr= -1;
442 
443  return filter;
444 }
445 
447  unsigned int pid,
448  SectionCallback *section_cb,
449  void *opaque,
450  int check_crc)
451 {
453  MpegTSSectionFilter *sec;
454 
455  if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_SECTION)))
456  return NULL;
457  sec = &filter->u.section_filter;
458  sec->section_cb = section_cb;
459  sec->opaque = opaque;
461  sec->check_crc = check_crc;
462  if (!sec->section_buf) {
463  av_free(filter);
464  return NULL;
465  }
466  return filter;
467 }
468 
469 static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid,
470  PESCallback *pes_cb,
471  void *opaque)
472 {
474  MpegTSPESFilter *pes;
475 
476  if (!(filter = mpegts_open_filter(ts, pid, MPEGTS_PES)))
477  return NULL;
478 
479  pes = &filter->u.pes_filter;
480  pes->pes_cb = pes_cb;
481  pes->opaque = opaque;
482  return filter;
483 }
484 
485 static MpegTSFilter *mpegts_open_pcr_filter(MpegTSContext *ts, unsigned int pid)
486 {
487  return mpegts_open_filter(ts, pid, MPEGTS_PCR);
488 }
489 
491 {
492  int pid;
493 
494  pid = filter->pid;
495  if (filter->type == MPEGTS_SECTION)
497  else if (filter->type == MPEGTS_PES) {
498  PESContext *pes = filter->u.pes_filter.opaque;
499  av_buffer_unref(&pes->buffer);
500  /* referenced private data will be freed later in
501  * avformat_close_input */
502  if (!((PESContext *)filter->u.pes_filter.opaque)->st) {
503  av_freep(&filter->u.pes_filter.opaque);
504  }
505  }
506 
507  av_free(filter);
508  ts->pids[pid] = NULL;
509 }
510 
511 static int analyze(const uint8_t *buf, int size, int packet_size, int *index)
512 {
513  int stat[TS_MAX_PACKET_SIZE];
514  int stat_all = 0;
515  int i;
516  int best_score = 0;
517 
518  memset(stat, 0, packet_size * sizeof(*stat));
519 
520  for (i = 0; i < size - 3; i++) {
521  if (buf[i] == 0x47 && !(buf[i + 1] & 0x80) && buf[i + 3] != 0x47) {
522  int x = i % packet_size;
523  stat[x]++;
524  stat_all++;
525  if (stat[x] > best_score) {
526  best_score = stat[x];
527  if (index)
528  *index = x;
529  }
530  }
531  }
532 
533  return best_score - FFMAX(stat_all - 10*best_score, 0)/10;
534 }
535 
536 /* autodetect fec presence. Must have at least 1024 bytes */
537 static int get_packet_size(const uint8_t *buf, int size)
538 {
539  int score, fec_score, dvhs_score;
540 
541  if (size < (TS_FEC_PACKET_SIZE * 5 + 1))
542  return AVERROR_INVALIDDATA;
543 
544  score = analyze(buf, size, TS_PACKET_SIZE, NULL);
545  dvhs_score = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL);
546  fec_score = analyze(buf, size, TS_FEC_PACKET_SIZE, NULL);
547  av_dlog(NULL, "score: %d, dvhs_score: %d, fec_score: %d \n",
548  score, dvhs_score, fec_score);
549 
550  if (score > fec_score && score > dvhs_score)
551  return TS_PACKET_SIZE;
552  else if (dvhs_score > score && dvhs_score > fec_score)
553  return TS_DVHS_PACKET_SIZE;
554  else if (score < fec_score && dvhs_score < fec_score)
555  return TS_FEC_PACKET_SIZE;
556  else
557  return AVERROR_INVALIDDATA;
558 }
559 
560 typedef struct SectionHeader {
562  uint16_t id;
566 } SectionHeader;
567 
568 static inline int get8(const uint8_t **pp, const uint8_t *p_end)
569 {
570  const uint8_t *p;
571  int c;
572 
573  p = *pp;
574  if (p >= p_end)
575  return AVERROR_INVALIDDATA;
576  c = *p++;
577  *pp = p;
578  return c;
579 }
580 
581 static inline int get16(const uint8_t **pp, const uint8_t *p_end)
582 {
583  const uint8_t *p;
584  int c;
585 
586  p = *pp;
587  if ((p + 1) >= p_end)
588  return AVERROR_INVALIDDATA;
589  c = AV_RB16(p);
590  p += 2;
591  *pp = p;
592  return c;
593 }
594 
595 /* read and allocate a DVB string preceded by its length */
596 static char *getstr8(const uint8_t **pp, const uint8_t *p_end)
597 {
598  int len;
599  const uint8_t *p;
600  char *str;
601 
602  p = *pp;
603  len = get8(&p, p_end);
604  if (len < 0)
605  return NULL;
606  if ((p + len) > p_end)
607  return NULL;
608  str = av_malloc(len + 1);
609  if (!str)
610  return NULL;
611  memcpy(str, p, len);
612  str[len] = '\0';
613  p += len;
614  *pp = p;
615  return str;
616 }
617 
619  const uint8_t **pp, const uint8_t *p_end)
620 {
621  int val;
622 
623  val = get8(pp, p_end);
624  if (val < 0)
625  return val;
626  h->tid = val;
627  *pp += 2;
628  val = get16(pp, p_end);
629  if (val < 0)
630  return val;
631  h->id = val;
632  val = get8(pp, p_end);
633  if (val < 0)
634  return val;
635  h->version = (val >> 1) & 0x1f;
636  val = get8(pp, p_end);
637  if (val < 0)
638  return val;
639  h->sec_num = val;
640  val = get8(pp, p_end);
641  if (val < 0)
642  return val;
643  h->last_sec_num = val;
644  return 0;
645 }
646 
647 typedef struct {
648  uint32_t stream_type;
651 } StreamType;
652 
653 static const StreamType ISO_types[] = {
660  /* Makito encoder sets stream type 0x11 for AAC,
661  * so auto-detect LOAS/LATM instead of hardcoding it. */
662 #if !CONFIG_LOAS_DEMUXER
663  { 0x11, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AAC_LATM }, /* LATM syntax */
664 #endif
670  { 0 },
671 };
672 
673 static const StreamType HDMV_types[] = {
679  { 0x85, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD */
680  { 0x86, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS HD MASTER*/
681  { 0xa1, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC3 Secondary Audio */
682  { 0xa2, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS }, /* DTS Express Secondary Audio */
684  { 0 },
685 };
686 
687 /* ATSC ? */
688 static const StreamType MISC_types[] = {
691  { 0 },
692 };
693 
694 static const StreamType REGD_types[] = {
695  { MKTAG('d', 'r', 'a', 'c'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_DIRAC },
696  { MKTAG('A', 'C', '-', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 },
697  { MKTAG('B', 'S', 'S', 'D'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_S302M },
698  { MKTAG('D', 'T', 'S', '1'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
699  { MKTAG('D', 'T', 'S', '2'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
700  { MKTAG('D', 'T', 'S', '3'), AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_DTS },
701  { MKTAG('H', 'E', 'V', 'C'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_HEVC },
702  { MKTAG('K', 'L', 'V', 'A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
703  { MKTAG('V', 'C', '-', '1'), AVMEDIA_TYPE_VIDEO, AV_CODEC_ID_VC1 },
704  { 0 },
705 };
706 
707 static const StreamType METADATA_types[] = {
708  { MKTAG('K','L','V','A'), AVMEDIA_TYPE_DATA, AV_CODEC_ID_SMPTE_KLV },
709  { MKTAG('I','D','3',' '), AVMEDIA_TYPE_DATA, AV_CODEC_ID_TIMED_ID3 },
710  { 0 },
711 };
712 
713 /* descriptor present */
714 static const StreamType DESC_types[] = {
715  { 0x6a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_AC3 }, /* AC-3 descriptor */
716  { 0x7a, AVMEDIA_TYPE_AUDIO, AV_CODEC_ID_EAC3 }, /* E-AC-3 descriptor */
719  { 0x59, AVMEDIA_TYPE_SUBTITLE, AV_CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */
720  { 0 },
721 };
722 
724  uint32_t stream_type,
725  const StreamType *types)
726 {
727  if (avcodec_is_open(st->codec)) {
728  av_log(NULL, AV_LOG_DEBUG, "cannot set stream info, codec is open\n");
729  return;
730  }
731 
732  for (; types->stream_type; types++)
733  if (stream_type == types->stream_type) {
734  st->codec->codec_type = types->codec_type;
735  st->codec->codec_id = types->codec_id;
736  st->request_probe = 0;
737  return;
738  }
739 }
740 
742  uint32_t stream_type, uint32_t prog_reg_desc)
743 {
744  int old_codec_type = st->codec->codec_type;
745  int old_codec_id = st->codec->codec_id;
746 
747  if (avcodec_is_open(st->codec)) {
748  av_log(pes->stream, AV_LOG_DEBUG, "cannot set stream info, codec is open\n");
749  return 0;
750  }
751 
752  avpriv_set_pts_info(st, 33, 1, 90000);
753  st->priv_data = pes;
757  pes->st = st;
758  pes->stream_type = stream_type;
759 
760  av_log(pes->stream, AV_LOG_DEBUG,
761  "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
762  st->index, pes->stream_type, pes->pid, (char *)&prog_reg_desc);
763 
764  st->codec->codec_tag = pes->stream_type;
765 
766  mpegts_find_stream_type(st, pes->stream_type, ISO_types);
767  if ((prog_reg_desc == AV_RL32("HDMV") ||
768  prog_reg_desc == AV_RL32("HDPR")) &&
769  st->codec->codec_id == AV_CODEC_ID_NONE) {
770  mpegts_find_stream_type(st, pes->stream_type, HDMV_types);
771  if (pes->stream_type == 0x83) {
772  // HDMV TrueHD streams also contain an AC3 coded version of the
773  // audio track - add a second stream for this
774  AVStream *sub_st;
775  // priv_data cannot be shared between streams
776  PESContext *sub_pes = av_malloc(sizeof(*sub_pes));
777  if (!sub_pes)
778  return AVERROR(ENOMEM);
779  memcpy(sub_pes, pes, sizeof(*sub_pes));
780 
781  sub_st = avformat_new_stream(pes->stream, NULL);
782  if (!sub_st) {
783  av_free(sub_pes);
784  return AVERROR(ENOMEM);
785  }
786 
787  sub_st->id = pes->pid;
788  avpriv_set_pts_info(sub_st, 33, 1, 90000);
789  sub_st->priv_data = sub_pes;
791  sub_st->codec->codec_id = AV_CODEC_ID_AC3;
793  sub_pes->sub_st = pes->sub_st = sub_st;
794  }
795  }
796  if (st->codec->codec_id == AV_CODEC_ID_NONE)
797  mpegts_find_stream_type(st, pes->stream_type, MISC_types);
798  if (st->codec->codec_id == AV_CODEC_ID_NONE) {
799  st->codec->codec_id = old_codec_id;
800  st->codec->codec_type = old_codec_type;
801  }
802 
803  return 0;
804 }
805 
807 {
808  pes->pts = AV_NOPTS_VALUE;
809  pes->dts = AV_NOPTS_VALUE;
810  pes->data_index = 0;
811  pes->flags = 0;
812  av_buffer_unref(&pes->buffer);
813 }
814 
816 {
817  av_init_packet(pkt);
818 
819  pkt->buf = pes->buffer;
820  pkt->data = pes->buffer->data;
821  pkt->size = pes->data_index;
822 
823  if (pes->total_size != MAX_PES_PAYLOAD &&
824  pes->pes_header_size + pes->data_index != pes->total_size +
825  PES_START_SIZE) {
826  av_log(pes->stream, AV_LOG_WARNING, "PES packet size mismatch\n");
827  pes->flags |= AV_PKT_FLAG_CORRUPT;
828  }
829  memset(pkt->data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
830 
831  // Separate out the AC3 substream from an HDMV combined TrueHD/AC3 PID
832  if (pes->sub_st && pes->stream_type == 0x83 && pes->extended_stream_id == 0x76)
833  pkt->stream_index = pes->sub_st->index;
834  else
835  pkt->stream_index = pes->st->index;
836  pkt->pts = pes->pts;
837  pkt->dts = pes->dts;
838  /* store position of first TS packet of this PES packet */
839  pkt->pos = pes->ts_packet_pos;
840  pkt->flags = pes->flags;
841 
842  pes->buffer = NULL;
844 }
845 
846 static uint64_t get_ts64(GetBitContext *gb, int bits)
847 {
848  if (get_bits_left(gb) < bits)
849  return AV_NOPTS_VALUE;
850  return get_bits64(gb, bits);
851 }
852 
854  const uint8_t *buf, int buf_size)
855 {
856  GetBitContext gb;
857  int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;
858  int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;
859  int dts_flag = -1, cts_flag = -1;
860  int64_t dts = AV_NOPTS_VALUE, cts = AV_NOPTS_VALUE;
861 
862  init_get_bits(&gb, buf, buf_size * 8);
863 
864  if (sl->use_au_start)
865  au_start_flag = get_bits1(&gb);
866  if (sl->use_au_end)
867  au_end_flag = get_bits1(&gb);
868  if (!sl->use_au_start && !sl->use_au_end)
869  au_start_flag = au_end_flag = 1;
870  if (sl->ocr_len > 0)
871  ocr_flag = get_bits1(&gb);
872  if (sl->use_idle)
873  idle_flag = get_bits1(&gb);
874  if (sl->use_padding)
875  padding_flag = get_bits1(&gb);
876  if (padding_flag)
877  padding_bits = get_bits(&gb, 3);
878 
879  if (!idle_flag && (!padding_flag || padding_bits != 0)) {
880  if (sl->packet_seq_num_len)
882  if (sl->degr_prior_len)
883  if (get_bits1(&gb))
884  skip_bits(&gb, sl->degr_prior_len);
885  if (ocr_flag)
886  skip_bits_long(&gb, sl->ocr_len);
887  if (au_start_flag) {
888  if (sl->use_rand_acc_pt)
889  get_bits1(&gb);
890  if (sl->au_seq_num_len > 0)
891  skip_bits_long(&gb, sl->au_seq_num_len);
892  if (sl->use_timestamps) {
893  dts_flag = get_bits1(&gb);
894  cts_flag = get_bits1(&gb);
895  }
896  }
897  if (sl->inst_bitrate_len)
898  inst_bitrate_flag = get_bits1(&gb);
899  if (dts_flag == 1)
900  dts = get_ts64(&gb, sl->timestamp_len);
901  if (cts_flag == 1)
902  cts = get_ts64(&gb, sl->timestamp_len);
903  if (sl->au_len > 0)
904  skip_bits_long(&gb, sl->au_len);
905  if (inst_bitrate_flag)
907  }
908 
909  if (dts != AV_NOPTS_VALUE)
910  pes->dts = dts;
911  if (cts != AV_NOPTS_VALUE)
912  pes->pts = cts;
913 
914  if (sl->timestamp_len && sl->timestamp_res)
916 
917  return (get_bits_count(&gb) + 7) >> 3;
918 }
919 
920 /* return non zero if a packet could be constructed */
922  const uint8_t *buf, int buf_size, int is_start,
923  int64_t pos)
924 {
925  PESContext *pes = filter->u.pes_filter.opaque;
926  MpegTSContext *ts = pes->ts;
927  const uint8_t *p;
928  int len, code;
929 
930  if (!ts->pkt)
931  return 0;
932 
933  if (is_start) {
934  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
935  new_pes_packet(pes, ts->pkt);
936  ts->stop_parse = 1;
937  } else {
939  }
940  pes->state = MPEGTS_HEADER;
941  pes->ts_packet_pos = pos;
942  }
943  p = buf;
944  while (buf_size > 0) {
945  switch (pes->state) {
946  case MPEGTS_HEADER:
947  len = PES_START_SIZE - pes->data_index;
948  if (len > buf_size)
949  len = buf_size;
950  memcpy(pes->header + pes->data_index, p, len);
951  pes->data_index += len;
952  p += len;
953  buf_size -= len;
954  if (pes->data_index == PES_START_SIZE) {
955  /* we got all the PES or section header. We can now
956  * decide */
957  if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&
958  pes->header[2] == 0x01) {
959  /* it must be an mpeg2 PES stream */
960  code = pes->header[3] | 0x100;
961  av_dlog(pes->stream, "pid=%x pes_code=%#x\n", pes->pid,
962  code);
963 
964  if ((pes->st && pes->st->discard == AVDISCARD_ALL &&
965  (!pes->sub_st ||
966  pes->sub_st->discard == AVDISCARD_ALL)) ||
967  code == 0x1be) /* padding_stream */
968  goto skip;
969 
970  /* stream not present in PMT */
971  if (!pes->st) {
972  if (ts->skip_changes)
973  goto skip;
974 
975  pes->st = avformat_new_stream(ts->stream, NULL);
976  if (!pes->st)
977  return AVERROR(ENOMEM);
978  pes->st->id = pes->pid;
979  mpegts_set_stream_info(pes->st, pes, 0, 0);
980  }
981 
982  pes->total_size = AV_RB16(pes->header + 4);
983  /* NOTE: a zero total size means the PES size is
984  * unbounded */
985  if (!pes->total_size)
987 
988  /* allocate pes buffer */
989  pes->buffer = av_buffer_alloc(pes->total_size +
991  if (!pes->buffer)
992  return AVERROR(ENOMEM);
993 
994  if (code != 0x1bc && code != 0x1bf && /* program_stream_map, private_stream_2 */
995  code != 0x1f0 && code != 0x1f1 && /* ECM, EMM */
996  code != 0x1ff && code != 0x1f2 && /* program_stream_directory, DSMCC_stream */
997  code != 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */
998  pes->state = MPEGTS_PESHEADER;
999  if (pes->st->codec->codec_id == AV_CODEC_ID_NONE && !pes->st->request_probe) {
1000  av_dlog(pes->stream,
1001  "pid=%x stream_type=%x probing\n",
1002  pes->pid,
1003  pes->stream_type);
1004  pes->st->request_probe = 1;
1005  }
1006  } else {
1007  pes->state = MPEGTS_PAYLOAD;
1008  pes->data_index = 0;
1009  }
1010  } else {
1011  /* otherwise, it should be a table */
1012  /* skip packet */
1013 skip:
1014  pes->state = MPEGTS_SKIP;
1015  continue;
1016  }
1017  }
1018  break;
1019  /**********************************************/
1020  /* PES packing parsing */
1021  case MPEGTS_PESHEADER:
1022  len = PES_HEADER_SIZE - pes->data_index;
1023  if (len < 0)
1024  return AVERROR_INVALIDDATA;
1025  if (len > buf_size)
1026  len = buf_size;
1027  memcpy(pes->header + pes->data_index, p, len);
1028  pes->data_index += len;
1029  p += len;
1030  buf_size -= len;
1031  if (pes->data_index == PES_HEADER_SIZE) {
1032  pes->pes_header_size = pes->header[8] + 9;
1034  }
1035  break;
1036  case MPEGTS_PESHEADER_FILL:
1037  len = pes->pes_header_size - pes->data_index;
1038  if (len < 0)
1039  return AVERROR_INVALIDDATA;
1040  if (len > buf_size)
1041  len = buf_size;
1042  memcpy(pes->header + pes->data_index, p, len);
1043  pes->data_index += len;
1044  p += len;
1045  buf_size -= len;
1046  if (pes->data_index == pes->pes_header_size) {
1047  const uint8_t *r;
1048  unsigned int flags, pes_ext, skip;
1049 
1050  flags = pes->header[7];
1051  r = pes->header + 9;
1052  pes->pts = AV_NOPTS_VALUE;
1053  pes->dts = AV_NOPTS_VALUE;
1054  if ((flags & 0xc0) == 0x80) {
1055  pes->dts = pes->pts = ff_parse_pes_pts(r);
1056  r += 5;
1057  } else if ((flags & 0xc0) == 0xc0) {
1058  pes->pts = ff_parse_pes_pts(r);
1059  r += 5;
1060  pes->dts = ff_parse_pes_pts(r);
1061  r += 5;
1062  }
1063  pes->extended_stream_id = -1;
1064  if (flags & 0x01) { /* PES extension */
1065  pes_ext = *r++;
1066  /* Skip PES private data, program packet sequence counter and P-STD buffer */
1067  skip = (pes_ext >> 4) & 0xb;
1068  skip += skip & 0x9;
1069  r += skip;
1070  if ((pes_ext & 0x41) == 0x01 &&
1071  (r + 2) <= (pes->header + pes->pes_header_size)) {
1072  /* PES extension 2 */
1073  if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)
1074  pes->extended_stream_id = r[1];
1075  }
1076  }
1077 
1078  /* we got the full header. We parse it and get the payload */
1079  pes->state = MPEGTS_PAYLOAD;
1080  pes->data_index = 0;
1081  if (pes->stream_type == 0x12 && buf_size > 0) {
1082  int sl_header_bytes = read_sl_header(pes, &pes->sl, p,
1083  buf_size);
1084  pes->pes_header_size += sl_header_bytes;
1085  p += sl_header_bytes;
1086  buf_size -= sl_header_bytes;
1087  }
1088  if (pes->stream_type == 0x15 && buf_size >= 5) {
1089  /* skip metadata access unit header */
1090  pes->pes_header_size += 5;
1091  p += 5;
1092  buf_size -= 5;
1093  }
1094  if (pes->ts->fix_teletext_pts && pes->st->codec->codec_id == AV_CODEC_ID_DVB_TELETEXT) {
1095  AVProgram *p = NULL;
1096  while ((p = av_find_program_from_stream(pes->stream, p, pes->st->index))) {
1097  if (p->pcr_pid != -1 && p->discard != AVDISCARD_ALL) {
1098  MpegTSFilter *f = pes->ts->pids[p->pcr_pid];
1099  if (f) {
1100  AVStream *st = NULL;
1101  if (f->type == MPEGTS_PES) {
1102  PESContext *pcrpes = f->u.pes_filter.opaque;
1103  if (pcrpes)
1104  st = pcrpes->st;
1105  } else if (f->type == MPEGTS_PCR) {
1106  int i;
1107  for (i = 0; i < p->nb_stream_indexes; i++) {
1108  AVStream *pst = pes->stream->streams[p->stream_index[i]];
1109  if (pst->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1110  st = pst;
1111  }
1112  }
1113  if (f->last_pcr != -1 && st && st->discard != AVDISCARD_ALL) {
1114  // teletext packets do not always have correct timestamps,
1115  // the standard says they should be handled after 40.6 ms at most,
1116  // and the pcr error to this packet should be no more than 100 ms.
1117  // TODO: we should interpolate the PCR, not just use the last one
1118  int64_t pcr = f->last_pcr / 300;
1121  if (pes->dts == AV_NOPTS_VALUE || pes->dts < pcr) {
1122  pes->pts = pes->dts = pcr;
1123  } else if (pes->dts > pcr + 3654 + 9000) {
1124  pes->pts = pes->dts = pcr + 3654 + 9000;
1125  }
1126  break;
1127  }
1128  }
1129  }
1130  }
1131  }
1132  }
1133  break;
1134  case MPEGTS_PAYLOAD:
1135  if (pes->buffer) {
1136  if (pes->data_index > 0 &&
1137  pes->data_index + buf_size > pes->total_size) {
1138  new_pes_packet(pes, ts->pkt);
1139  pes->total_size = MAX_PES_PAYLOAD;
1140  pes->buffer = av_buffer_alloc(pes->total_size +
1142  if (!pes->buffer)
1143  return AVERROR(ENOMEM);
1144  ts->stop_parse = 1;
1145  } else if (pes->data_index == 0 &&
1146  buf_size > pes->total_size) {
1147  // pes packet size is < ts size packet and pes data is padded with 0xff
1148  // not sure if this is legal in ts but see issue #2392
1149  buf_size = pes->total_size;
1150  }
1151  memcpy(pes->buffer->data + pes->data_index, p, buf_size);
1152  pes->data_index += buf_size;
1153  /* emit complete packets with known packet size
1154  * decreases demuxer delay for infrequent packets like subtitles from
1155  * a couple of seconds to milliseconds for properly muxed files.
1156  * total_size is the number of bytes following pes_packet_length
1157  * in the pes header, i.e. not counting the first PES_START_SIZE bytes */
1158  if (!ts->stop_parse && pes->total_size < MAX_PES_PAYLOAD &&
1159  pes->pes_header_size + pes->data_index == pes->total_size + PES_START_SIZE) {
1160  ts->stop_parse = 1;
1161  new_pes_packet(pes, ts->pkt);
1162  }
1163  }
1164  buf_size = 0;
1165  break;
1166  case MPEGTS_SKIP:
1167  buf_size = 0;
1168  break;
1169  }
1170  }
1171 
1172  return 0;
1173 }
1174 
1175 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid)
1176 {
1177  MpegTSFilter *tss;
1178  PESContext *pes;
1179 
1180  /* if no pid found, then add a pid context */
1181  pes = av_mallocz(sizeof(PESContext));
1182  if (!pes)
1183  return 0;
1184  pes->ts = ts;
1185  pes->stream = ts->stream;
1186  pes->pid = pid;
1187  pes->pcr_pid = pcr_pid;
1188  pes->state = MPEGTS_SKIP;
1189  pes->pts = AV_NOPTS_VALUE;
1190  pes->dts = AV_NOPTS_VALUE;
1191  tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);
1192  if (!tss) {
1193  av_free(pes);
1194  return 0;
1195  }
1196  return pes;
1197 }
1198 
1199 #define MAX_LEVEL 4
1200 typedef struct {
1207  int level;
1210 
1212  const uint8_t *buf, unsigned size,
1213  Mp4Descr *descr, int max_descr_count)
1214 {
1215  int ret;
1216  if (size > (1 << 30))
1217  return AVERROR_INVALIDDATA;
1218 
1219  if ((ret = ffio_init_context(&d->pb, (unsigned char *)buf, size, 0,
1220  NULL, NULL, NULL, NULL)) < 0)
1221  return ret;
1222 
1223  d->s = s;
1224  d->level = 0;
1225  d->descr_count = 0;
1226  d->descr = descr;
1227  d->active_descr = NULL;
1228  d->max_descr_count = max_descr_count;
1229 
1230  return 0;
1231 }
1232 
1233 static void update_offsets(AVIOContext *pb, int64_t *off, int *len)
1234 {
1235  int64_t new_off = avio_tell(pb);
1236  (*len) -= new_off - *off;
1237  *off = new_off;
1238 }
1239 
1240 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1241  int target_tag);
1242 
1243 static int parse_mp4_descr_arr(MP4DescrParseContext *d, int64_t off, int len)
1244 {
1245  while (len > 0) {
1246  int ret = parse_mp4_descr(d, off, len, 0);
1247  if (ret < 0)
1248  return ret;
1249  update_offsets(&d->pb, &off, &len);
1250  }
1251  return 0;
1252 }
1253 
1254 static int parse_MP4IODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1255 {
1256  avio_rb16(&d->pb); // ID
1257  avio_r8(&d->pb);
1258  avio_r8(&d->pb);
1259  avio_r8(&d->pb);
1260  avio_r8(&d->pb);
1261  avio_r8(&d->pb);
1262  update_offsets(&d->pb, &off, &len);
1263  return parse_mp4_descr_arr(d, off, len);
1264 }
1265 
1266 static int parse_MP4ODescrTag(MP4DescrParseContext *d, int64_t off, int len)
1267 {
1268  int id_flags;
1269  if (len < 2)
1270  return 0;
1271  id_flags = avio_rb16(&d->pb);
1272  if (!(id_flags & 0x0020)) { // URL_Flag
1273  update_offsets(&d->pb, &off, &len);
1274  return parse_mp4_descr_arr(d, off, len); // ES_Descriptor[]
1275  } else {
1276  return 0;
1277  }
1278 }
1279 
1280 static int parse_MP4ESDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1281 {
1282  int es_id = 0;
1283  if (d->descr_count >= d->max_descr_count)
1284  return AVERROR_INVALIDDATA;
1285  ff_mp4_parse_es_descr(&d->pb, &es_id);
1286  d->active_descr = d->descr + (d->descr_count++);
1287 
1288  d->active_descr->es_id = es_id;
1289  update_offsets(&d->pb, &off, &len);
1290  parse_mp4_descr(d, off, len, MP4DecConfigDescrTag);
1291  update_offsets(&d->pb, &off, &len);
1292  if (len > 0)
1293  parse_mp4_descr(d, off, len, MP4SLDescrTag);
1294  d->active_descr = NULL;
1295  return 0;
1296 }
1297 
1299  int len)
1300 {
1301  Mp4Descr *descr = d->active_descr;
1302  if (!descr)
1303  return AVERROR_INVALIDDATA;
1305  if (!descr->dec_config_descr)
1306  return AVERROR(ENOMEM);
1307  descr->dec_config_descr_len = len;
1308  avio_read(&d->pb, descr->dec_config_descr, len);
1309  return 0;
1310 }
1311 
1312 static int parse_MP4SLDescrTag(MP4DescrParseContext *d, int64_t off, int len)
1313 {
1314  Mp4Descr *descr = d->active_descr;
1315  int predefined;
1316  if (!descr)
1317  return AVERROR_INVALIDDATA;
1318 
1319  predefined = avio_r8(&d->pb);
1320  if (!predefined) {
1321  int lengths;
1322  int flags = avio_r8(&d->pb);
1323  descr->sl.use_au_start = !!(flags & 0x80);
1324  descr->sl.use_au_end = !!(flags & 0x40);
1325  descr->sl.use_rand_acc_pt = !!(flags & 0x20);
1326  descr->sl.use_padding = !!(flags & 0x08);
1327  descr->sl.use_timestamps = !!(flags & 0x04);
1328  descr->sl.use_idle = !!(flags & 0x02);
1329  descr->sl.timestamp_res = avio_rb32(&d->pb);
1330  avio_rb32(&d->pb);
1331  descr->sl.timestamp_len = avio_r8(&d->pb);
1332  if (descr->sl.timestamp_len > 64) {
1333  avpriv_request_sample(NULL, "timestamp_len > 64");
1334  descr->sl.timestamp_len = 64;
1335  return AVERROR_PATCHWELCOME;
1336  }
1337  descr->sl.ocr_len = avio_r8(&d->pb);
1338  descr->sl.au_len = avio_r8(&d->pb);
1339  descr->sl.inst_bitrate_len = avio_r8(&d->pb);
1340  lengths = avio_rb16(&d->pb);
1341  descr->sl.degr_prior_len = lengths >> 12;
1342  descr->sl.au_seq_num_len = (lengths >> 7) & 0x1f;
1343  descr->sl.packet_seq_num_len = (lengths >> 2) & 0x1f;
1344  } else if (!d->predefined_SLConfigDescriptor_seen){
1345  avpriv_report_missing_feature(d->s, "Predefined SLConfigDescriptor");
1347  }
1348  return 0;
1349 }
1350 
1351 static int parse_mp4_descr(MP4DescrParseContext *d, int64_t off, int len,
1352  int target_tag)
1353 {
1354  int tag;
1355  int len1 = ff_mp4_read_descr(d->s, &d->pb, &tag);
1356  update_offsets(&d->pb, &off, &len);
1357  if (len < 0 || len1 > len || len1 <= 0) {
1358  av_log(d->s, AV_LOG_ERROR,
1359  "Tag %x length violation new length %d bytes remaining %d\n",
1360  tag, len1, len);
1361  return AVERROR_INVALIDDATA;
1362  }
1363 
1364  if (d->level++ >= MAX_LEVEL) {
1365  av_log(d->s, AV_LOG_ERROR, "Maximum MP4 descriptor level exceeded\n");
1366  goto done;
1367  }
1368 
1369  if (target_tag && tag != target_tag) {
1370  av_log(d->s, AV_LOG_ERROR, "Found tag %x expected %x\n", tag,
1371  target_tag);
1372  goto done;
1373  }
1374 
1375  switch (tag) {
1376  case MP4IODescrTag:
1377  parse_MP4IODescrTag(d, off, len1);
1378  break;
1379  case MP4ODescrTag:
1380  parse_MP4ODescrTag(d, off, len1);
1381  break;
1382  case MP4ESDescrTag:
1383  parse_MP4ESDescrTag(d, off, len1);
1384  break;
1385  case MP4DecConfigDescrTag:
1386  parse_MP4DecConfigDescrTag(d, off, len1);
1387  break;
1388  case MP4SLDescrTag:
1389  parse_MP4SLDescrTag(d, off, len1);
1390  break;
1391  }
1392 
1393 
1394 done:
1395  d->level--;
1396  avio_seek(&d->pb, off + len1, SEEK_SET);
1397  return 0;
1398 }
1399 
1400 static int mp4_read_iods(AVFormatContext *s, const uint8_t *buf, unsigned size,
1401  Mp4Descr *descr, int *descr_count, int max_descr_count)
1402 {
1404  int ret;
1405 
1406  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1407  if (ret < 0)
1408  return ret;
1409 
1410  ret = parse_mp4_descr(&d, avio_tell(&d.pb), size, MP4IODescrTag);
1411 
1412  *descr_count = d.descr_count;
1413  return ret;
1414 }
1415 
1416 static int mp4_read_od(AVFormatContext *s, const uint8_t *buf, unsigned size,
1417  Mp4Descr *descr, int *descr_count, int max_descr_count)
1418 {
1420  int ret;
1421 
1422  ret = init_MP4DescrParseContext(&d, s, buf, size, descr, max_descr_count);
1423  if (ret < 0)
1424  return ret;
1425 
1426  ret = parse_mp4_descr_arr(&d, avio_tell(&d.pb), size);
1427 
1428  *descr_count = d.descr_count;
1429  return ret;
1430 }
1431 
1433  int section_len)
1434 {
1435  MpegTSContext *ts = filter->u.section_filter.opaque;
1436  SectionHeader h;
1437  const uint8_t *p, *p_end;
1438  AVIOContext pb;
1439  int mp4_descr_count = 0;
1440  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
1441  int i, pid;
1442  AVFormatContext *s = ts->stream;
1443 
1444  p_end = section + section_len - 4;
1445  p = section;
1446  if (parse_section_header(&h, &p, p_end) < 0)
1447  return;
1448  if (h.tid != M4OD_TID)
1449  return;
1450 
1451  mp4_read_od(s, p, (unsigned) (p_end - p), mp4_descr, &mp4_descr_count,
1453 
1454  for (pid = 0; pid < NB_PID_MAX; pid++) {
1455  if (!ts->pids[pid])
1456  continue;
1457  for (i = 0; i < mp4_descr_count; i++) {
1458  PESContext *pes;
1459  AVStream *st;
1460  if (ts->pids[pid]->es_id != mp4_descr[i].es_id)
1461  continue;
1462  if (ts->pids[pid]->type != MPEGTS_PES) {
1463  av_log(s, AV_LOG_ERROR, "pid %x is not PES\n", pid);
1464  continue;
1465  }
1466  pes = ts->pids[pid]->u.pes_filter.opaque;
1467  st = pes->st;
1468  if (!st)
1469  continue;
1470 
1471  pes->sl = mp4_descr[i].sl;
1472 
1473  ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1474  mp4_descr[i].dec_config_descr_len, 0,
1475  NULL, NULL, NULL, NULL);
1476  ff_mp4_read_dec_config_descr(s, st, &pb);
1477  if (st->codec->codec_id == AV_CODEC_ID_AAC &&
1478  st->codec->extradata_size > 0)
1479  st->need_parsing = 0;
1480  if (st->codec->codec_id == AV_CODEC_ID_H264 &&
1481  st->codec->extradata_size > 0)
1482  st->need_parsing = 0;
1483 
1484  if (st->codec->codec_id <= AV_CODEC_ID_NONE) {
1485  // do nothing
1486  } else if (st->codec->codec_id < AV_CODEC_ID_FIRST_AUDIO)
1488  else if (st->codec->codec_id < AV_CODEC_ID_FIRST_SUBTITLE)
1490  else if (st->codec->codec_id < AV_CODEC_ID_FIRST_UNKNOWN)
1492  }
1493  }
1494  for (i = 0; i < mp4_descr_count; i++)
1495  av_free(mp4_descr[i].dec_config_descr);
1496 }
1497 
1499  const uint8_t **pp, const uint8_t *desc_list_end,
1500  Mp4Descr *mp4_descr, int mp4_descr_count, int pid,
1501  MpegTSContext *ts)
1502 {
1503  const uint8_t *desc_end;
1504  int desc_len, desc_tag, desc_es_id;
1505  char language[252];
1506  int i;
1507 
1508  desc_tag = get8(pp, desc_list_end);
1509  if (desc_tag < 0)
1510  return AVERROR_INVALIDDATA;
1511  desc_len = get8(pp, desc_list_end);
1512  if (desc_len < 0)
1513  return AVERROR_INVALIDDATA;
1514  desc_end = *pp + desc_len;
1515  if (desc_end > desc_list_end)
1516  return AVERROR_INVALIDDATA;
1517 
1518  av_dlog(fc, "tag: 0x%02x len=%d\n", desc_tag, desc_len);
1519 
1520  if ((st->codec->codec_id == AV_CODEC_ID_NONE || st->request_probe > 0) &&
1521  stream_type == STREAM_TYPE_PRIVATE_DATA)
1522  mpegts_find_stream_type(st, desc_tag, DESC_types);
1523 
1524  switch (desc_tag) {
1525  case 0x1E: /* SL descriptor */
1526  desc_es_id = get16(pp, desc_end);
1527  if (ts && ts->pids[pid])
1528  ts->pids[pid]->es_id = desc_es_id;
1529  for (i = 0; i < mp4_descr_count; i++)
1530  if (mp4_descr[i].dec_config_descr_len &&
1531  mp4_descr[i].es_id == desc_es_id) {
1532  AVIOContext pb;
1533  ffio_init_context(&pb, mp4_descr[i].dec_config_descr,
1534  mp4_descr[i].dec_config_descr_len, 0,
1535  NULL, NULL, NULL, NULL);
1536  ff_mp4_read_dec_config_descr(fc, st, &pb);
1537  if (st->codec->codec_id == AV_CODEC_ID_AAC &&
1538  st->codec->extradata_size > 0)
1539  st->need_parsing = 0;
1541  mpegts_open_section_filter(ts, pid, m4sl_cb, ts, 1);
1542  }
1543  break;
1544  case 0x1F: /* FMC descriptor */
1545  get16(pp, desc_end);
1546  if (mp4_descr_count > 0 &&
1547  (st->codec->codec_id == AV_CODEC_ID_AAC_LATM || st->request_probe > 0) &&
1548  mp4_descr->dec_config_descr_len && mp4_descr->es_id == pid) {
1549  AVIOContext pb;
1550  ffio_init_context(&pb, mp4_descr->dec_config_descr,
1551  mp4_descr->dec_config_descr_len, 0,
1552  NULL, NULL, NULL, NULL);
1553  ff_mp4_read_dec_config_descr(fc, st, &pb);
1554  if (st->codec->codec_id == AV_CODEC_ID_AAC &&
1555  st->codec->extradata_size > 0) {
1556  st->request_probe = st->need_parsing = 0;
1558  }
1559  }
1560  break;
1561  case 0x56: /* DVB teletext descriptor */
1562  {
1563  uint8_t *extradata = NULL;
1564  int language_count = desc_len / 5;
1565 
1566  if (desc_len > 0 && desc_len % 5 != 0)
1567  return AVERROR_INVALIDDATA;
1568 
1569  if (language_count > 0) {
1570  /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1571  if (language_count > sizeof(language) / 4) {
1572  language_count = sizeof(language) / 4;
1573  }
1574 
1575  if (st->codec->extradata == NULL) {
1576  if (ff_alloc_extradata(st->codec, language_count * 2)) {
1577  return AVERROR(ENOMEM);
1578  }
1579  }
1580 
1581  if (st->codec->extradata_size < language_count * 2)
1582  return AVERROR_INVALIDDATA;
1583 
1584  extradata = st->codec->extradata;
1585 
1586  for (i = 0; i < language_count; i++) {
1587  language[i * 4 + 0] = get8(pp, desc_end);
1588  language[i * 4 + 1] = get8(pp, desc_end);
1589  language[i * 4 + 2] = get8(pp, desc_end);
1590  language[i * 4 + 3] = ',';
1591 
1592  memcpy(extradata, *pp, 2);
1593  extradata += 2;
1594 
1595  *pp += 2;
1596  }
1597 
1598  language[i * 4 - 1] = 0;
1599  av_dict_set(&st->metadata, "language", language, 0);
1600  }
1601  }
1602  break;
1603  case 0x59: /* subtitling descriptor */
1604  {
1605  /* 8 bytes per DVB subtitle substream data:
1606  * ISO_639_language_code (3 bytes),
1607  * subtitling_type (1 byte),
1608  * composition_page_id (2 bytes),
1609  * ancillary_page_id (2 bytes) */
1610  int language_count = desc_len / 8;
1611 
1612  if (desc_len > 0 && desc_len % 8 != 0)
1613  return AVERROR_INVALIDDATA;
1614 
1615  if (language_count > 1) {
1616  avpriv_request_sample(fc, "DVB subtitles with multiple languages");
1617  }
1618 
1619  if (language_count > 0) {
1620  uint8_t *extradata;
1621 
1622  /* 4 bytes per language code (3 bytes) with comma or NUL byte should fit language buffer */
1623  if (language_count > sizeof(language) / 4) {
1624  language_count = sizeof(language) / 4;
1625  }
1626 
1627  if (st->codec->extradata == NULL) {
1628  if (ff_alloc_extradata(st->codec, language_count * 5)) {
1629  return AVERROR(ENOMEM);
1630  }
1631  }
1632 
1633  if (st->codec->extradata_size < language_count * 5)
1634  return AVERROR_INVALIDDATA;
1635 
1636  extradata = st->codec->extradata;
1637 
1638  for (i = 0; i < language_count; i++) {
1639  language[i * 4 + 0] = get8(pp, desc_end);
1640  language[i * 4 + 1] = get8(pp, desc_end);
1641  language[i * 4 + 2] = get8(pp, desc_end);
1642  language[i * 4 + 3] = ',';
1643 
1644  /* hearing impaired subtitles detection using subtitling_type */
1645  switch (*pp[0]) {
1646  case 0x20: /* DVB subtitles (for the hard of hearing) with no monitor aspect ratio criticality */
1647  case 0x21: /* DVB subtitles (for the hard of hearing) for display on 4:3 aspect ratio monitor */
1648  case 0x22: /* DVB subtitles (for the hard of hearing) for display on 16:9 aspect ratio monitor */
1649  case 0x23: /* DVB subtitles (for the hard of hearing) for display on 2.21:1 aspect ratio monitor */
1650  case 0x24: /* DVB subtitles (for the hard of hearing) for display on a high definition monitor */
1651  case 0x25: /* DVB subtitles (for the hard of hearing) with plano-stereoscopic disparity for display on a high definition monitor */
1653  break;
1654  }
1655 
1656  extradata[4] = get8(pp, desc_end); /* subtitling_type */
1657  memcpy(extradata, *pp, 4); /* composition_page_id and ancillary_page_id */
1658  extradata += 5;
1659 
1660  *pp += 4;
1661  }
1662 
1663  language[i * 4 - 1] = 0;
1664  av_dict_set(&st->metadata, "language", language, 0);
1665  }
1666  }
1667  break;
1668  case 0x0a: /* ISO 639 language descriptor */
1669  for (i = 0; i + 4 <= desc_len; i += 4) {
1670  language[i + 0] = get8(pp, desc_end);
1671  language[i + 1] = get8(pp, desc_end);
1672  language[i + 2] = get8(pp, desc_end);
1673  language[i + 3] = ',';
1674  switch (get8(pp, desc_end)) {
1675  case 0x01:
1677  break;
1678  case 0x02:
1680  break;
1681  case 0x03:
1683  break;
1684  }
1685  }
1686  if (i && language[0]) {
1687  language[i - 1] = 0;
1688  av_dict_set(&st->metadata, "language", language, 0);
1689  }
1690  break;
1691  case 0x05: /* registration descriptor */
1692  st->codec->codec_tag = bytestream_get_le32(pp);
1693  av_dlog(fc, "reg_desc=%.4s\n", (char *)&st->codec->codec_tag);
1694  if (st->codec->codec_id == AV_CODEC_ID_NONE)
1695  mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types);
1696  break;
1697  case 0x52: /* stream identifier descriptor */
1698  st->stream_identifier = 1 + get8(pp, desc_end);
1699  break;
1700  case 0x26: /* metadata descriptor */
1701  if (get16(pp, desc_end) == 0xFFFF)
1702  *pp += 4;
1703  if (get8(pp, desc_end) == 0xFF) {
1704  st->codec->codec_tag = bytestream_get_le32(pp);
1705  if (st->codec->codec_id == AV_CODEC_ID_NONE)
1706  mpegts_find_stream_type(st, st->codec->codec_tag, METADATA_types);
1707  }
1708  break;
1709  default:
1710  break;
1711  }
1712  *pp = desc_end;
1713  return 0;
1714 }
1715 
1716 static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
1717 {
1718  MpegTSContext *ts = filter->u.section_filter.opaque;
1719  SectionHeader h1, *h = &h1;
1720  PESContext *pes;
1721  AVStream *st;
1722  const uint8_t *p, *p_end, *desc_list_end;
1723  int program_info_length, pcr_pid, pid, stream_type;
1724  int desc_list_len;
1725  uint32_t prog_reg_desc = 0; /* registration descriptor */
1726 
1727  int mp4_descr_count = 0;
1728  Mp4Descr mp4_descr[MAX_MP4_DESCR_COUNT] = { { 0 } };
1729  int i;
1730 
1731  av_dlog(ts->stream, "PMT: len %i\n", section_len);
1732  hex_dump_debug(ts->stream, section, section_len);
1733 
1734  p_end = section + section_len - 4;
1735  p = section;
1736  if (parse_section_header(h, &p, p_end) < 0)
1737  return;
1738 
1739  av_dlog(ts->stream, "sid=0x%x sec_num=%d/%d\n",
1740  h->id, h->sec_num, h->last_sec_num);
1741 
1742  if (h->tid != PMT_TID)
1743  return;
1744  if (ts->skip_changes)
1745  return;
1746 
1747  clear_program(ts, h->id);
1748  pcr_pid = get16(&p, p_end);
1749  if (pcr_pid < 0)
1750  return;
1751  pcr_pid &= 0x1fff;
1752  add_pid_to_pmt(ts, h->id, pcr_pid);
1753  set_pcr_pid(ts->stream, h->id, pcr_pid);
1754 
1755  av_dlog(ts->stream, "pcr_pid=0x%x\n", pcr_pid);
1756 
1757  program_info_length = get16(&p, p_end);
1758  if (program_info_length < 0)
1759  return;
1760  program_info_length &= 0xfff;
1761  while (program_info_length >= 2) {
1762  uint8_t tag, len;
1763  tag = get8(&p, p_end);
1764  len = get8(&p, p_end);
1765 
1766  av_dlog(ts->stream, "program tag: 0x%02x len=%d\n", tag, len);
1767 
1768  if (len > program_info_length - 2)
1769  // something else is broken, exit the program_descriptors_loop
1770  break;
1771  program_info_length -= len + 2;
1772  if (tag == 0x1d) { // IOD descriptor
1773  get8(&p, p_end); // scope
1774  get8(&p, p_end); // label
1775  len -= 2;
1776  mp4_read_iods(ts->stream, p, len, mp4_descr + mp4_descr_count,
1777  &mp4_descr_count, MAX_MP4_DESCR_COUNT);
1778  } else if (tag == 0x05 && len >= 4) { // registration descriptor
1779  prog_reg_desc = bytestream_get_le32(&p);
1780  len -= 4;
1781  }
1782  p += len;
1783  }
1784  p += program_info_length;
1785  if (p >= p_end)
1786  goto out;
1787 
1788  // stop parsing after pmt, we found header
1789  if (!ts->stream->nb_streams)
1790  ts->stop_parse = 2;
1791 
1792  set_pmt_found(ts, h->id);
1793 
1794 
1795  for (;;) {
1796  st = 0;
1797  pes = NULL;
1798  stream_type = get8(&p, p_end);
1799  if (stream_type < 0)
1800  break;
1801  pid = get16(&p, p_end);
1802  if (pid < 0)
1803  goto out;
1804  pid &= 0x1fff;
1805  if (pid == ts->current_pid)
1806  goto out;
1807 
1808  /* now create stream */
1809  if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
1810  pes = ts->pids[pid]->u.pes_filter.opaque;
1811  if (!pes->st) {
1812  pes->st = avformat_new_stream(pes->stream, NULL);
1813  if (!pes->st)
1814  goto out;
1815  pes->st->id = pes->pid;
1816  }
1817  st = pes->st;
1818  } else if (stream_type != 0x13) {
1819  if (ts->pids[pid])
1820  mpegts_close_filter(ts, ts->pids[pid]); // wrongly added sdt filter probably
1821  pes = add_pes_stream(ts, pid, pcr_pid);
1822  if (pes) {
1823  st = avformat_new_stream(pes->stream, NULL);
1824  if (!st)
1825  goto out;
1826  st->id = pes->pid;
1827  }
1828  } else {
1829  int idx = ff_find_stream_index(ts->stream, pid);
1830  if (idx >= 0) {
1831  st = ts->stream->streams[idx];
1832  } else {
1833  st = avformat_new_stream(ts->stream, NULL);
1834  if (!st)
1835  goto out;
1836  st->id = pid;
1838  }
1839  }
1840 
1841  if (!st)
1842  goto out;
1843 
1844  if (pes && !pes->stream_type)
1845  mpegts_set_stream_info(st, pes, stream_type, prog_reg_desc);
1846 
1847  add_pid_to_pmt(ts, h->id, pid);
1848 
1850 
1851  desc_list_len = get16(&p, p_end);
1852  if (desc_list_len < 0)
1853  goto out;
1854  desc_list_len &= 0xfff;
1855  desc_list_end = p + desc_list_len;
1856  if (desc_list_end > p_end)
1857  goto out;
1858  for (;;) {
1859  if (ff_parse_mpeg2_descriptor(ts->stream, st, stream_type, &p,
1860  desc_list_end, mp4_descr,
1861  mp4_descr_count, pid, ts) < 0)
1862  break;
1863 
1864  if (pes && prog_reg_desc == AV_RL32("HDMV") &&
1865  stream_type == 0x83 && pes->sub_st) {
1867  pes->sub_st->index);
1868  pes->sub_st->codec->codec_tag = st->codec->codec_tag;
1869  }
1870  }
1871  p = desc_list_end;
1872  }
1873 
1874  if (!ts->pids[pcr_pid])
1875  mpegts_open_pcr_filter(ts, pcr_pid);
1876 
1877 out:
1878  for (i = 0; i < mp4_descr_count; i++)
1879  av_free(mp4_descr[i].dec_config_descr);
1880 }
1881 
1882 static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
1883 {
1884  MpegTSContext *ts = filter->u.section_filter.opaque;
1885  SectionHeader h1, *h = &h1;
1886  const uint8_t *p, *p_end;
1887  int sid, pmt_pid;
1888  AVProgram *program;
1889 
1890  av_dlog(ts->stream, "PAT:\n");
1891  hex_dump_debug(ts->stream, section, section_len);
1892 
1893  p_end = section + section_len - 4;
1894  p = section;
1895  if (parse_section_header(h, &p, p_end) < 0)
1896  return;
1897  if (h->tid != PAT_TID)
1898  return;
1899  if (ts->skip_changes)
1900  return;
1901 
1902  ts->stream->ts_id = h->id;
1903 
1904  clear_programs(ts);
1905  for (;;) {
1906  sid = get16(&p, p_end);
1907  if (sid < 0)
1908  break;
1909  pmt_pid = get16(&p, p_end);
1910  if (pmt_pid < 0)
1911  break;
1912  pmt_pid &= 0x1fff;
1913 
1914  if (pmt_pid == ts->current_pid)
1915  break;
1916 
1917  av_dlog(ts->stream, "sid=0x%x pid=0x%x\n", sid, pmt_pid);
1918 
1919  if (sid == 0x0000) {
1920  /* NIT info */
1921  } else {
1922  MpegTSFilter *fil = ts->pids[pmt_pid];
1923  program = av_new_program(ts->stream, sid);
1924  program->program_num = sid;
1925  program->pmt_pid = pmt_pid;
1926  if (fil)
1927  if ( fil->type != MPEGTS_SECTION
1928  || fil->pid != pmt_pid
1929  || fil->u.section_filter.section_cb != pmt_cb)
1930  mpegts_close_filter(ts, ts->pids[pmt_pid]);
1931 
1932  if (!ts->pids[pmt_pid])
1933  mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1);
1934  add_pat_entry(ts, sid);
1935  add_pid_to_pmt(ts, sid, 0); // add pat pid to program
1936  add_pid_to_pmt(ts, sid, pmt_pid);
1937  }
1938  }
1939 
1940  if (sid < 0) {
1941  int i,j;
1942  for (j=0; j<ts->stream->nb_programs; j++) {
1943  for (i = 0; i < ts->nb_prg; i++)
1944  if (ts->prg[i].id == ts->stream->programs[j]->id)
1945  break;
1946  if (i==ts->nb_prg && !ts->skip_clear)
1947  clear_avprogram(ts, ts->stream->programs[j]->id);
1948  }
1949  }
1950 }
1951 
1952 static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
1953 {
1954  MpegTSContext *ts = filter->u.section_filter.opaque;
1955  SectionHeader h1, *h = &h1;
1956  const uint8_t *p, *p_end, *desc_list_end, *desc_end;
1957  int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
1958  char *name, *provider_name;
1959 
1960  av_dlog(ts->stream, "SDT:\n");
1961  hex_dump_debug(ts->stream, section, section_len);
1962 
1963  p_end = section + section_len - 4;
1964  p = section;
1965  if (parse_section_header(h, &p, p_end) < 0)
1966  return;
1967  if (h->tid != SDT_TID)
1968  return;
1969  if (ts->skip_changes)
1970  return;
1971  onid = get16(&p, p_end);
1972  if (onid < 0)
1973  return;
1974  val = get8(&p, p_end);
1975  if (val < 0)
1976  return;
1977  for (;;) {
1978  sid = get16(&p, p_end);
1979  if (sid < 0)
1980  break;
1981  val = get8(&p, p_end);
1982  if (val < 0)
1983  break;
1984  desc_list_len = get16(&p, p_end);
1985  if (desc_list_len < 0)
1986  break;
1987  desc_list_len &= 0xfff;
1988  desc_list_end = p + desc_list_len;
1989  if (desc_list_end > p_end)
1990  break;
1991  for (;;) {
1992  desc_tag = get8(&p, desc_list_end);
1993  if (desc_tag < 0)
1994  break;
1995  desc_len = get8(&p, desc_list_end);
1996  desc_end = p + desc_len;
1997  if (desc_end > desc_list_end)
1998  break;
1999 
2000  av_dlog(ts->stream, "tag: 0x%02x len=%d\n",
2001  desc_tag, desc_len);
2002 
2003  switch (desc_tag) {
2004  case 0x48:
2005  service_type = get8(&p, p_end);
2006  if (service_type < 0)
2007  break;
2008  provider_name = getstr8(&p, p_end);
2009  if (!provider_name)
2010  break;
2011  name = getstr8(&p, p_end);
2012  if (name) {
2013  AVProgram *program = av_new_program(ts->stream, sid);
2014  if (program) {
2015  av_dict_set(&program->metadata, "service_name", name, 0);
2016  av_dict_set(&program->metadata, "service_provider",
2017  provider_name, 0);
2018  }
2019  }
2020  av_free(name);
2021  av_free(provider_name);
2022  break;
2023  default:
2024  break;
2025  }
2026  p = desc_end;
2027  }
2028  p = desc_list_end;
2029  }
2030 }
2031 
2032 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low,
2033  const uint8_t *packet);
2034 
2035 /* handle one TS packet */
2036 static int handle_packet(MpegTSContext *ts, const uint8_t *packet)
2037 {
2038  MpegTSFilter *tss;
2039  int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,
2040  has_adaptation, has_payload;
2041  const uint8_t *p, *p_end;
2042  int64_t pos;
2043 
2044  pid = AV_RB16(packet + 1) & 0x1fff;
2045  if (pid && discard_pid(ts, pid))
2046  return 0;
2047  is_start = packet[1] & 0x40;
2048  tss = ts->pids[pid];
2049  if (ts->auto_guess && !tss && is_start) {
2050  add_pes_stream(ts, pid, -1);
2051  tss = ts->pids[pid];
2052  }
2053  if (!tss)
2054  return 0;
2055  ts->current_pid = pid;
2056 
2057  afc = (packet[3] >> 4) & 3;
2058  if (afc == 0) /* reserved value */
2059  return 0;
2060  has_adaptation = afc & 2;
2061  has_payload = afc & 1;
2062  is_discontinuity = has_adaptation &&
2063  packet[4] != 0 && /* with length > 0 */
2064  (packet[5] & 0x80); /* and discontinuity indicated */
2065 
2066  /* continuity check (currently not used) */
2067  cc = (packet[3] & 0xf);
2068  expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc;
2069  cc_ok = pid == 0x1FFF || // null packet PID
2070  is_discontinuity ||
2071  tss->last_cc < 0 ||
2072  expected_cc == cc;
2073 
2074  tss->last_cc = cc;
2075  if (!cc_ok) {
2076  av_log(ts->stream, AV_LOG_DEBUG,
2077  "Continuity check failed for pid %d expected %d got %d\n",
2078  pid, expected_cc, cc);
2079  if (tss->type == MPEGTS_PES) {
2080  PESContext *pc = tss->u.pes_filter.opaque;
2081  pc->flags |= AV_PKT_FLAG_CORRUPT;
2082  }
2083  }
2084 
2085  p = packet + 4;
2086  if (has_adaptation) {
2087  int64_t pcr_h;
2088  int pcr_l;
2089  if (parse_pcr(&pcr_h, &pcr_l, packet) == 0)
2090  tss->last_pcr = pcr_h * 300 + pcr_l;
2091  /* skip adaptation field */
2092  p += p[0] + 1;
2093  }
2094  /* if past the end of packet, ignore */
2095  p_end = packet + TS_PACKET_SIZE;
2096  if (p >= p_end || !has_payload)
2097  return 0;
2098 
2099  pos = avio_tell(ts->stream->pb);
2100  if (pos >= 0) {
2101  av_assert0(pos >= TS_PACKET_SIZE);
2102  ts->pos47_full = pos - TS_PACKET_SIZE;
2103  }
2104 
2105  if (tss->type == MPEGTS_SECTION) {
2106  if (is_start) {
2107  /* pointer field present */
2108  len = *p++;
2109  if (p + len > p_end)
2110  return 0;
2111  if (len && cc_ok) {
2112  /* write remaining section bytes */
2113  write_section_data(ts, tss,
2114  p, len, 0);
2115  /* check whether filter has been closed */
2116  if (!ts->pids[pid])
2117  return 0;
2118  }
2119  p += len;
2120  if (p < p_end) {
2121  write_section_data(ts, tss,
2122  p, p_end - p, 1);
2123  }
2124  } else {
2125  if (cc_ok) {
2126  write_section_data(ts, tss,
2127  p, p_end - p, 0);
2128  }
2129  }
2130 
2131  // stop find_stream_info from waiting for more streams
2132  // when all programs have received a PMT
2133  if (ts->stream->ctx_flags & AVFMTCTX_NOHEADER) {
2134  int i;
2135  for (i = 0; i < ts->nb_prg; i++) {
2136  if (!ts->prg[i].pmt_found)
2137  break;
2138  }
2139  if (i == ts->nb_prg && ts->nb_prg > 0) {
2140  if (ts->stream->nb_streams > 1 || pos > 100000) {
2141  av_log(ts->stream, AV_LOG_DEBUG, "All programs have pmt, headers found\n");
2143  }
2144  }
2145  }
2146 
2147  } else {
2148  int ret;
2149  // Note: The position here points actually behind the current packet.
2150  if (tss->type == MPEGTS_PES) {
2151  if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
2152  pos - ts->raw_packet_size)) < 0)
2153  return ret;
2154  }
2155  }
2156 
2157  return 0;
2158 }
2159 
2160 static void reanalyze(MpegTSContext *ts) {
2161  AVIOContext *pb = ts->stream->pb;
2162  int64_t pos = avio_tell(pb);
2163  if (pos < 0)
2164  return;
2165  pos -= ts->pos47_full;
2166  if (pos == TS_PACKET_SIZE) {
2167  ts->size_stat[0] ++;
2168  } else if (pos == TS_DVHS_PACKET_SIZE) {
2169  ts->size_stat[1] ++;
2170  } else if (pos == TS_FEC_PACKET_SIZE) {
2171  ts->size_stat[2] ++;
2172  }
2173 
2174  ts->size_stat_count ++;
2176  int newsize = 0;
2177  if (ts->size_stat[0] > SIZE_STAT_THRESHOLD) {
2178  newsize = TS_PACKET_SIZE;
2179  } else if (ts->size_stat[1] > SIZE_STAT_THRESHOLD) {
2180  newsize = TS_DVHS_PACKET_SIZE;
2181  } else if (ts->size_stat[2] > SIZE_STAT_THRESHOLD) {
2182  newsize = TS_FEC_PACKET_SIZE;
2183  }
2184  if (newsize && newsize != ts->raw_packet_size) {
2185  av_log(ts->stream, AV_LOG_WARNING, "changing packet size to %d\n", newsize);
2186  ts->raw_packet_size = newsize;
2187  }
2188  ts->size_stat_count = 0;
2189  memset(ts->size_stat, 0, sizeof(ts->size_stat));
2190  }
2191 }
2192 
2193 /* XXX: try to find a better synchro over several packets (use
2194  * get_packet_size() ?) */
2196 {
2197  MpegTSContext *ts = s->priv_data;
2198  AVIOContext *pb = s->pb;
2199  int c, i;
2200 
2201  for (i = 0; i < ts->resync_size; i++) {
2202  c = avio_r8(pb);
2203  if (avio_feof(pb))
2204  return AVERROR_EOF;
2205  if (c == 0x47) {
2206  avio_seek(pb, -1, SEEK_CUR);
2207  reanalyze(s->priv_data);
2208  return 0;
2209  }
2210  }
2211  av_log(s, AV_LOG_ERROR,
2212  "max resync size reached, could not find sync byte\n");
2213  /* no sync found */
2214  return AVERROR_INVALIDDATA;
2215 }
2216 
2217 /* return AVERROR_something if error or EOF. Return 0 if OK. */
2218 static int read_packet(AVFormatContext *s, uint8_t *buf, int raw_packet_size,
2219  const uint8_t **data)
2220 {
2221  AVIOContext *pb = s->pb;
2222  int len;
2223 
2224  for (;;) {
2225  len = ffio_read_indirect(pb, buf, TS_PACKET_SIZE, data);
2226  if (len != TS_PACKET_SIZE)
2227  return len < 0 ? len : AVERROR_EOF;
2228  /* check packet sync byte */
2229  if ((*data)[0] != 0x47) {
2230  /* find a new packet start */
2231  uint64_t pos = avio_tell(pb);
2232  avio_seek(pb, -FFMIN(raw_packet_size, pos), SEEK_CUR);
2233 
2234  if (mpegts_resync(s) < 0)
2235  return AVERROR(EAGAIN);
2236  else
2237  continue;
2238  } else {
2239  break;
2240  }
2241  }
2242  return 0;
2243 }
2244 
2245 static void finished_reading_packet(AVFormatContext *s, int raw_packet_size)
2246 {
2247  AVIOContext *pb = s->pb;
2248  int skip = raw_packet_size - TS_PACKET_SIZE;
2249  if (skip > 0)
2250  avio_skip(pb, skip);
2251 }
2252 
2253 static int handle_packets(MpegTSContext *ts, int64_t nb_packets)
2254 {
2255  AVFormatContext *s = ts->stream;
2257  const uint8_t *data;
2258  int64_t packet_num;
2259  int ret = 0;
2260 
2261  if (avio_tell(s->pb) != ts->last_pos) {
2262  int i;
2263  av_dlog(ts->stream, "Skipping after seek\n");
2264  /* seek detected, flush pes buffer */
2265  for (i = 0; i < NB_PID_MAX; i++) {
2266  if (ts->pids[i]) {
2267  if (ts->pids[i]->type == MPEGTS_PES) {
2268  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
2269  av_buffer_unref(&pes->buffer);
2270  pes->data_index = 0;
2271  pes->state = MPEGTS_SKIP; /* skip until pes header */
2272  }
2273  ts->pids[i]->last_cc = -1;
2274  ts->pids[i]->last_pcr = -1;
2275  }
2276  }
2277  }
2278 
2279  ts->stop_parse = 0;
2280  packet_num = 0;
2281  memset(packet + TS_PACKET_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2282  for (;;) {
2283  packet_num++;
2284  if (nb_packets != 0 && packet_num >= nb_packets ||
2285  ts->stop_parse > 1) {
2286  ret = AVERROR(EAGAIN);
2287  break;
2288  }
2289  if (ts->stop_parse > 0)
2290  break;
2291 
2292  ret = read_packet(s, packet, ts->raw_packet_size, &data);
2293  if (ret != 0)
2294  break;
2295  ret = handle_packet(ts, data);
2297  if (ret != 0)
2298  break;
2299  }
2300  ts->last_pos = avio_tell(s->pb);
2301  return ret;
2302 }
2303 
2305 {
2306  const int size = p->buf_size;
2307  int maxscore = 0;
2308  int sumscore = 0;
2309  int i;
2310  int check_count = size / TS_FEC_PACKET_SIZE;
2311 #define CHECK_COUNT 10
2312 #define CHECK_BLOCK 100
2313 
2314  if (check_count < CHECK_COUNT)
2315  return AVERROR_INVALIDDATA;
2316 
2317  for (i = 0; i<check_count; i+=CHECK_BLOCK) {
2318  int left = FFMIN(check_count - i, CHECK_BLOCK);
2319  int score = analyze(p->buf + TS_PACKET_SIZE *i, TS_PACKET_SIZE *left, TS_PACKET_SIZE , NULL);
2320  int dvhs_score = analyze(p->buf + TS_DVHS_PACKET_SIZE*i, TS_DVHS_PACKET_SIZE*left, TS_DVHS_PACKET_SIZE, NULL);
2321  int fec_score = analyze(p->buf + TS_FEC_PACKET_SIZE *i, TS_FEC_PACKET_SIZE *left, TS_FEC_PACKET_SIZE , NULL);
2322  score = FFMAX3(score, dvhs_score, fec_score);
2323  sumscore += score;
2324  maxscore = FFMAX(maxscore, score);
2325  }
2326 
2327  sumscore = sumscore * CHECK_COUNT / check_count;
2328  maxscore = maxscore * CHECK_COUNT / CHECK_BLOCK;
2329 
2330  av_dlog(0, "TS score: %d %d\n", sumscore, maxscore);
2331 
2332  if (sumscore > 6) return AVPROBE_SCORE_MAX + sumscore - CHECK_COUNT;
2333  else if (maxscore > 6) return AVPROBE_SCORE_MAX/2 + sumscore - CHECK_COUNT;
2334  else
2335  return AVERROR_INVALIDDATA;
2336 }
2337 
2338 /* return the 90kHz PCR and the extension for the 27MHz PCR. return
2339  * (-1) if not available */
2340 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, const uint8_t *packet)
2341 {
2342  int afc, len, flags;
2343  const uint8_t *p;
2344  unsigned int v;
2345 
2346  afc = (packet[3] >> 4) & 3;
2347  if (afc <= 1)
2348  return AVERROR_INVALIDDATA;
2349  p = packet + 4;
2350  len = p[0];
2351  p++;
2352  if (len == 0)
2353  return AVERROR_INVALIDDATA;
2354  flags = *p++;
2355  len--;
2356  if (!(flags & 0x10))
2357  return AVERROR_INVALIDDATA;
2358  if (len < 6)
2359  return AVERROR_INVALIDDATA;
2360  v = AV_RB32(p);
2361  *ppcr_high = ((int64_t) v << 1) | (p[4] >> 7);
2362  *ppcr_low = ((p[4] & 1) << 8) | p[5];
2363  return 0;
2364 }
2365 
2366 static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos) {
2367 
2368  /* NOTE: We attempt to seek on non-seekable files as well, as the
2369  * probe buffer usually is big enough. Only warn if the seek failed
2370  * on files where the seek should work. */
2371  if (avio_seek(pb, pos, SEEK_SET) < 0)
2372  av_log(s, pb->seekable ? AV_LOG_ERROR : AV_LOG_INFO, "Unable to seek back to the start\n");
2373 }
2374 
2376 {
2377  MpegTSContext *ts = s->priv_data;
2378  AVIOContext *pb = s->pb;
2379  uint8_t buf[8 * 1024] = {0};
2380  int len;
2381  int64_t pos, probesize = s->probesize ? s->probesize : s->probesize2;
2382 
2383  ffio_ensure_seekback(pb, probesize);
2384 
2385  /* read the first 8192 bytes to get packet size */
2386  pos = avio_tell(pb);
2387  len = avio_read(pb, buf, sizeof(buf));
2388  ts->raw_packet_size = get_packet_size(buf, len);
2389  if (ts->raw_packet_size <= 0) {
2390  av_log(s, AV_LOG_WARNING, "Could not detect TS packet size, defaulting to non-FEC/DVHS\n");
2392  }
2393  ts->stream = s;
2394  ts->auto_guess = 0;
2395 
2396  if (s->iformat == &ff_mpegts_demuxer) {
2397  /* normal demux */
2398 
2399  /* first do a scan to get all the services */
2400  seek_back(s, pb, pos);
2401 
2403 
2405 
2406  handle_packets(ts, probesize / ts->raw_packet_size);
2407  /* if could not find service, enable auto_guess */
2408 
2409  ts->auto_guess = 1;
2410 
2411  av_dlog(ts->stream, "tuning done\n");
2412 
2414  } else {
2415  AVStream *st;
2416  int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
2417  int64_t pcrs[2], pcr_h;
2418  int packet_count[2];
2419  uint8_t packet[TS_PACKET_SIZE];
2420  const uint8_t *data;
2421 
2422  /* only read packets */
2423 
2424  st = avformat_new_stream(s, NULL);
2425  if (!st)
2426  return AVERROR(ENOMEM);
2427  avpriv_set_pts_info(st, 60, 1, 27000000);
2430 
2431  /* we iterate until we find two PCRs to estimate the bitrate */
2432  pcr_pid = -1;
2433  nb_pcrs = 0;
2434  nb_packets = 0;
2435  for (;;) {
2436  ret = read_packet(s, packet, ts->raw_packet_size, &data);
2437  if (ret < 0)
2438  return ret;
2439  pid = AV_RB16(data + 1) & 0x1fff;
2440  if ((pcr_pid == -1 || pcr_pid == pid) &&
2441  parse_pcr(&pcr_h, &pcr_l, data) == 0) {
2443  pcr_pid = pid;
2444  packet_count[nb_pcrs] = nb_packets;
2445  pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
2446  nb_pcrs++;
2447  if (nb_pcrs >= 2)
2448  break;
2449  } else {
2451  }
2452  nb_packets++;
2453  }
2454 
2455  /* NOTE1: the bitrate is computed without the FEC */
2456  /* NOTE2: it is only the bitrate of the start of the stream */
2457  ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
2458  ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];
2459  s->bit_rate = TS_PACKET_SIZE * 8 * 27e6 / ts->pcr_incr;
2460  st->codec->bit_rate = s->bit_rate;
2461  st->start_time = ts->cur_pcr;
2462  av_dlog(ts->stream, "start=%0.3f pcr=%0.3f incr=%d\n",
2463  st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr);
2464  }
2465 
2466  seek_back(s, pb, pos);
2467  return 0;
2468 }
2469 
2470 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
2471 
2473 {
2474  MpegTSContext *ts = s->priv_data;
2475  int ret, i;
2476  int64_t pcr_h, next_pcr_h, pos;
2477  int pcr_l, next_pcr_l;
2478  uint8_t pcr_buf[12];
2479  const uint8_t *data;
2480 
2481  if (av_new_packet(pkt, TS_PACKET_SIZE) < 0)
2482  return AVERROR(ENOMEM);
2483  ret = read_packet(s, pkt->data, ts->raw_packet_size, &data);
2484  pkt->pos = avio_tell(s->pb);
2485  if (ret < 0) {
2486  av_free_packet(pkt);
2487  return ret;
2488  }
2489  if (data != pkt->data)
2490  memcpy(pkt->data, data, ts->raw_packet_size);
2492  if (ts->mpeg2ts_compute_pcr) {
2493  /* compute exact PCR for each packet */
2494  if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) {
2495  /* we read the next PCR (XXX: optimize it by using a bigger buffer */
2496  pos = avio_tell(s->pb);
2497  for (i = 0; i < MAX_PACKET_READAHEAD; i++) {
2498  avio_seek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET);
2499  avio_read(s->pb, pcr_buf, 12);
2500  if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
2501  /* XXX: not precise enough */
2502  ts->pcr_incr =
2503  ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
2504  (i + 1);
2505  break;
2506  }
2507  }
2508  avio_seek(s->pb, pos, SEEK_SET);
2509  /* no next PCR found: we use previous increment */
2510  ts->cur_pcr = pcr_h * 300 + pcr_l;
2511  }
2512  pkt->pts = ts->cur_pcr;
2513  pkt->duration = ts->pcr_incr;
2514  ts->cur_pcr += ts->pcr_incr;
2515  }
2516  pkt->stream_index = 0;
2517  return 0;
2518 }
2519 
2521 {
2522  MpegTSContext *ts = s->priv_data;
2523  int ret, i;
2524 
2525  pkt->size = -1;
2526  ts->pkt = pkt;
2527  ret = handle_packets(ts, 0);
2528  if (ret < 0) {
2529  av_free_packet(ts->pkt);
2530  /* flush pes data left */
2531  for (i = 0; i < NB_PID_MAX; i++)
2532  if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) {
2533  PESContext *pes = ts->pids[i]->u.pes_filter.opaque;
2534  if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) {
2535  new_pes_packet(pes, pkt);
2536  pes->state = MPEGTS_SKIP;
2537  ret = 0;
2538  break;
2539  }
2540  }
2541  }
2542 
2543  if (!ret && pkt->size < 0)
2544  ret = AVERROR(EINTR);
2545  return ret;
2546 }
2547 
2548 static void mpegts_free(MpegTSContext *ts)
2549 {
2550  int i;
2551 
2552  clear_programs(ts);
2553 
2554  for (i = 0; i < NB_PID_MAX; i++)
2555  if (ts->pids[i])
2556  mpegts_close_filter(ts, ts->pids[i]);
2557 }
2558 
2560 {
2561  MpegTSContext *ts = s->priv_data;
2562  mpegts_free(ts);
2563  return 0;
2564 }
2565 
2566 static av_unused int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index,
2567  int64_t *ppos, int64_t pos_limit)
2568 {
2569  MpegTSContext *ts = s->priv_data;
2570  int64_t pos, timestamp;
2572  int pcr_l, pcr_pid =
2573  ((PESContext *)s->streams[stream_index]->priv_data)->pcr_pid;
2574  int pos47 = ts->pos47_full % ts->raw_packet_size;
2575  pos =
2576  ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) *
2577  ts->raw_packet_size + pos47;
2578  while(pos < pos_limit) {
2579  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
2580  return AV_NOPTS_VALUE;
2581  if (avio_read(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE)
2582  return AV_NOPTS_VALUE;
2583  if (buf[0] != 0x47) {
2584  avio_seek(s->pb, -TS_PACKET_SIZE, SEEK_CUR);
2585  if (mpegts_resync(s) < 0)
2586  return AV_NOPTS_VALUE;
2587  pos = avio_tell(s->pb);
2588  continue;
2589  }
2590  if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
2591  parse_pcr(&timestamp, &pcr_l, buf) == 0) {
2592  *ppos = pos;
2593  return timestamp;
2594  }
2595  pos += ts->raw_packet_size;
2596  }
2597 
2598  return AV_NOPTS_VALUE;
2599 }
2600 
2601 static int64_t mpegts_get_dts(AVFormatContext *s, int stream_index,
2602  int64_t *ppos, int64_t pos_limit)
2603 {
2604  MpegTSContext *ts = s->priv_data;
2605  int64_t pos;
2606  int pos47 = ts->pos47_full % ts->raw_packet_size;
2607  pos = ((*ppos + ts->raw_packet_size - 1 - pos47) / ts->raw_packet_size) * ts->raw_packet_size + pos47;
2609  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
2610  return AV_NOPTS_VALUE;
2611  while(pos < pos_limit) {
2612  int ret;
2613  AVPacket pkt;
2614  av_init_packet(&pkt);
2615  ret = av_read_frame(s, &pkt);
2616  if (ret < 0)
2617  return AV_NOPTS_VALUE;
2618  av_free_packet(&pkt);
2619  if (pkt.dts != AV_NOPTS_VALUE && pkt.pos >= 0) {
2620  ff_reduce_index(s, pkt.stream_index);
2621  av_add_index_entry(s->streams[pkt.stream_index], pkt.pos, pkt.dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
2622  if (pkt.stream_index == stream_index && pkt.pos >= *ppos) {
2623  *ppos = pkt.pos;
2624  return pkt.dts;
2625  }
2626  }
2627  pos = pkt.pos;
2628  }
2629 
2630  return AV_NOPTS_VALUE;
2631 }
2632 
2633 /**************************************************************/
2634 /* parsing functions - called from other demuxers such as RTP */
2635 
2637 {
2638  MpegTSContext *ts;
2639 
2640  ts = av_mallocz(sizeof(MpegTSContext));
2641  if (!ts)
2642  return NULL;
2643  /* no stream case, currently used by RTP */
2645  ts->stream = s;
2646  ts->auto_guess = 1;
2649 
2650  return ts;
2651 }
2652 
2653 /* return the consumed length if a packet was output, or -1 if no
2654  * packet is output */
2656  const uint8_t *buf, int len)
2657 {
2658  int len1;
2659 
2660  len1 = len;
2661  ts->pkt = pkt;
2662  for (;;) {
2663  ts->stop_parse = 0;
2664  if (len < TS_PACKET_SIZE)
2665  return AVERROR_INVALIDDATA;
2666  if (buf[0] != 0x47) {
2667  buf++;
2668  len--;
2669  } else {
2670  handle_packet(ts, buf);
2671  buf += TS_PACKET_SIZE;
2672  len -= TS_PACKET_SIZE;
2673  if (ts->stop_parse == 1)
2674  break;
2675  }
2676  }
2677  return len1 - len;
2678 }
2679 
2681 {
2682  mpegts_free(ts);
2683  av_free(ts);
2684 }
2685 
2686 AVInputFormat ff_mpegts_demuxer = {
2687  .name = "mpegts",
2688  .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
2689  .priv_data_size = sizeof(MpegTSContext),
2694  .read_timestamp = mpegts_get_dts,
2696  .priv_class = &mpegts_class,
2697 };
2698 
2700  .name = "mpegtsraw",
2701  .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-TS (MPEG-2 Transport Stream)"),
2702  .priv_data_size = sizeof(MpegTSContext),
2706  .read_timestamp = mpegts_get_dts,
2708  .priv_class = &mpegtsraw_class,
2709 };