FFmpeg
mpegtsenc.c
Go to the documentation of this file.
1 /*
2  * MPEG-2 transport stream (aka DVB) muxer
3  * Copyright (c) 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/avassert.h"
23 #include "libavutil/bswap.h"
24 #include "libavutil/crc.h"
25 #include "libavutil/dict.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavutil/mathematics.h"
28 #include "libavutil/opt.h"
29 
31 #include "libavcodec/internal.h"
32 
33 #include "avformat.h"
34 #include "avio_internal.h"
35 #include "internal.h"
36 #include "mpegts.h"
37 
38 #define PCR_TIME_BASE 27000000
39 
40 /* write DVB SI sections */
41 
42 #define DVB_PRIVATE_NETWORK_START 0xff01
43 
44 /*********************************************/
45 /* mpegts section writer */
46 
47 typedef struct MpegTSSection {
48  int pid;
49  int cc;
51  void (*write_packet)(struct MpegTSSection *s, const uint8_t *packet);
52  void *opaque;
54 
55 typedef struct MpegTSService {
56  MpegTSSection pmt; /* MPEG-2 PMT table context */
57  int sid; /* service ID */
58  uint8_t name[256];
59  uint8_t provider_name[256];
60  int pcr_pid;
63 
64 // service_type values as defined in ETSI 300 468
65 enum {
74 };
75 typedef struct MpegTSWrite {
76  const AVClass *av_class;
77  MpegTSSection pat; /* MPEG-2 PAT table */
78  MpegTSSection sdt; /* MPEG-2 SDT table context */
80  int64_t sdt_period; /* SDT period in PCR time base */
81  int64_t pat_period; /* PAT/PMT period in PCR time base */
83  int64_t first_pcr;
85  int64_t next_pcr;
86  int mux_rate; ///< set to 1 when VBR
88  int64_t total_size;
89 
94 
96  int start_pid;
97  int m2ts_mode;
102 
104 #define MPEGTS_FLAG_REEMIT_PAT_PMT 0x01
105 #define MPEGTS_FLAG_AAC_LATM 0x02
106 #define MPEGTS_FLAG_PAT_PMT_AT_FRAMES 0x04
107 #define MPEGTS_FLAG_SYSTEM_B 0x08
108 #define MPEGTS_FLAG_DISCONT 0x10
109  int flags;
110  int copyts;
112  int64_t pat_period_us;
113  int64_t sdt_period_us;
114  int64_t last_pat_ts;
115  int64_t last_sdt_ts;
116 
118 } MpegTSWrite;
119 
120 /* a PES packet header is generated every DEFAULT_PES_HEADER_FREQ packets */
121 #define DEFAULT_PES_HEADER_FREQ 16
122 #define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170)
123 
124 /* The section length is 12 bits. The first 2 are set to 0, the remaining
125  * 10 bits should not exceed 1021. */
126 #define SECTION_LENGTH 1020
127 
128 /* NOTE: 4 bytes must be left at the end for the crc32 */
130 {
131  unsigned int crc;
132  unsigned char packet[TS_PACKET_SIZE];
133  const unsigned char *buf_ptr;
134  unsigned char *q;
135  int first, b, len1, left;
136 
138  -1, buf, len - 4));
139 
140  buf[len - 4] = (crc >> 24) & 0xff;
141  buf[len - 3] = (crc >> 16) & 0xff;
142  buf[len - 2] = (crc >> 8) & 0xff;
143  buf[len - 1] = crc & 0xff;
144 
145  /* send each packet */
146  buf_ptr = buf;
147  while (len > 0) {
148  first = buf == buf_ptr;
149  q = packet;
150  *q++ = 0x47;
151  b = s->pid >> 8;
152  if (first)
153  b |= 0x40;
154  *q++ = b;
155  *q++ = s->pid;
156  s->cc = s->cc + 1 & 0xf;
157  *q++ = 0x10 | s->cc;
158  if (s->discontinuity) {
159  q[-1] |= 0x20;
160  *q++ = 1;
161  *q++ = 0x80;
162  s->discontinuity = 0;
163  }
164  if (first)
165  *q++ = 0; /* 0 offset */
166  len1 = TS_PACKET_SIZE - (q - packet);
167  if (len1 > len)
168  len1 = len;
169  memcpy(q, buf_ptr, len1);
170  q += len1;
171  /* add known padding data */
172  left = TS_PACKET_SIZE - (q - packet);
173  if (left > 0)
174  memset(q, 0xff, left);
175 
176  s->write_packet(s, packet);
177 
178  buf_ptr += len1;
179  len -= len1;
180  }
181 }
182 
183 static inline void put16(uint8_t **q_ptr, int val)
184 {
185  uint8_t *q;
186  q = *q_ptr;
187  *q++ = val >> 8;
188  *q++ = val;
189  *q_ptr = q;
190 }
191 
192 static int mpegts_write_section1(MpegTSSection *s, int tid, int id,
193  int version, int sec_num, int last_sec_num,
194  uint8_t *buf, int len)
195 {
196  uint8_t section[1024], *q;
197  unsigned int tot_len;
198  /* reserved_future_use field must be set to 1 for SDT */
199  unsigned int flags = tid == SDT_TID ? 0xf000 : 0xb000;
200 
201  tot_len = 3 + 5 + len + 4;
202  /* check if not too big */
203  if (tot_len > 1024)
204  return AVERROR_INVALIDDATA;
205 
206  q = section;
207  *q++ = tid;
208  put16(&q, flags | (len + 5 + 4)); /* 5 byte header + 4 byte CRC */
209  put16(&q, id);
210  *q++ = 0xc1 | (version << 1); /* current_next_indicator = 1 */
211  *q++ = sec_num;
212  *q++ = last_sec_num;
213  memcpy(q, buf, len);
214 
215  mpegts_write_section(s, section, tot_len);
216  return 0;
217 }
218 
219 /*********************************************/
220 /* mpegts writer */
221 
222 #define DEFAULT_PROVIDER_NAME "FFmpeg"
223 #define DEFAULT_SERVICE_NAME "Service"
224 
225 /* we retransmit the SI info at this rate */
226 #define SDT_RETRANS_TIME 500
227 #define PAT_RETRANS_TIME 100
228 #define PCR_RETRANS_TIME 20
229 
230 typedef struct MpegTSWriteStream {
231  int pid; /* stream associated pid */
232  int cc;
235  int first_timestamp_checked; ///< first pts/dts check needed
237  int64_t payload_pts;
238  int64_t payload_dts;
243 
244  int64_t pcr_period; /* PCR period in PCR time base */
245  int64_t last_pcr;
246 
247  /* For Opus */
250 
253 
255 {
256  MpegTSWrite *ts = s->priv_data;
257  MpegTSService *service;
259  int i;
260 
261  q = data;
262  for (i = 0; i < ts->nb_services; i++) {
263  service = ts->services[i];
264  put16(&q, service->sid);
265  put16(&q, 0xe000 | service->pmt.pid);
266  }
268  data, q - data);
269 }
270 
271 static void putbuf(uint8_t **q_ptr, const uint8_t *buf, size_t len)
272 {
273  memcpy(*q_ptr, buf, len);
274  *q_ptr += len;
275 }
276 
277 static void put_registration_descriptor(uint8_t **q_ptr, uint32_t tag)
278 {
279  uint8_t *q = *q_ptr;
281  *q++ = 4;
282  *q++ = tag;
283  *q++ = tag >> 8;
284  *q++ = tag >> 16;
285  *q++ = tag >> 24;
286  *q_ptr = q;
287 }
288 
290 {
291  MpegTSWrite *ts = s->priv_data;
292  MpegTSWriteStream *ts_st = st->priv_data;
293  int stream_type;
294 
295  switch (st->codecpar->codec_id) {
298  stream_type = STREAM_TYPE_VIDEO_MPEG2;
299  break;
300  case AV_CODEC_ID_MPEG4:
301  stream_type = STREAM_TYPE_VIDEO_MPEG4;
302  break;
303  case AV_CODEC_ID_H264:
304  stream_type = STREAM_TYPE_VIDEO_H264;
305  break;
306  case AV_CODEC_ID_HEVC:
307  stream_type = STREAM_TYPE_VIDEO_HEVC;
308  break;
309  case AV_CODEC_ID_CAVS:
310  stream_type = STREAM_TYPE_VIDEO_CAVS;
311  break;
312  case AV_CODEC_ID_DIRAC:
313  stream_type = STREAM_TYPE_VIDEO_DIRAC;
314  break;
315  case AV_CODEC_ID_VC1:
316  stream_type = STREAM_TYPE_VIDEO_VC1;
317  break;
318  case AV_CODEC_ID_MP2:
319  case AV_CODEC_ID_MP3:
320  if ( st->codecpar->sample_rate > 0
321  && st->codecpar->sample_rate < 32000) {
322  stream_type = STREAM_TYPE_AUDIO_MPEG2;
323  } else {
324  stream_type = STREAM_TYPE_AUDIO_MPEG1;
325  }
326  break;
327  case AV_CODEC_ID_AAC:
328  stream_type = (ts->flags & MPEGTS_FLAG_AAC_LATM)
331  break;
333  stream_type = STREAM_TYPE_AUDIO_AAC_LATM;
334  break;
335  case AV_CODEC_ID_AC3:
336  stream_type = (ts->flags & MPEGTS_FLAG_SYSTEM_B)
339  break;
340  case AV_CODEC_ID_EAC3:
341  stream_type = (ts->flags & MPEGTS_FLAG_SYSTEM_B)
344  break;
345  case AV_CODEC_ID_DTS:
346  stream_type = STREAM_TYPE_AUDIO_DTS;
347  break;
348  case AV_CODEC_ID_TRUEHD:
349  stream_type = STREAM_TYPE_AUDIO_TRUEHD;
350  break;
351  case AV_CODEC_ID_OPUS:
352  stream_type = STREAM_TYPE_PRIVATE_DATA;
353  break;
355  stream_type = STREAM_TYPE_METADATA;
356  break;
359  stream_type = STREAM_TYPE_PRIVATE_DATA;
360  break;
362  if (st->codecpar->profile == FF_PROFILE_KLVA_SYNC) {
363  stream_type = STREAM_TYPE_METADATA;
364  } else {
365  stream_type = STREAM_TYPE_PRIVATE_DATA;
366  }
367  break;
368  default:
370  "Stream %d, codec %s, is muxed as a private data stream "
371  "and may not be recognized upon reading.\n", st->index,
373  stream_type = STREAM_TYPE_PRIVATE_DATA;
374  break;
375  }
376 
377  return stream_type;
378 }
379 
381 {
382  int stream_type;
383  MpegTSWriteStream *ts_st = st->priv_data;
384 
385  switch (st->codecpar->codec_id) {
387  stream_type = STREAM_TYPE_VIDEO_MPEG2;
388  break;
389  case AV_CODEC_ID_H264:
390  stream_type = STREAM_TYPE_VIDEO_H264;
391  break;
392  case AV_CODEC_ID_VC1:
393  stream_type = STREAM_TYPE_VIDEO_VC1;
394  break;
395  case AV_CODEC_ID_HEVC:
396  stream_type = STREAM_TYPE_VIDEO_HEVC;
397  break;
399  stream_type = 0x80;
400  break;
401  case AV_CODEC_ID_AC3:
402  stream_type = 0x81;
403  break;
404  case AV_CODEC_ID_DTS:
405  stream_type = (st->codecpar->channels > 6) ? 0x85 : 0x82;
406  break;
407  case AV_CODEC_ID_TRUEHD:
408  stream_type = 0x83;
409  break;
410  case AV_CODEC_ID_EAC3:
411  stream_type = 0x84;
412  break;
414  stream_type = 0x90;
415  break;
417  stream_type = 0x92;
418  break;
419  default:
421  "Stream %d, codec %s, is muxed as a private data stream "
422  "and may not be recognized upon reading.\n", st->index,
424  stream_type = STREAM_TYPE_PRIVATE_DATA;
425  break;
426  }
427 
428  return stream_type;
429 }
430 
432 {
433  MpegTSWrite *ts = s->priv_data;
434  uint8_t data[SECTION_LENGTH], *q, *desc_length_ptr, *program_info_length_ptr;
435  int val, stream_type, i, err = 0;
436 
437  q = data;
438  put16(&q, 0xe000 | service->pcr_pid);
439 
440  program_info_length_ptr = q;
441  q += 2; /* patched after */
442 
443  /* put program info here */
444  if (ts->m2ts_mode) {
445  put_registration_descriptor(&q, MKTAG('H', 'D', 'M', 'V'));
446  *q++ = 0x88; // descriptor_tag - hdmv_copy_control_descriptor
447  *q++ = 0x04; // descriptor_length
448  put16(&q, 0x0fff); // CA_System_ID
449  *q++ = 0xfc; // private_data_byte
450  *q++ = 0xfc; // private_data_byte
451  }
452 
453  val = 0xf000 | (q - program_info_length_ptr - 2);
454  program_info_length_ptr[0] = val >> 8;
455  program_info_length_ptr[1] = val;
456 
457  for (i = 0; i < s->nb_streams; i++) {
458  AVStream *st = s->streams[i];
459  MpegTSWriteStream *ts_st = st->priv_data;
460  AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
461  enum AVCodecID codec_id = st->codecpar->codec_id;
462 
463  if (s->nb_programs) {
464  int k, found = 0;
465  AVProgram *program = service->program;
466 
467  for (k = 0; k < program->nb_stream_indexes; k++)
468  if (program->stream_index[k] == i) {
469  found = 1;
470  break;
471  }
472 
473  if (!found)
474  continue;
475  }
476 
477  if (q - data > SECTION_LENGTH - 32) {
478  err = 1;
479  break;
480  }
481 
482  stream_type = ts->m2ts_mode ? get_m2ts_stream_type(s, st) : get_dvb_stream_type(s, st);
483 
484  *q++ = stream_type;
485  put16(&q, 0xe000 | ts_st->pid);
486  desc_length_ptr = q;
487  q += 2; /* patched after */
488 
489  /* write optional descriptors here */
490  switch (st->codecpar->codec_type) {
491  case AVMEDIA_TYPE_AUDIO:
492  if (codec_id == AV_CODEC_ID_AC3)
493  put_registration_descriptor(&q, MKTAG('A', 'C', '-', '3'));
494  if (codec_id == AV_CODEC_ID_EAC3)
495  put_registration_descriptor(&q, MKTAG('E', 'A', 'C', '3'));
496  if (ts->flags & MPEGTS_FLAG_SYSTEM_B) {
497  if (codec_id == AV_CODEC_ID_AC3) {
498  DVBAC3Descriptor *dvb_ac3_desc = ts_st->dvb_ac3_desc;
499 
500  *q++=0x6a; // AC3 descriptor see A038 DVB SI
501  if (dvb_ac3_desc) {
502  int len = 1 +
503  !!(dvb_ac3_desc->component_type_flag) +
504  !!(dvb_ac3_desc->bsid_flag) +
505  !!(dvb_ac3_desc->mainid_flag) +
506  !!(dvb_ac3_desc->asvc_flag);
507 
508  *q++ = len;
509  *q++ = dvb_ac3_desc->component_type_flag << 7 | dvb_ac3_desc->bsid_flag << 6 |
510  dvb_ac3_desc->mainid_flag << 5 | dvb_ac3_desc->asvc_flag << 4;
511 
512  if (dvb_ac3_desc->component_type_flag) *q++ = dvb_ac3_desc->component_type;
513  if (dvb_ac3_desc->bsid_flag) *q++ = dvb_ac3_desc->bsid;
514  if (dvb_ac3_desc->mainid_flag) *q++ = dvb_ac3_desc->mainid;
515  if (dvb_ac3_desc->asvc_flag) *q++ = dvb_ac3_desc->asvc;
516  } else {
517  *q++=1; // 1 byte, all flags sets to 0
518  *q++=0; // omit all fields...
519  }
520  } else if (codec_id == AV_CODEC_ID_EAC3) {
521  *q++=0x7a; // EAC3 descriptor see A038 DVB SI
522  *q++=1; // 1 byte, all flags sets to 0
523  *q++=0; // omit all fields...
524  }
525  }
526  if (codec_id == AV_CODEC_ID_S302M)
527  put_registration_descriptor(&q, MKTAG('B', 'S', 'S', 'D'));
528  if (codec_id == AV_CODEC_ID_OPUS) {
529  /* 6 bytes registration descriptor, 4 bytes Opus audio descriptor */
530  if (q - data > SECTION_LENGTH - 6 - 4) {
531  err = 1;
532  break;
533  }
534 
535  put_registration_descriptor(&q, MKTAG('O', 'p', 'u', 's'));
536 
537  *q++ = 0x7f; /* DVB extension descriptor */
538  *q++ = 2;
539  *q++ = 0x80;
540 
541  if (st->codecpar->extradata && st->codecpar->extradata_size >= 19) {
542  if (st->codecpar->extradata[18] == 0 && st->codecpar->channels <= 2) {
543  /* RTP mapping family */
544  *q++ = st->codecpar->channels;
545  } else if (st->codecpar->extradata[18] == 1 && st->codecpar->channels <= 8 &&
546  st->codecpar->extradata_size >= 21 + st->codecpar->channels) {
547  static const uint8_t coupled_stream_counts[9] = {
548  1, 0, 1, 1, 2, 2, 2, 3, 3
549  };
550  static const uint8_t channel_map_a[8][8] = {
551  {0},
552  {0, 1},
553  {0, 2, 1},
554  {0, 1, 2, 3},
555  {0, 4, 1, 2, 3},
556  {0, 4, 1, 2, 3, 5},
557  {0, 4, 1, 2, 3, 5, 6},
558  {0, 6, 1, 2, 3, 4, 5, 7},
559  };
560  static const uint8_t channel_map_b[8][8] = {
561  {0},
562  {0, 1},
563  {0, 1, 2},
564  {0, 1, 2, 3},
565  {0, 1, 2, 3, 4},
566  {0, 1, 2, 3, 4, 5},
567  {0, 1, 2, 3, 4, 5, 6},
568  {0, 1, 2, 3, 4, 5, 6, 7},
569  };
570  /* Vorbis mapping family */
571 
572  if (st->codecpar->extradata[19] == st->codecpar->channels - coupled_stream_counts[st->codecpar->channels] &&
573  st->codecpar->extradata[20] == coupled_stream_counts[st->codecpar->channels] &&
574  memcmp(&st->codecpar->extradata[21], channel_map_a[st->codecpar->channels-1], st->codecpar->channels) == 0) {
575  *q++ = st->codecpar->channels;
576  } else if (st->codecpar->channels >= 2 && st->codecpar->extradata[19] == st->codecpar->channels &&
577  st->codecpar->extradata[20] == 0 &&
578  memcmp(&st->codecpar->extradata[21], channel_map_b[st->codecpar->channels-1], st->codecpar->channels) == 0) {
579  *q++ = st->codecpar->channels | 0x80;
580  } else {
581  /* Unsupported, could write an extended descriptor here */
582  av_log(s, AV_LOG_ERROR, "Unsupported Opus Vorbis-style channel mapping");
583  *q++ = 0xff;
584  }
585  } else {
586  /* Unsupported */
587  av_log(s, AV_LOG_ERROR, "Unsupported Opus channel mapping for family %d", st->codecpar->extradata[18]);
588  *q++ = 0xff;
589  }
590  } else if (st->codecpar->channels <= 2) {
591  /* Assume RTP mapping family */
592  *q++ = st->codecpar->channels;
593  } else {
594  /* Unsupported */
595  av_log(s, AV_LOG_ERROR, "Unsupported Opus channel mapping");
596  *q++ = 0xff;
597  }
598  }
599 
600  if (lang) {
601  char *p;
602  char *next = lang->value;
603  uint8_t *len_ptr;
604 
606  len_ptr = q++;
607  *len_ptr = 0;
608 
609  for (p = lang->value; next && *len_ptr < 255 / 4 * 4; p = next + 1) {
610  if (q - data > SECTION_LENGTH - 4) {
611  err = 1;
612  break;
613  }
614  next = strchr(p, ',');
615  if (strlen(p) != 3 && (!next || next != p + 3))
616  continue; /* not a 3-letter code */
617 
618  *q++ = *p++;
619  *q++ = *p++;
620  *q++ = *p++;
621 
623  *q++ = 0x01;
625  *q++ = 0x02;
627  *q++ = 0x03;
628  else
629  *q++ = 0; /* undefined type */
630 
631  *len_ptr += 4;
632  }
633 
634  if (*len_ptr == 0)
635  q -= 2; /* no language codes were written */
636  }
637  break;
639  {
640  const char default_language[] = "und";
641  const char *language = lang && strlen(lang->value) >= 3 ? lang->value : default_language;
642 
643  if (codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
644  uint8_t *len_ptr;
645  int extradata_copied = 0;
646 
647  *q++ = 0x59; /* subtitling_descriptor */
648  len_ptr = q++;
649 
650  while (strlen(language) >= 3) {
651  if (sizeof(data) - (q - data) < 8) { /* 8 bytes per DVB subtitle substream data */
652  err = 1;
653  break;
654  }
655  *q++ = *language++;
656  *q++ = *language++;
657  *q++ = *language++;
658  /* Skip comma */
659  if (*language != '\0')
660  language++;
661 
662  if (st->codecpar->extradata_size - extradata_copied >= 5) {
663  *q++ = st->codecpar->extradata[extradata_copied + 4]; /* subtitling_type */
664  memcpy(q, st->codecpar->extradata + extradata_copied, 4); /* composition_page_id and ancillary_page_id */
665  extradata_copied += 5;
666  q += 4;
667  } else {
668  /* subtitling_type:
669  * 0x10 - normal with no monitor aspect ratio criticality
670  * 0x20 - for the hard of hearing with no monitor aspect ratio criticality */
671  *q++ = (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED) ? 0x20 : 0x10;
672  if ((st->codecpar->extradata_size == 4) && (extradata_copied == 0)) {
673  /* support of old 4-byte extradata format */
674  memcpy(q, st->codecpar->extradata, 4); /* composition_page_id and ancillary_page_id */
675  extradata_copied += 4;
676  q += 4;
677  } else {
678  put16(&q, 1); /* composition_page_id */
679  put16(&q, 1); /* ancillary_page_id */
680  }
681  }
682  }
683 
684  *len_ptr = q - len_ptr - 1;
685  } else if (codec_id == AV_CODEC_ID_DVB_TELETEXT) {
686  uint8_t *len_ptr = NULL;
687  int extradata_copied = 0;
688 
689  /* The descriptor tag. teletext_descriptor */
690  *q++ = 0x56;
691  len_ptr = q++;
692 
693  while (strlen(language) >= 3 && q - data < sizeof(data) - 6) {
694  *q++ = *language++;
695  *q++ = *language++;
696  *q++ = *language++;
697  /* Skip comma */
698  if (*language != '\0')
699  language++;
700 
701  if (st->codecpar->extradata_size - 1 > extradata_copied) {
702  memcpy(q, st->codecpar->extradata + extradata_copied, 2);
703  extradata_copied += 2;
704  q += 2;
705  } else {
706  /* The Teletext descriptor:
707  * teletext_type: This 5-bit field indicates the type of Teletext page indicated. (0x01 Initial Teletext page)
708  * teletext_magazine_number: This is a 3-bit field which identifies the magazine number.
709  * teletext_page_number: This is an 8-bit field giving two 4-bit hex digits identifying the page number. */
710  *q++ = 0x08;
711  *q++ = 0x00;
712  }
713  }
714 
715  *len_ptr = q - len_ptr - 1;
716  }
717  }
718  break;
719  case AVMEDIA_TYPE_VIDEO:
720  if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
721  put_registration_descriptor(&q, MKTAG('d', 'r', 'a', 'c'));
722  } else if (stream_type == STREAM_TYPE_VIDEO_VC1) {
723  put_registration_descriptor(&q, MKTAG('V', 'C', '-', '1'));
724  } else if (stream_type == STREAM_TYPE_VIDEO_HEVC && s->strict_std_compliance <= FF_COMPLIANCE_NORMAL) {
725  put_registration_descriptor(&q, MKTAG('H', 'E', 'V', 'C'));
726  }
727  break;
728  case AVMEDIA_TYPE_DATA:
729  if (codec_id == AV_CODEC_ID_SMPTE_KLV) {
730  put_registration_descriptor(&q, MKTAG('K', 'L', 'V', 'A'));
731  } else if (codec_id == AV_CODEC_ID_TIMED_ID3) {
732  const char *tag = "ID3 ";
733  *q++ = METADATA_DESCRIPTOR;
734  *q++ = 13;
735  put16(&q, 0xffff); /* metadata application format */
736  putbuf(&q, tag, strlen(tag));
737  *q++ = 0xff; /* metadata format */
738  putbuf(&q, tag, strlen(tag));
739  *q++ = 0; /* metadata service ID */
740  *q++ = 0xF; /* metadata_locator_record_flag|MPEG_carriage_flags|reserved */
741  }
742  break;
743  }
744 
745  val = 0xf000 | (q - desc_length_ptr - 2);
746  desc_length_ptr[0] = val >> 8;
747  desc_length_ptr[1] = val;
748  }
749 
750  if (err)
751  av_log(s, AV_LOG_ERROR,
752  "The PMT section cannot fit stream %d and all following streams.\n"
753  "Try reducing the number of languages in the audio streams "
754  "or the total number of streams.\n", i);
755 
756  mpegts_write_section1(&service->pmt, PMT_TID, service->sid, ts->tables_version, 0, 0,
757  data, q - data);
758  return 0;
759 }
760 
762 {
763  MpegTSWrite *ts = s->priv_data;
764  MpegTSService *service;
765  uint8_t data[SECTION_LENGTH], *q, *desc_list_len_ptr, *desc_len_ptr;
766  int i, running_status, free_ca_mode, val;
767 
768  q = data;
769  put16(&q, ts->original_network_id);
770  *q++ = 0xff;
771  for (i = 0; i < ts->nb_services; i++) {
772  service = ts->services[i];
773  put16(&q, service->sid);
774  *q++ = 0xfc | 0x00; /* currently no EIT info */
775  desc_list_len_ptr = q;
776  q += 2;
777  running_status = 4; /* running */
778  free_ca_mode = 0;
779 
780  /* write only one descriptor for the service name and provider */
781  *q++ = 0x48;
782  desc_len_ptr = q;
783  q++;
784  *q++ = ts->service_type;
785  putbuf(&q, service->provider_name, service->provider_name[0] + 1);
786  putbuf(&q, service->name, service->name[0] + 1);
787  desc_len_ptr[0] = q - desc_len_ptr - 1;
788 
789  /* fill descriptor length */
790  val = (running_status << 13) | (free_ca_mode << 12) |
791  (q - desc_list_len_ptr - 2);
792  desc_list_len_ptr[0] = val >> 8;
793  desc_list_len_ptr[1] = val;
794  }
796  data, q - data);
797 }
798 
799 /* This stores a string in buf with the correct encoding and also sets the
800  * first byte as the length. !str is accepted for an empty string.
801  * If the string is already encoded, invalid UTF-8 or has no multibyte sequence
802  * then we keep it as is, otherwise we signal UTF-8 encoding. */
803 static int encode_str8(uint8_t *buf, const char *str)
804 {
805  size_t str_len;
806  if (!str)
807  str = "";
808  str_len = strlen(str);
809  if (str[0] && (unsigned)str[0] >= 0x20) { /* Make sure the string is not already encoded. */
810  const uint8_t *q = str;
811  int has_multibyte = 0;
812  while (*q) {
813  uint32_t code;
814  GET_UTF8(code, *q++, goto invalid;) /* Is it valid UTF-8? */
815  has_multibyte |= (code > 127); /* Does it have multibyte UTF-8 chars in it? */
816  }
817  if (has_multibyte) { /* If we have multibyte chars and valid UTF-8, then encode as such! */
818  if (str_len > 254)
819  return AVERROR(EINVAL);
820  buf[0] = str_len + 1;
821  buf[1] = 0x15;
822  memcpy(&buf[2], str, str_len);
823  return 0;
824  }
825  }
826 invalid:
827  /* Otherwise let's just encode the string as is! */
828  if (str_len > 255)
829  return AVERROR(EINVAL);
830  buf[0] = str_len;
831  memcpy(&buf[1], str, str_len);
832  return 0;
833 }
834 
835 static int64_t get_pcr(const MpegTSWrite *ts)
836 {
837  return av_rescale(ts->total_size + 11, 8 * PCR_TIME_BASE, ts->mux_rate) +
838  ts->first_pcr;
839 }
840 
841 static void write_packet(AVFormatContext *s, const uint8_t *packet)
842 {
843  MpegTSWrite *ts = s->priv_data;
844  if (ts->m2ts_mode) {
845  int64_t pcr = get_pcr(s->priv_data);
846  uint32_t tp_extra_header = pcr % 0x3fffffff;
847  tp_extra_header = AV_RB32(&tp_extra_header);
848  avio_write(s->pb, (unsigned char *) &tp_extra_header,
849  sizeof(tp_extra_header));
850  }
851  avio_write(s->pb, packet, TS_PACKET_SIZE);
852  ts->total_size += TS_PACKET_SIZE;
853 }
854 
855 static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
856 {
857  AVFormatContext *ctx = s->opaque;
858  write_packet(ctx, packet);
859 }
860 
862  const AVDictionary *metadata,
864 {
865  MpegTSWrite *ts = s->priv_data;
866  MpegTSService *service;
867  AVDictionaryEntry *title, *provider;
868  char default_service_name[32];
869  const char *service_name;
870  const char *provider_name;
871 
872  title = av_dict_get(metadata, "service_name", NULL, 0);
873  if (!title)
874  title = av_dict_get(metadata, "title", NULL, 0);
875  snprintf(default_service_name, sizeof(default_service_name), "%s%02d", DEFAULT_SERVICE_NAME, ts->nb_services + 1);
876  service_name = title ? title->value : default_service_name;
877  provider = av_dict_get(metadata, "service_provider", NULL, 0);
878  provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME;
879 
880  service = av_mallocz(sizeof(MpegTSService));
881  if (!service)
882  return NULL;
883  service->pmt.pid = ts->pmt_start_pid + ts->nb_services;
884  service->sid = sid;
885  service->pcr_pid = 0x1fff;
886  if (encode_str8(service->provider_name, provider_name) < 0 ||
887  encode_str8(service->name, service_name) < 0) {
888  av_log(s, AV_LOG_ERROR, "Too long service or provider name\n");
889  goto fail;
890  }
891  if (av_dynarray_add_nofree(&ts->services, &ts->nb_services, service) < 0)
892  goto fail;
893 
895  service->pmt.opaque = s;
896  service->pmt.cc = 15;
897  service->pmt.discontinuity= ts->flags & MPEGTS_FLAG_DISCONT;
898  service->program = program;
899 
900  return service;
901 fail:
902  av_free(service);
903  return NULL;
904 }
905 
907 {
908  MpegTSWrite *ts = s->priv_data;
909  MpegTSWriteStream *ts_st = pcr_st->priv_data;
910 
911  if (ts->mux_rate > 1 || ts->pcr_period_ms >= 0) {
912  int pcr_period_ms = ts->pcr_period_ms == -1 ? PCR_RETRANS_TIME : ts->pcr_period_ms;
913  ts_st->pcr_period = av_rescale(pcr_period_ms, PCR_TIME_BASE, 1000);
914  } else {
915  /* By default, for VBR we select the highest multiple of frame duration which is less than 100 ms. */
916  int64_t frame_period = 0;
917  if (pcr_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
919  if (!frame_size) {
920  av_log(s, AV_LOG_WARNING, "frame size not set\n");
921  frame_size = 512;
922  }
923  frame_period = av_rescale_rnd(frame_size, PCR_TIME_BASE, pcr_st->codecpar->sample_rate, AV_ROUND_UP);
924  } else if (pcr_st->avg_frame_rate.num) {
925  frame_period = av_rescale_rnd(pcr_st->avg_frame_rate.den, PCR_TIME_BASE, pcr_st->avg_frame_rate.num, AV_ROUND_UP);
926  }
927  if (frame_period > 0 && frame_period <= PCR_TIME_BASE / 10)
928  ts_st->pcr_period = frame_period * (PCR_TIME_BASE / 10 / frame_period);
929  else
930  ts_st->pcr_period = 1;
931  }
932 
933  // output a PCR as soon as possible
934  ts_st->last_pcr = ts->first_pcr - ts_st->pcr_period;
935 }
936 
938 {
939  MpegTSWrite *ts = s->priv_data;
940 
941  for (int i = 0; i < ts->nb_services; i++) {
942  MpegTSService *service = ts->services[i];
943  AVStream *pcr_st = NULL;
944  AVProgram *program = service->program;
945  int nb_streams = program ? program->nb_stream_indexes : s->nb_streams;
946 
947  for (int j = 0; j < nb_streams; j++) {
948  AVStream *st = s->streams[program ? program->stream_index[j] : j];
949  if (!pcr_st ||
951  {
952  pcr_st = st;
953  }
954  }
955 
956  if (pcr_st) {
957  MpegTSWriteStream *ts_st = pcr_st->priv_data;
958  service->pcr_pid = ts_st->pid;
960  av_log(s, AV_LOG_VERBOSE, "service %i using PCR in pid=%i, pcr_period=%"PRId64"ms\n",
961  service->sid, service->pcr_pid, av_rescale(ts_st->pcr_period, 1000, PCR_TIME_BASE));
962  }
963  }
964 }
965 
967 {
968  MpegTSWrite *ts = s->priv_data;
969  int i, j;
970  int ret;
971 
972  if (ts->m2ts_mode == -1) {
973  if (av_match_ext(s->url, "m2ts")) {
974  ts->m2ts_mode = 1;
975  } else {
976  ts->m2ts_mode = 0;
977  }
978  }
979 
984 
985  if (ts->m2ts_mode) {
987  if (s->nb_programs > 1) {
988  av_log(s, AV_LOG_ERROR, "Only one program is allowed in m2ts mode!\n");
989  return AVERROR(EINVAL);
990  }
991  }
992 
993  if (s->max_delay < 0) /* Not set by the caller */
994  s->max_delay = 0;
995 
996  // round up to a whole number of TS packets
997  ts->pes_payload_size = (ts->pes_payload_size + 14 + 183) / 184 * 184 - 14;
998 
999  if (!s->nb_programs) {
1000  /* allocate a single DVB service */
1001  if (!mpegts_add_service(s, ts->service_id, s->metadata, NULL))
1002  return AVERROR(ENOMEM);
1003  } else {
1004  for (i = 0; i < s->nb_programs; i++) {
1005  AVProgram *program = s->programs[i];
1006  if (!mpegts_add_service(s, program->id, program->metadata, program))
1007  return AVERROR(ENOMEM);
1008  }
1009  }
1010 
1011  ts->pat.pid = PAT_PID;
1012  /* Initialize at 15 so that it wraps and is equal to 0 for the
1013  * first packet we write. */
1014  ts->pat.cc = 15;
1017  ts->pat.opaque = s;
1018 
1019  ts->sdt.pid = SDT_PID;
1020  ts->sdt.cc = 15;
1023  ts->sdt.opaque = s;
1024 
1025  /* assign pids to each stream */
1026  for (i = 0; i < s->nb_streams; i++) {
1027  AVStream *st = s->streams[i];
1028  MpegTSWriteStream *ts_st;
1029 
1030  ts_st = av_mallocz(sizeof(MpegTSWriteStream));
1031  if (!ts_st) {
1032  return AVERROR(ENOMEM);
1033  }
1034  st->priv_data = ts_st;
1035 
1036  avpriv_set_pts_info(st, 33, 1, 90000);
1037 
1038  ts_st->payload = av_mallocz(ts->pes_payload_size);
1039  if (!ts_st->payload) {
1040  return AVERROR(ENOMEM);
1041  }
1042 
1043  /* MPEG pid values < 16 are reserved. Applications which set st->id in
1044  * this range are assigned a calculated pid. */
1045  if (st->id < 16) {
1046  if (ts->m2ts_mode) {
1047  switch (st->codecpar->codec_type) {
1048  case AVMEDIA_TYPE_VIDEO:
1049  ts_st->pid = ts->m2ts_video_pid++;
1050  break;
1051  case AVMEDIA_TYPE_AUDIO:
1052  ts_st->pid = ts->m2ts_audio_pid++;
1053  break;
1054  case AVMEDIA_TYPE_SUBTITLE:
1055  switch (st->codecpar->codec_id) {
1057  ts_st->pid = ts->m2ts_pgssub_pid++;
1058  break;
1060  ts_st->pid = ts->m2ts_textsub_pid++;
1061  break;
1062  }
1063  break;
1064  }
1065  if (ts->m2ts_video_pid > M2TS_VIDEO_PID + 1 ||
1066  ts->m2ts_audio_pid > M2TS_AUDIO_START_PID + 32 ||
1068  ts->m2ts_textsub_pid > M2TS_TEXTSUB_PID + 1 ||
1069  ts_st->pid < 16) {
1070  av_log(s, AV_LOG_ERROR, "Cannot automatically assign PID for stream %d\n", st->index);
1071  return AVERROR(EINVAL);
1072  }
1073  } else {
1074  ts_st->pid = ts->start_pid + i;
1075  }
1076  } else {
1077  ts_st->pid = st->id;
1078  }
1079  if (ts_st->pid >= 0x1FFF) {
1080  av_log(s, AV_LOG_ERROR,
1081  "Invalid stream id %d, must be less than 8191\n", st->id);
1082  return AVERROR(EINVAL);
1083  }
1084  for (j = 0; j < ts->nb_services; j++) {
1085  if (ts->services[j]->pmt.pid > LAST_OTHER_PID) {
1086  av_log(s, AV_LOG_ERROR,
1087  "Invalid PMT PID %d, must be less than %d\n", ts->services[j]->pmt.pid, LAST_OTHER_PID + 1);
1088  return AVERROR(EINVAL);
1089  }
1090  if (ts_st->pid == ts->services[j]->pmt.pid) {
1091  av_log(s, AV_LOG_ERROR, "PID %d cannot be both elementary and PMT PID\n", ts_st->pid);
1092  return AVERROR(EINVAL);
1093  }
1094  }
1095  for (j = 0; j < i; j++) {
1096  MpegTSWriteStream *ts_st_prev = s->streams[j]->priv_data;
1097  if (ts_st_prev->pid == ts_st->pid) {
1098  av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
1099  return AVERROR(EINVAL);
1100  }
1101  }
1102  ts_st->payload_pts = AV_NOPTS_VALUE;
1103  ts_st->payload_dts = AV_NOPTS_VALUE;
1104  ts_st->cc = 15;
1105  ts_st->discontinuity = ts->flags & MPEGTS_FLAG_DISCONT;
1106  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1107  st->codecpar->extradata_size > 0) {
1108  AVStream *ast;
1109  ts_st->amux = avformat_alloc_context();
1110  if (!ts_st->amux) {
1111  return AVERROR(ENOMEM);
1112  }
1113  ts_st->amux->oformat =
1114  av_guess_format((ts->flags & MPEGTS_FLAG_AAC_LATM) ? "latm" : "adts",
1115  NULL, NULL);
1116  if (!ts_st->amux->oformat) {
1117  return AVERROR(EINVAL);
1118  }
1119  if (!(ast = avformat_new_stream(ts_st->amux, NULL))) {
1120  return AVERROR(ENOMEM);
1121  }
1122  ret = avcodec_parameters_copy(ast->codecpar, st->codecpar);
1123  if (ret != 0)
1124  return ret;
1125  ast->time_base = st->time_base;
1126  ret = avformat_write_header(ts_st->amux, NULL);
1127  if (ret < 0)
1128  return ret;
1129  }
1130  if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
1132  }
1133  }
1134 
1135  if (ts->copyts < 1)
1137 
1138  select_pcr_streams(s);
1139 
1144 
1145  if (ts->mux_rate == 1)
1146  av_log(s, AV_LOG_VERBOSE, "muxrate VBR, ");
1147  else
1148  av_log(s, AV_LOG_VERBOSE, "muxrate %d, ", ts->mux_rate);
1150  "sdt every %"PRId64" ms, pat/pmt every %"PRId64" ms\n",
1151  av_rescale(ts->sdt_period, 1000, PCR_TIME_BASE),
1152  av_rescale(ts->pat_period, 1000, PCR_TIME_BASE));
1153 
1154  return 0;
1155 }
1156 
1157 /* send SDT, PAT and PMT tables regularly */
1158 static void retransmit_si_info(AVFormatContext *s, int force_pat, int force_sdt, int64_t pcr)
1159 {
1160  MpegTSWrite *ts = s->priv_data;
1161  int i;
1162 
1163  if ((pcr != AV_NOPTS_VALUE && ts->last_sdt_ts == AV_NOPTS_VALUE) ||
1164  (pcr != AV_NOPTS_VALUE && pcr - ts->last_sdt_ts >= ts->sdt_period) ||
1165  force_sdt
1166  ) {
1167  if (pcr != AV_NOPTS_VALUE)
1168  ts->last_sdt_ts = FFMAX(pcr, ts->last_sdt_ts);
1169  mpegts_write_sdt(s);
1170  }
1171  if ((pcr != AV_NOPTS_VALUE && ts->last_pat_ts == AV_NOPTS_VALUE) ||
1172  (pcr != AV_NOPTS_VALUE && pcr - ts->last_pat_ts >= ts->pat_period) ||
1173  force_pat) {
1174  if (pcr != AV_NOPTS_VALUE)
1175  ts->last_pat_ts = FFMAX(pcr, ts->last_pat_ts);
1176  mpegts_write_pat(s);
1177  for (i = 0; i < ts->nb_services; i++)
1178  mpegts_write_pmt(s, ts->services[i]);
1179  }
1180 }
1181 
1182 static int write_pcr_bits(uint8_t *buf, int64_t pcr)
1183 {
1184  int64_t pcr_low = pcr % 300, pcr_high = pcr / 300;
1185 
1186  *buf++ = pcr_high >> 25;
1187  *buf++ = pcr_high >> 17;
1188  *buf++ = pcr_high >> 9;
1189  *buf++ = pcr_high >> 1;
1190  *buf++ = pcr_high << 7 | pcr_low >> 8 | 0x7e;
1191  *buf++ = pcr_low;
1192 
1193  return 6;
1194 }
1195 
1196 /* Write a single null transport stream packet */
1198 {
1199  uint8_t *q;
1200  uint8_t buf[TS_PACKET_SIZE];
1201 
1202  q = buf;
1203  *q++ = 0x47;
1204  *q++ = 0x00 | 0x1f;
1205  *q++ = 0xff;
1206  *q++ = 0x10;
1207  memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
1208  write_packet(s, buf);
1209 }
1210 
1211 /* Write a single transport stream packet with a PCR and no payload */
1213 {
1214  MpegTSWrite *ts = s->priv_data;
1215  MpegTSWriteStream *ts_st = st->priv_data;
1216  uint8_t *q;
1217  uint8_t buf[TS_PACKET_SIZE];
1218 
1219  q = buf;
1220  *q++ = 0x47;
1221  *q++ = ts_st->pid >> 8;
1222  *q++ = ts_st->pid;
1223  *q++ = 0x20 | ts_st->cc; /* Adaptation only */
1224  /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
1225  *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */
1226  *q++ = 0x10; /* Adaptation flags: PCR present */
1227  if (ts_st->discontinuity) {
1228  q[-1] |= 0x80;
1229  ts_st->discontinuity = 0;
1230  }
1231 
1232  /* PCR coded into 6 bytes */
1233  q += write_pcr_bits(q, get_pcr(ts));
1234 
1235  /* stuffing bytes */
1236  memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
1237  write_packet(s, buf);
1238 }
1239 
1240 static void write_pts(uint8_t *q, int fourbits, int64_t pts)
1241 {
1242  int val;
1243 
1244  val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1;
1245  *q++ = val;
1246  val = (((pts >> 15) & 0x7fff) << 1) | 1;
1247  *q++ = val >> 8;
1248  *q++ = val;
1249  val = (((pts) & 0x7fff) << 1) | 1;
1250  *q++ = val >> 8;
1251  *q++ = val;
1252 }
1253 
1254 /* Set an adaptation field flag in an MPEG-TS packet*/
1255 static void set_af_flag(uint8_t *pkt, int flag)
1256 {
1257  // expect at least one flag to set
1258  av_assert0(flag);
1259 
1260  if ((pkt[3] & 0x20) == 0) {
1261  // no AF yet, set adaptation field flag
1262  pkt[3] |= 0x20;
1263  // 1 byte length, no flags
1264  pkt[4] = 1;
1265  pkt[5] = 0;
1266  }
1267  pkt[5] |= flag;
1268 }
1269 
1270 /* Extend the adaptation field by size bytes */
1271 static void extend_af(uint8_t *pkt, int size)
1272 {
1273  // expect already existing adaptation field
1274  av_assert0(pkt[3] & 0x20);
1275  pkt[4] += size;
1276 }
1277 
1278 /* Get a pointer to MPEG-TS payload (right after TS packet header) */
1280 {
1281  if (pkt[3] & 0x20)
1282  return pkt + 5 + pkt[4];
1283  else
1284  return pkt + 4;
1285 }
1286 
1287 /* Add a PES header to the front of the payload, and segment into an integer
1288  * number of TS packets. The final TS packet is padded using an oversized
1289  * adaptation header to exactly fill the last TS packet.
1290  * NOTE: 'payload' contains a complete PES payload. */
1292  const uint8_t *payload, int payload_size,
1293  int64_t pts, int64_t dts, int key, int stream_id)
1294 {
1295  MpegTSWriteStream *ts_st = st->priv_data;
1296  MpegTSWrite *ts = s->priv_data;
1297  uint8_t buf[TS_PACKET_SIZE];
1298  uint8_t *q;
1299  int val, is_start, len, header_len, write_pcr, is_dvb_subtitle, is_dvb_teletext, flags;
1300  int afc_len, stuffing_len;
1301  int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
1302  int force_pat = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && key && !ts_st->prev_payload_key;
1303  int force_sdt = 0;
1304 
1305  av_assert0(ts_st->payload != buf || st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO);
1307  force_pat = 1;
1308  }
1309 
1310  if (ts->flags & MPEGTS_FLAG_REEMIT_PAT_PMT) {
1311  force_pat = 1;
1312  force_sdt = 1;
1314  }
1315 
1316  is_start = 1;
1317  while (payload_size > 0) {
1318  int64_t pcr = AV_NOPTS_VALUE;
1319  if (ts->mux_rate > 1)
1320  pcr = get_pcr(ts);
1321  else if (dts != AV_NOPTS_VALUE)
1322  pcr = (dts - delay) * 300;
1323 
1324  retransmit_si_info(s, force_pat, force_sdt, pcr);
1325  force_pat = 0;
1326  force_sdt = 0;
1327 
1328  write_pcr = 0;
1329  if (ts->mux_rate > 1) {
1330  /* Send PCR packets for all PCR streams if needed */
1331  pcr = get_pcr(ts);
1332  if (pcr >= ts->next_pcr) {
1333  int64_t next_pcr = INT64_MAX;
1334  for (int i = 0; i < s->nb_streams; i++) {
1335  /* Make the current stream the last, because for that we
1336  * can insert the pcr into the payload later */
1337  int st2_index = i < st->index ? i : (i + 1 == s->nb_streams ? st->index : i + 1);
1338  AVStream *st2 = s->streams[st2_index];
1339  MpegTSWriteStream *ts_st2 = st2->priv_data;
1340  if (ts_st2->pcr_period) {
1341  if (pcr - ts_st2->last_pcr >= ts_st2->pcr_period) {
1342  ts_st2->last_pcr = FFMAX(pcr - ts_st2->pcr_period, ts_st2->last_pcr + ts_st2->pcr_period);
1343  if (st2 != st) {
1344  mpegts_insert_pcr_only(s, st2);
1345  pcr = get_pcr(ts);
1346  } else {
1347  write_pcr = 1;
1348  }
1349  }
1350  next_pcr = FFMIN(next_pcr, ts_st2->last_pcr + ts_st2->pcr_period);
1351  }
1352  }
1353  ts->next_pcr = next_pcr;
1354  }
1355  if (dts != AV_NOPTS_VALUE && (dts - pcr / 300) > delay) {
1356  /* pcr insert gets priority over null packet insert */
1357  if (write_pcr)
1358  mpegts_insert_pcr_only(s, st);
1359  else
1361  /* recalculate write_pcr and possibly retransmit si_info */
1362  continue;
1363  }
1364  } else if (ts_st->pcr_period && pcr != AV_NOPTS_VALUE) {
1365  if (pcr - ts_st->last_pcr >= ts_st->pcr_period && is_start) {
1366  ts_st->last_pcr = FFMAX(pcr - ts_st->pcr_period, ts_st->last_pcr + ts_st->pcr_period);
1367  write_pcr = 1;
1368  }
1369  }
1370 
1371  /* prepare packet header */
1372  q = buf;
1373  *q++ = 0x47;
1374  val = ts_st->pid >> 8;
1375  if (ts->m2ts_mode && st->codecpar->codec_id == AV_CODEC_ID_AC3)
1376  val |= 0x20;
1377  if (is_start)
1378  val |= 0x40;
1379  *q++ = val;
1380  *q++ = ts_st->pid;
1381  ts_st->cc = ts_st->cc + 1 & 0xf;
1382  *q++ = 0x10 | ts_st->cc; // payload indicator + CC
1383  if (ts_st->discontinuity) {
1384  set_af_flag(buf, 0x80);
1385  q = get_ts_payload_start(buf);
1386  ts_st->discontinuity = 0;
1387  }
1388  if (key && is_start && pts != AV_NOPTS_VALUE) {
1389  // set Random Access for key frames
1390  if (ts_st->pcr_period)
1391  write_pcr = 1;
1392  set_af_flag(buf, 0x40);
1393  q = get_ts_payload_start(buf);
1394  }
1395  if (write_pcr) {
1396  set_af_flag(buf, 0x10);
1397  q = get_ts_payload_start(buf);
1398  // add 11, pcr references the last byte of program clock reference base
1399  if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
1400  av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
1401  extend_af(buf, write_pcr_bits(q, pcr));
1402  q = get_ts_payload_start(buf);
1403  }
1404  if (is_start) {
1405  int pes_extension = 0;
1406  int pes_header_stuffing_bytes = 0;
1407  /* write PES header */
1408  *q++ = 0x00;
1409  *q++ = 0x00;
1410  *q++ = 0x01;
1411  is_dvb_subtitle = 0;
1412  is_dvb_teletext = 0;
1413  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1414  if (st->codecpar->codec_id == AV_CODEC_ID_DIRAC)
1416  else
1417  *q++ = STREAM_ID_VIDEO_STREAM_0;
1418  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1419  (st->codecpar->codec_id == AV_CODEC_ID_MP2 ||
1420  st->codecpar->codec_id == AV_CODEC_ID_MP3 ||
1421  st->codecpar->codec_id == AV_CODEC_ID_AAC)) {
1422  *q++ = STREAM_ID_AUDIO_STREAM_0;
1423  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1424  st->codecpar->codec_id == AV_CODEC_ID_AC3 &&
1425  ts->m2ts_mode) {
1427  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA &&
1430  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
1431  *q++ = stream_id != -1 ? stream_id : STREAM_ID_METADATA_STREAM;
1432 
1433  if (stream_id == STREAM_ID_PRIVATE_STREAM_1) /* asynchronous KLV */
1434  pts = dts = AV_NOPTS_VALUE;
1435  } else {
1439  is_dvb_subtitle = 1;
1440  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT) {
1441  is_dvb_teletext = 1;
1442  }
1443  }
1444  }
1445  header_len = 0;
1446  flags = 0;
1447  if (pts != AV_NOPTS_VALUE) {
1448  header_len += 5;
1449  flags |= 0x80;
1450  }
1451  if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1452  header_len += 5;
1453  flags |= 0x40;
1454  }
1455  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1457  /* set PES_extension_flag */
1458  pes_extension = 1;
1459  flags |= 0x01;
1460 
1461  /* One byte for PES2 extension flag +
1462  * one byte for extension length +
1463  * one byte for extension id */
1464  header_len += 3;
1465  }
1466  /* for Blu-ray AC3 Audio the PES Extension flag should be as follow
1467  * otherwise it will not play sound on blu-ray
1468  */
1469  if (ts->m2ts_mode &&
1471  st->codecpar->codec_id == AV_CODEC_ID_AC3) {
1472  /* set PES_extension_flag */
1473  pes_extension = 1;
1474  flags |= 0x01;
1475  header_len += 3;
1476  }
1477  if (is_dvb_teletext) {
1478  pes_header_stuffing_bytes = 0x24 - header_len;
1479  header_len = 0x24;
1480  }
1481  len = payload_size + header_len + 3;
1482  /* 3 extra bytes should be added to DVB subtitle payload: 0x20 0x00 at the beginning and trailing 0xff */
1483  if (is_dvb_subtitle) {
1484  len += 3;
1485  payload_size++;
1486  }
1487  if (len > 0xffff)
1488  len = 0;
1490  len = 0;
1491  }
1492  *q++ = len >> 8;
1493  *q++ = len;
1494  val = 0x80;
1495  /* data alignment indicator is required for subtitle and data streams */
1497  val |= 0x04;
1498  *q++ = val;
1499  *q++ = flags;
1500  *q++ = header_len;
1501  if (pts != AV_NOPTS_VALUE) {
1502  write_pts(q, flags >> 6, pts);
1503  q += 5;
1504  }
1505  if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1506  write_pts(q, 1, dts);
1507  q += 5;
1508  }
1509  if (pes_extension && st->codecpar->codec_id == AV_CODEC_ID_DIRAC) {
1510  flags = 0x01; /* set PES_extension_flag_2 */
1511  *q++ = flags;
1512  *q++ = 0x80 | 0x01; /* marker bit + extension length */
1513  /* Set the stream ID extension flag bit to 0 and
1514  * write the extended stream ID. */
1515  *q++ = 0x00 | 0x60;
1516  }
1517  /* For Blu-ray AC3 Audio Setting extended flags */
1518  if (ts->m2ts_mode &&
1519  pes_extension &&
1520  st->codecpar->codec_id == AV_CODEC_ID_AC3) {
1521  flags = 0x01; /* set PES_extension_flag_2 */
1522  *q++ = flags;
1523  *q++ = 0x80 | 0x01; /* marker bit + extension length */
1524  *q++ = 0x00 | 0x71; /* for AC3 Audio (specifically on blue-rays) */
1525  }
1526 
1527 
1528  if (is_dvb_subtitle) {
1529  /* First two fields of DVB subtitles PES data:
1530  * data_identifier: for DVB subtitle streams shall be coded with the value 0x20
1531  * subtitle_stream_id: for DVB subtitle stream shall be identified by the value 0x00 */
1532  *q++ = 0x20;
1533  *q++ = 0x00;
1534  }
1535  if (is_dvb_teletext) {
1536  memset(q, 0xff, pes_header_stuffing_bytes);
1537  q += pes_header_stuffing_bytes;
1538  }
1539  is_start = 0;
1540  }
1541  /* header size */
1542  header_len = q - buf;
1543  /* data len */
1544  len = TS_PACKET_SIZE - header_len;
1545  if (len > payload_size)
1546  len = payload_size;
1547  stuffing_len = TS_PACKET_SIZE - header_len - len;
1548  if (stuffing_len > 0) {
1549  /* add stuffing with AFC */
1550  if (buf[3] & 0x20) {
1551  /* stuffing already present: increase its size */
1552  afc_len = buf[4] + 1;
1553  memmove(buf + 4 + afc_len + stuffing_len,
1554  buf + 4 + afc_len,
1555  header_len - (4 + afc_len));
1556  buf[4] += stuffing_len;
1557  memset(buf + 4 + afc_len, 0xff, stuffing_len);
1558  } else {
1559  /* add stuffing */
1560  memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4);
1561  buf[3] |= 0x20;
1562  buf[4] = stuffing_len - 1;
1563  if (stuffing_len >= 2) {
1564  buf[5] = 0x00;
1565  memset(buf + 6, 0xff, stuffing_len - 2);
1566  }
1567  }
1568  }
1569 
1570  if (is_dvb_subtitle && payload_size == len) {
1571  memcpy(buf + TS_PACKET_SIZE - len, payload, len - 1);
1572  buf[TS_PACKET_SIZE - 1] = 0xff; /* end_of_PES_data_field_marker: an 8-bit field with fixed contents 0xff for DVB subtitle */
1573  } else {
1574  memcpy(buf + TS_PACKET_SIZE - len, payload, len);
1575  }
1576 
1577  payload += len;
1578  payload_size -= len;
1579  write_packet(s, buf);
1580  }
1581  ts_st->prev_payload_key = key;
1582 }
1583 
1585 {
1586  if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001 && AV_RB24(pkt->data) != 0x000001) {
1587  if (!st->nb_frames) {
1588  av_log(s, AV_LOG_ERROR, "H.264 bitstream malformed, "
1589  "no startcode found, use the video bitstream filter 'h264_mp4toannexb' to fix it "
1590  "('-bsf:v h264_mp4toannexb' option with ffmpeg)\n");
1591  return AVERROR_INVALIDDATA;
1592  }
1593  av_log(s, AV_LOG_WARNING, "H.264 bitstream error, startcode missing, size %d", pkt->size);
1594  if (pkt->size)
1595  av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
1596  av_log(s, AV_LOG_WARNING, "\n");
1597  }
1598  return 0;
1599 }
1600 
1602 {
1603  if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001 && AV_RB24(pkt->data) != 0x000001) {
1604  if (!st->nb_frames) {
1605  av_log(s, AV_LOG_ERROR, "HEVC bitstream malformed, no startcode found\n");
1606  return AVERROR_PATCHWELCOME;
1607  }
1608  av_log(s, AV_LOG_WARNING, "HEVC bitstream error, startcode missing, size %d", pkt->size);
1609  if (pkt->size)
1610  av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
1611  av_log(s, AV_LOG_WARNING, "\n");
1612  }
1613  return 0;
1614 }
1615 
1616 /* Based on GStreamer's gst-plugins-base/ext/ogg/gstoggstream.c
1617  * Released under the LGPL v2.1+, written by
1618  * Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
1619  */
1621 {
1622  static const int durations[32] = {
1623  480, 960, 1920, 2880, /* Silk NB */
1624  480, 960, 1920, 2880, /* Silk MB */
1625  480, 960, 1920, 2880, /* Silk WB */
1626  480, 960, /* Hybrid SWB */
1627  480, 960, /* Hybrid FB */
1628  120, 240, 480, 960, /* CELT NB */
1629  120, 240, 480, 960, /* CELT NB */
1630  120, 240, 480, 960, /* CELT NB */
1631  120, 240, 480, 960, /* CELT NB */
1632  };
1633  int toc, frame_duration, nframes, duration;
1634 
1635  if (pkt->size < 1)
1636  return 0;
1637 
1638  toc = pkt->data[0];
1639 
1640  frame_duration = durations[toc >> 3];
1641  switch (toc & 3) {
1642  case 0:
1643  nframes = 1;
1644  break;
1645  case 1:
1646  nframes = 2;
1647  break;
1648  case 2:
1649  nframes = 2;
1650  break;
1651  case 3:
1652  if (pkt->size < 2)
1653  return 0;
1654  nframes = pkt->data[1] & 63;
1655  break;
1656  }
1657 
1658  duration = nframes * frame_duration;
1659  if (duration > 5760) {
1661  "Opus packet duration > 120 ms, invalid");
1662  return 0;
1663  }
1664 
1665  return duration;
1666 }
1667 
1669 {
1670  AVStream *st = s->streams[pkt->stream_index];
1671  int size = pkt->size;
1672  uint8_t *buf = pkt->data;
1673  uint8_t *data = NULL;
1674  MpegTSWrite *ts = s->priv_data;
1675  MpegTSWriteStream *ts_st = st->priv_data;
1676  const int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) * 2;
1677  const int64_t max_audio_delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) / 2;
1678  int64_t dts = pkt->dts, pts = pkt->pts;
1679  int opus_samples = 0;
1680  int side_data_size;
1681  uint8_t *side_data = NULL;
1682  int stream_id = -1;
1683 
1684  side_data = av_packet_get_side_data(pkt,
1686  &side_data_size);
1687  if (side_data)
1688  stream_id = side_data[0];
1689 
1690  if (ts->copyts < 1) {
1691  if (!ts->first_dts_checked && dts != AV_NOPTS_VALUE) {
1692  ts->first_pcr += dts * 300;
1693  ts->first_dts_checked = 1;
1694  }
1695 
1696  if (pts != AV_NOPTS_VALUE)
1697  pts += delay;
1698  if (dts != AV_NOPTS_VALUE)
1699  dts += delay;
1700  }
1701 
1702  if (!ts_st->first_timestamp_checked && (pts == AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)) {
1703  av_log(s, AV_LOG_ERROR, "first pts and dts value must be set\n");
1704  return AVERROR_INVALIDDATA;
1705  }
1706  ts_st->first_timestamp_checked = 1;
1707 
1708  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
1709  const uint8_t *p = buf, *buf_end = p + size;
1710  uint32_t state = -1;
1711  int extradd = (pkt->flags & AV_PKT_FLAG_KEY) ? st->codecpar->extradata_size : 0;
1712  int ret = ff_check_h264_startcode(s, st, pkt);
1713  if (ret < 0)
1714  return ret;
1715 
1716  if (extradd && AV_RB24(st->codecpar->extradata) > 1)
1717  extradd = 0;
1718 
1719  do {
1720  p = avpriv_find_start_code(p, buf_end, &state);
1721  av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", state & 0x1f);
1722  if ((state & 0x1f) == 7)
1723  extradd = 0;
1724  } while (p < buf_end && (state & 0x1f) != 9 &&
1725  (state & 0x1f) != 5 && (state & 0x1f) != 1);
1726 
1727  if ((state & 0x1f) != 5)
1728  extradd = 0;
1729  if ((state & 0x1f) != 9) { // AUD NAL
1730  data = av_malloc(pkt->size + 6 + extradd);
1731  if (!data)
1732  return AVERROR(ENOMEM);
1733  memcpy(data + 6, st->codecpar->extradata, extradd);
1734  memcpy(data + 6 + extradd, pkt->data, pkt->size);
1735  AV_WB32(data, 0x00000001);
1736  data[4] = 0x09;
1737  data[5] = 0xf0; // any slice type (0xe) + rbsp stop one bit
1738  buf = data;
1739  size = pkt->size + 6 + extradd;
1740  }
1741  } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1742  if (pkt->size < 2) {
1743  av_log(s, AV_LOG_ERROR, "AAC packet too short\n");
1744  return AVERROR_INVALIDDATA;
1745  }
1746  if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) {
1747  int ret;
1748  AVPacket pkt2;
1749 
1750  if (!ts_st->amux) {
1751  av_log(s, AV_LOG_ERROR, "AAC bitstream not in ADTS format "
1752  "and extradata missing\n");
1753  } else {
1754  av_init_packet(&pkt2);
1755  pkt2.data = pkt->data;
1756  pkt2.size = pkt->size;
1757  av_assert0(pkt->dts != AV_NOPTS_VALUE);
1758  pkt2.dts = av_rescale_q(pkt->dts, st->time_base, ts_st->amux->streams[0]->time_base);
1759 
1760  ret = avio_open_dyn_buf(&ts_st->amux->pb);
1761  if (ret < 0)
1762  return ret;
1763 
1764  ret = av_write_frame(ts_st->amux, &pkt2);
1765  if (ret < 0) {
1766  ffio_free_dyn_buf(&ts_st->amux->pb);
1767  return ret;
1768  }
1769  size = avio_close_dyn_buf(ts_st->amux->pb, &data);
1770  ts_st->amux->pb = NULL;
1771  buf = data;
1772  }
1773  }
1774  } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
1775  const uint8_t *p = buf, *buf_end = p + size;
1776  uint32_t state = -1;
1777  int extradd = (pkt->flags & AV_PKT_FLAG_KEY) ? st->codecpar->extradata_size : 0;
1778  int ret = check_hevc_startcode(s, st, pkt);
1779  if (ret < 0)
1780  return ret;
1781 
1782  if (extradd && AV_RB24(st->codecpar->extradata) > 1)
1783  extradd = 0;
1784 
1785  do {
1786  p = avpriv_find_start_code(p, buf_end, &state);
1787  av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", (state & 0x7e)>>1);
1788  if ((state & 0x7e) == 2*32)
1789  extradd = 0;
1790  } while (p < buf_end && (state & 0x7e) != 2*35 &&
1791  (state & 0x7e) >= 2*32);
1792 
1793  if ((state & 0x7e) < 2*16 || (state & 0x7e) >= 2*24)
1794  extradd = 0;
1795  if ((state & 0x7e) != 2*35) { // AUD NAL
1796  data = av_malloc(pkt->size + 7 + extradd);
1797  if (!data)
1798  return AVERROR(ENOMEM);
1799  memcpy(data + 7, st->codecpar->extradata, extradd);
1800  memcpy(data + 7 + extradd, pkt->data, pkt->size);
1801  AV_WB32(data, 0x00000001);
1802  data[4] = 2*35;
1803  data[5] = 1;
1804  data[6] = 0x50; // any slice type (0x4) + rbsp stop one bit
1805  buf = data;
1806  size = pkt->size + 7 + extradd;
1807  }
1808  } else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
1809  if (pkt->size < 2) {
1810  av_log(s, AV_LOG_ERROR, "Opus packet too short\n");
1811  return AVERROR_INVALIDDATA;
1812  }
1813 
1814  /* Add Opus control header */
1815  if ((AV_RB16(pkt->data) >> 5) != 0x3ff) {
1816  uint8_t *side_data;
1817  int side_data_size;
1818  int i, n;
1819  int ctrl_header_size;
1820  int trim_start = 0, trim_end = 0;
1821 
1822  opus_samples = opus_get_packet_samples(s, pkt);
1823 
1824  side_data = av_packet_get_side_data(pkt,
1826  &side_data_size);
1827 
1828  if (side_data && side_data_size >= 10) {
1829  trim_end = AV_RL32(side_data + 4) * 48000 / st->codecpar->sample_rate;
1830  }
1831 
1832  ctrl_header_size = pkt->size + 2 + pkt->size / 255 + 1;
1833  if (ts_st->opus_pending_trim_start)
1834  ctrl_header_size += 2;
1835  if (trim_end)
1836  ctrl_header_size += 2;
1837 
1838  data = av_malloc(ctrl_header_size);
1839  if (!data)
1840  return AVERROR(ENOMEM);
1841 
1842  data[0] = 0x7f;
1843  data[1] = 0xe0;
1844  if (ts_st->opus_pending_trim_start)
1845  data[1] |= 0x10;
1846  if (trim_end)
1847  data[1] |= 0x08;
1848 
1849  n = pkt->size;
1850  i = 2;
1851  do {
1852  data[i] = FFMIN(n, 255);
1853  n -= 255;
1854  i++;
1855  } while (n >= 0);
1856 
1857  av_assert0(2 + pkt->size / 255 + 1 == i);
1858 
1859  if (ts_st->opus_pending_trim_start) {
1860  trim_start = FFMIN(ts_st->opus_pending_trim_start, opus_samples);
1861  AV_WB16(data + i, trim_start);
1862  i += 2;
1863  ts_st->opus_pending_trim_start -= trim_start;
1864  }
1865  if (trim_end) {
1866  trim_end = FFMIN(trim_end, opus_samples - trim_start);
1867  AV_WB16(data + i, trim_end);
1868  i += 2;
1869  }
1870 
1871  memcpy(data + i, pkt->data, pkt->size);
1872  buf = data;
1873  size = ctrl_header_size;
1874  } else {
1875  /* TODO: Can we get TS formatted data here? If so we will
1876  * need to count the samples of that too! */
1877  av_log(s, AV_LOG_WARNING, "Got MPEG-TS formatted Opus data, unhandled");
1878  }
1879  } else if (st->codecpar->codec_id == AV_CODEC_ID_AC3 && !ts_st->dvb_ac3_desc) {
1880  AC3HeaderInfo *hdr = NULL;
1881 
1882  if (avpriv_ac3_parse_header(&hdr, pkt->data, pkt->size) >= 0) {
1883  uint8_t number_of_channels_flag;
1884  uint8_t service_type_flag;
1885  uint8_t full_service_flag = 1;
1886  DVBAC3Descriptor *dvb_ac3_desc;
1887 
1888  dvb_ac3_desc = av_mallocz(sizeof(*dvb_ac3_desc));
1889  if (!dvb_ac3_desc) {
1890  av_free(hdr);
1891  return AVERROR(ENOMEM);
1892  }
1893 
1894  service_type_flag = hdr->bitstream_mode;
1895  switch (hdr->channel_mode) {
1896  case AC3_CHMODE_DUALMONO:
1897  number_of_channels_flag = 1;
1898  break;
1899  case AC3_CHMODE_MONO:
1900  number_of_channels_flag = 0;
1901  break;
1902  case AC3_CHMODE_STEREO:
1903  if (hdr->dolby_surround_mode == AC3_DSURMOD_ON)
1904  number_of_channels_flag = 3;
1905  else
1906  number_of_channels_flag = 2;
1907  break;
1908  case AC3_CHMODE_3F:
1909  case AC3_CHMODE_2F1R:
1910  case AC3_CHMODE_3F1R:
1911  case AC3_CHMODE_2F2R:
1912  case AC3_CHMODE_3F2R:
1913  number_of_channels_flag = 4;
1914  break;
1915  default: /* reserved */
1916  number_of_channels_flag = 7;
1917  break;
1918  }
1919 
1920  if (service_type_flag == 1 || service_type_flag == 4 ||
1921  (service_type_flag == 7 && !number_of_channels_flag))
1922  full_service_flag = 0;
1923 
1924  dvb_ac3_desc->component_type_flag = 1;
1925  dvb_ac3_desc->component_type = (full_service_flag << 6) |
1926  ((service_type_flag & 0x7) << 3) |
1927  (number_of_channels_flag & 0x7);
1928  dvb_ac3_desc->bsid_flag = 1;
1929  dvb_ac3_desc->bsid = hdr->bitstream_id;
1930  dvb_ac3_desc->mainid_flag = 0;
1931  dvb_ac3_desc->asvc_flag = 0;
1932 
1933  ts_st->dvb_ac3_desc = dvb_ac3_desc;
1934  }
1935  av_free(hdr);
1936  }
1937 
1938  if (ts_st->payload_size && (ts_st->payload_size + size > ts->pes_payload_size ||
1939  (dts != AV_NOPTS_VALUE && ts_st->payload_dts != AV_NOPTS_VALUE &&
1940  dts - ts_st->payload_dts >= max_audio_delay) ||
1941  ts_st->opus_queued_samples + opus_samples >= 5760 /* 120ms */)) {
1942  mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
1943  ts_st->payload_pts, ts_st->payload_dts,
1944  ts_st->payload_flags & AV_PKT_FLAG_KEY, stream_id);
1945  ts_st->payload_size = 0;
1946  ts_st->opus_queued_samples = 0;
1947  }
1948 
1949  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || size > ts->pes_payload_size) {
1950  av_assert0(!ts_st->payload_size);
1951  // for video and subtitle, write a single pes packet
1952  mpegts_write_pes(s, st, buf, size, pts, dts,
1953  pkt->flags & AV_PKT_FLAG_KEY, stream_id);
1954  ts_st->opus_queued_samples = 0;
1955  av_free(data);
1956  return 0;
1957  }
1958 
1959  if (!ts_st->payload_size) {
1960  ts_st->payload_pts = pts;
1961  ts_st->payload_dts = dts;
1962  ts_st->payload_flags = pkt->flags;
1963  }
1964 
1965  memcpy(ts_st->payload + ts_st->payload_size, buf, size);
1966  ts_st->payload_size += size;
1967  ts_st->opus_queued_samples += opus_samples;
1968 
1969  av_free(data);
1970 
1971  return 0;
1972 }
1973 
1975 {
1976  MpegTSWrite *ts = s->priv_data;
1977  int i;
1978 
1979  /* flush current packets */
1980  for (i = 0; i < s->nb_streams; i++) {
1981  AVStream *st = s->streams[i];
1982  MpegTSWriteStream *ts_st = st->priv_data;
1983  if (ts_st->payload_size > 0) {
1984  mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
1985  ts_st->payload_pts, ts_st->payload_dts,
1986  ts_st->payload_flags & AV_PKT_FLAG_KEY, -1);
1987  ts_st->payload_size = 0;
1988  ts_st->opus_queued_samples = 0;
1989  }
1990  }
1991 
1992  if (ts->m2ts_mode) {
1993  int packets = (avio_tell(s->pb) / (TS_PACKET_SIZE + 4)) % 32;
1994  while (packets++ < 32)
1996  }
1997 }
1998 
2000 {
2001  if (!pkt) {
2002  mpegts_write_flush(s);
2003  return 1;
2004  } else {
2005  return mpegts_write_packet_internal(s, pkt);
2006  }
2007 }
2008 
2010 {
2011  if (s->pb)
2012  mpegts_write_flush(s);
2013 
2014  return 0;
2015 }
2016 
2018 {
2019  MpegTSWrite *ts = s->priv_data;
2020  MpegTSService *service;
2021  int i;
2022 
2023  for (i = 0; i < s->nb_streams; i++) {
2024  AVStream *st = s->streams[i];
2025  MpegTSWriteStream *ts_st = st->priv_data;
2026  if (ts_st) {
2027  av_freep(&ts_st->dvb_ac3_desc);
2028  av_freep(&ts_st->payload);
2029  if (ts_st->amux) {
2030  avformat_free_context(ts_st->amux);
2031  ts_st->amux = NULL;
2032  }
2033  }
2034  }
2035 
2036  for (i = 0; i < ts->nb_services; i++) {
2037  service = ts->services[i];
2038  av_freep(&service);
2039  }
2040  av_freep(&ts->services);
2041 }
2042 
2044 {
2045  int ret = 1;
2046  AVStream *st = s->streams[pkt->stream_index];
2047 
2048  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2049  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
2050  (AV_RB24(pkt->data) != 0x000001 ||
2051  (st->codecpar->extradata_size > 0 &&
2052  st->codecpar->extradata[0] == 1)))
2053  ret = ff_stream_add_bitstream_filter(st, "h264_mp4toannexb", NULL);
2054  } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
2055  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
2056  (AV_RB24(pkt->data) != 0x000001 ||
2057  (st->codecpar->extradata_size > 0 &&
2058  st->codecpar->extradata[0] == 1)))
2059  ret = ff_stream_add_bitstream_filter(st, "hevc_mp4toannexb", NULL);
2060  }
2061 
2062  return ret;
2063 }
2064 
2065 #define OFFSET(x) offsetof(MpegTSWrite, x)
2066 #define ENC AV_OPT_FLAG_ENCODING_PARAM
2067 static const AVOption options[] = {
2068  { "mpegts_transport_stream_id", "Set transport_stream_id field.",
2069  OFFSET(transport_stream_id), AV_OPT_TYPE_INT, { .i64 = 0x0001 }, 0x0001, 0xffff, ENC },
2070  { "mpegts_original_network_id", "Set original_network_id field.",
2071  OFFSET(original_network_id), AV_OPT_TYPE_INT, { .i64 = DVB_PRIVATE_NETWORK_START }, 0x0001, 0xffff, ENC },
2072  { "mpegts_service_id", "Set service_id field.",
2073  OFFSET(service_id), AV_OPT_TYPE_INT, { .i64 = 0x0001 }, 0x0001, 0xffff, ENC },
2074  { "mpegts_service_type", "Set service_type field.",
2075  OFFSET(service_type), AV_OPT_TYPE_INT, { .i64 = 0x01 }, 0x01, 0xff, ENC, "mpegts_service_type" },
2076  { "digital_tv", "Digital Television.",
2077  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_DIGITAL_TV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2078  { "digital_radio", "Digital Radio.",
2079  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_DIGITAL_RADIO }, 0x01, 0xff, ENC, "mpegts_service_type" },
2080  { "teletext", "Teletext.",
2081  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_TELETEXT }, 0x01, 0xff, ENC, "mpegts_service_type" },
2082  { "advanced_codec_digital_radio", "Advanced Codec Digital Radio.",
2083  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_RADIO }, 0x01, 0xff, ENC, "mpegts_service_type" },
2084  { "mpeg2_digital_hdtv", "MPEG2 Digital HDTV.",
2085  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_MPEG2_DIGITAL_HDTV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2086  { "advanced_codec_digital_sdtv", "Advanced Codec Digital SDTV.",
2087  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_SDTV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2088  { "advanced_codec_digital_hdtv", "Advanced Codec Digital HDTV.",
2089  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_HDTV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2090  { "hevc_digital_hdtv", "HEVC Digital Television Service.",
2091  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_HEVC_DIGITAL_HDTV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2092  { "mpegts_pmt_start_pid", "Set the first pid of the PMT.",
2093  OFFSET(pmt_start_pid), AV_OPT_TYPE_INT, { .i64 = 0x1000 }, FIRST_OTHER_PID, LAST_OTHER_PID, ENC },
2094  { "mpegts_start_pid", "Set the first pid.",
2095  OFFSET(start_pid), AV_OPT_TYPE_INT, { .i64 = 0x0100 }, FIRST_OTHER_PID, LAST_OTHER_PID, ENC },
2096  { "mpegts_m2ts_mode", "Enable m2ts mode.", OFFSET(m2ts_mode), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, ENC },
2097  { "muxrate", NULL, OFFSET(mux_rate), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, INT_MAX, ENC },
2098  { "pes_payload_size", "Minimum PES packet payload in bytes",
2099  OFFSET(pes_payload_size), AV_OPT_TYPE_INT, { .i64 = DEFAULT_PES_PAYLOAD_SIZE }, 0, INT_MAX, ENC },
2100  { "mpegts_flags", "MPEG-TS muxing flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, 0, INT_MAX, ENC, "mpegts_flags" },
2101  { "resend_headers", "Reemit PAT/PMT before writing the next packet",
2102  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_REEMIT_PAT_PMT }, 0, INT_MAX, ENC, "mpegts_flags" },
2103  { "latm", "Use LATM packetization for AAC",
2104  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_AAC_LATM }, 0, INT_MAX, ENC, "mpegts_flags" },
2105  { "pat_pmt_at_frames", "Reemit PAT and PMT at each video frame",
2106  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_PAT_PMT_AT_FRAMES}, 0, INT_MAX, ENC, "mpegts_flags" },
2107  { "system_b", "Conform to System B (DVB) instead of System A (ATSC)",
2108  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_SYSTEM_B }, 0, INT_MAX, ENC, "mpegts_flags" },
2109  { "initial_discontinuity", "Mark initial packets as discontinuous",
2110  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_DISCONT }, 0, INT_MAX, ENC, "mpegts_flags" },
2111  { "mpegts_copyts", "don't offset dts/pts", OFFSET(copyts), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, ENC },
2112  { "tables_version", "set PAT, PMT and SDT version", OFFSET(tables_version), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 31, ENC },
2113  { "omit_video_pes_length", "Omit the PES packet length for video packets",
2114  OFFSET(omit_video_pes_length), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, ENC },
2115  { "pcr_period", "PCR retransmission time in milliseconds",
2116  OFFSET(pcr_period_ms), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, ENC },
2117  { "pat_period", "PAT/PMT retransmission time limit in seconds",
2118  OFFSET(pat_period_us), AV_OPT_TYPE_DURATION, { .i64 = PAT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, ENC },
2119  { "sdt_period", "SDT retransmission time limit in seconds",
2120  OFFSET(sdt_period_us), AV_OPT_TYPE_DURATION, { .i64 = SDT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, ENC },
2121  { NULL },
2122 };
2123 
2124 static const AVClass mpegts_muxer_class = {
2125  .class_name = "MPEGTS muxer",
2126  .item_name = av_default_item_name,
2127  .option = options,
2128  .version = LIBAVUTIL_VERSION_INT,
2129 };
2130 
2132  .name = "mpegts",
2133  .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
2134  .mime_type = "video/MP2T",
2135  .extensions = "ts,m2t,m2ts,mts",
2136  .priv_data_size = sizeof(MpegTSWrite),
2137  .audio_codec = AV_CODEC_ID_MP2,
2138  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
2139  .init = mpegts_init,
2142  .deinit = mpegts_deinit,
2145  .priv_class = &mpegts_muxer_class,
2146 };
uint8_t bitstream_mode
Definition: ac3.h:185
int64_t total_size
Definition: mpegtsenc.c:88
#define NULL
Definition: coverity.c:32
#define SDT_PID
Definition: mpegts.h:43
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
uint8_t bsid
Definition: mpegts.h:199
version
Definition: libkvazaar.c:317
#define PMT_TID
Definition: mpegts.h:81
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:426
#define SECTION_LENGTH
Definition: mpegtsenc.c:126
uint8_t mainid
Definition: mpegts.h:200
#define STREAM_TYPE_AUDIO_MPEG2
Definition: mpeg.h:52
uint8_t provider_name[256]
Definition: mpegtsenc.c:59
MpegTSSection pmt
Definition: mpegtsenc.c:56
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1426
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:1190
#define METADATA_DESCRIPTOR
Definition: mpegts.h:154
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
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:4871
static void retransmit_si_info(AVFormatContext *s, int force_pat, int force_sdt, int64_t pcr)
Definition: mpegtsenc.c:1158
#define STREAM_TYPE_VIDEO_CAVS
Definition: mpeg.h:59
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static void put_registration_descriptor(uint8_t **q_ptr, uint32_t tag)
Definition: mpegtsenc.c:277
int64_t payload_dts
Definition: mpegtsenc.c:238
#define OFFSET(x)
Definition: mpegtsenc.c:2065
void av_log_once(void *avcl, int initial_level, int subsequent_level, int *state, const char *fmt,...)
Definition: log.c:415
static int mpegts_init(AVFormatContext *s)
Definition: mpegtsenc.c:966
uint8_t component_type
Definition: mpegts.h:198
int64_t sdt_period_us
Definition: mpegtsenc.c:113
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:881
int size
Definition: packet.h:364
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int64_t last_sdt_ts
Definition: mpegtsenc.c:115
#define PCR_TIME_BASE
Definition: mpegtsenc.c:38
#define ISO_639_LANGUAGE_DESCRIPTOR
Definition: mpegts.h:150
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:838
#define STREAM_TYPE_AUDIO_EAC3
Definition: mpegts.h:138
void * priv_data
Definition: avformat.h:895
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:840
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
#define PCR_RETRANS_TIME
Definition: mpegtsenc.c:228
static AVPacket pkt
int64_t first_pcr
Definition: mpegtsenc.c:83
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:91
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:471
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1381
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1547
Format I/O context.
Definition: avformat.h:1239
#define MPEGTS_FLAG_DISCONT
Definition: mpegtsenc.c:108
static void enable_pcr_generation_for_stream(AVFormatContext *s, AVStream *pcr_st)
Definition: mpegtsenc.c:906
#define STREAM_ID_VIDEO_STREAM_0
Definition: mpegts.h:143
unsigned int nb_stream_indexes
Definition: avformat.h:1161
int avpriv_ac3_parse_header(AC3HeaderInfo **phdr, const uint8_t *buf, size_t size)
Definition: ac3_parser.c:253
#define SDT_RETRANS_TIME
Definition: mpegtsenc.c:226
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
uint8_t asvc_flag
Definition: mpegts.h:196
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
static int mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
Definition: mpegtsenc.c:431
int64_t last_pcr
Definition: mpegtsenc.c:245
int64_t payload_pts
Definition: mpegtsenc.c:237
uint8_t
Round toward +infinity.
Definition: mathematics.h:83
static int nb_streams
Definition: ffprobe.c:282
#define LAST_OTHER_PID
Definition: mpegts.h:62
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:203
AVOptions.
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
void * opaque
Definition: mpegtsenc.c:52
int64_t pat_period_us
Definition: mpegtsenc.c:112
#define M2TS_AUDIO_START_PID
Definition: mpegts.h:72
#define DEFAULT_PES_PAYLOAD_SIZE
Definition: mpegtsenc.c:122
int id
Format-specific stream ID.
Definition: avformat.h:887
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
#define STREAM_TYPE_VIDEO_HEVC
Definition: mpeg.h:58
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4453
static int mpegts_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
Definition: mpegtsenc.c:2043
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:91
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1307
int64_t duration
Definition: movenc.c:63
#define TS_PACKET_SIZE
Definition: mpegts.h:29
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:211
static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegtsenc.c:1999
Public header for CRC hash function implementation.
static int encode_str8(uint8_t *buf, const char *str)
Definition: mpegtsenc.c:803
int initial_padding
Audio only.
Definition: codec_par.h:189
int omit_video_pes_length
Definition: mpegtsenc.c:117
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
static void mpegts_insert_null_packet(AVFormatContext *s)
Definition: mpegtsenc.c:1197
uint8_t * data
Definition: packet.h:363
uint32_t tag
Definition: movenc.c:1597
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
Definition: format.c:38
uint8_t bitstream_id
Definition: ac3.h:184
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:296
static void mpegts_write_sdt(AVFormatContext *s)
Definition: mpegtsenc.c:761
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int m2ts_video_pid
Definition: mpegtsenc.c:98
#define M2TS_PGSSUB_START_PID
Definition: mpegts.h:73
#define STREAM_ID_AUDIO_STREAM_0
Definition: mpegts.h:142
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:225
#define STREAM_TYPE_VIDEO_VC1
Definition: mpegts.h:132
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
static void extend_af(uint8_t *pkt, int size)
Definition: mpegtsenc.c:1271
unsigned int * stream_index
Definition: avformat.h:1160
#define MPEGTS_FLAG_AAC_LATM
Definition: mpegtsenc.c:105
#define av_log(a,...)
#define PAT_TID
Definition: mpegts.h:79
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
#define STREAM_TYPE_AUDIO_AAC
Definition: mpeg.h:55
MPEGTS stream ID as uint8_t, this is required to pass the stream ID information from the demuxer to t...
Definition: packet.h:215
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
#define STREAM_TYPE_AUDIO_DTS
Definition: mpegts.h:136
static void mpegts_write_pes(AVFormatContext *s, AVStream *st, const uint8_t *payload, int payload_size, int64_t pts, int64_t dts, int key, int stream_id)
Definition: mpegtsenc.c:1291
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1479
AVProgram * program
Definition: mpegtsenc.c:61
static void put16(uint8_t **q_ptr, int val)
Definition: mpegtsenc.c:183
static int mpegts_write_section1(MpegTSSection *s, int tid, int id, int version, int sec_num, int last_sec_num, uint8_t *buf, int len)
Definition: mpegtsenc.c:192
int m2ts_pgssub_pid
Definition: mpegtsenc.c:100
static void write_pts(uint8_t *q, int fourbits, int64_t pts)
Definition: mpegtsenc.c:1240
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
int pes_payload_size
Definition: mpegtsenc.c:87
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
static uint8_t * get_ts_payload_start(uint8_t *pkt)
Definition: mpegtsenc.c:1279
char * url
input or output URL.
Definition: avformat.h:1335
#define ENC
Definition: mpegtsenc.c:2066
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
unsigned int nb_programs
Definition: avformat.h:1418
#define STREAM_TYPE_VIDEO_DIRAC
Definition: mpegts.h:133
static void set_af_flag(uint8_t *pkt, int flag)
Definition: mpegtsenc.c:1255
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:419
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
Definition: mpegtsenc.c:1212
simple assert() macros that are a bit more flexible than ISO C assert().
int nb_services
Definition: mpegtsenc.c:82
Coded AC-3 header values up to the lfeon element, plus derived values.
Definition: ac3.h:177
#define PAT_RETRANS_TIME
Definition: mpegtsenc.c:227
int mux_rate
set to 1 when VBR
Definition: mpegtsenc.c:86
static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
Definition: mpegtsenc.c:1668
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:953
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1156
static int write_pcr_bits(uint8_t *buf, int64_t pcr)
Definition: mpegtsenc.c:1182
#define FFMAX(a, b)
Definition: common.h:94
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:1795
static void select_pcr_streams(AVFormatContext *s)
Definition: mpegtsenc.c:937
#define fail()
Definition: checkasm.h:123
#define MPEGTS_FLAG_SYSTEM_B
Definition: mpegtsenc.c:107
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1295
#define STREAM_TYPE_AUDIO_AAC_LATM
Definition: mpegts.h:126
int ff_check_h264_startcode(AVFormatContext *s, const AVStream *st, const AVPacket *pkt)
Check presence of H264 startcode.
Definition: mpegtsenc.c:1584
static const AVOption options[]
Definition: mpegtsenc.c:2067
#define b
Definition: input.c:41
DVBAC3Descriptor * dvb_ac3_desc
Definition: mpegtsenc.c:251
static struct @322 state
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
Definition: mux.c:505
#define FFMIN(a, b)
Definition: common.h:96
#define STREAM_TYPE_VIDEO_H264
Definition: mpeg.h:57
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
#define FIRST_OTHER_PID
Definition: mpegts.h:61
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:3
const char * name
Definition: avformat.h:500
#define DEFAULT_PROVIDER_NAME
Definition: mpegtsenc.c:222
AVFormatContext * ctx
Definition: movenc.c:48
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
int discontinuity
Definition: mpegtsenc.c:50
int64_t next_pcr
Definition: mpegtsenc.c:85
static int check_hevc_startcode(AVFormatContext *s, const AVStream *st, const AVPacket *pkt)
Definition: mpegtsenc.c:1601
static MpegTSService * mpegts_add_service(AVFormatContext *s, int sid, const AVDictionary *metadata, AVProgram *program)
Definition: mpegtsenc.c:861
#define s(width, name)
Definition: cbs_vp9.c:257
AVOutputFormat ff_mpegts_muxer
Definition: mpegtsenc.c:2131
uint8_t component_type_flag
Definition: mpegts.h:193
int m2ts_audio_pid
Definition: mpegtsenc.c:99
AVFormatContext * amux
Definition: mpegtsenc.c:241
AVDictionary * metadata
Definition: avformat.h:944
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
#define MPEGTS_FLAG_REEMIT_PAT_PMT
Definition: mpegtsenc.c:104
static int get_dvb_stream_type(AVFormatContext *s, AVStream *st)
Definition: mpegtsenc.c:289
int dolby_surround_mode
Definition: ac3.h:194
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
#define STREAM_TYPE_VIDEO_MPEG4
Definition: mpeg.h:56
static void mpegts_deinit(AVFormatContext *s)
Definition: mpegtsenc.c:2017
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1258
int pmt_start_pid
Definition: mpegtsenc.c:95
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1456
int service_type
Definition: mpegtsenc.c:93
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:839
void(* write_packet)(struct MpegTSSection *s, const uint8_t *packet)
Definition: mpegtsenc.c:51
Stream structure.
Definition: avformat.h:880
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int start_pid
Definition: mpegtsenc.c:96
#define FF_PROFILE_KLVA_SYNC
Definition: avcodec.h:1974
#define STREAM_TYPE_METADATA
Definition: mpegts.h:128
#define av_bswap32
Definition: bswap.h:33
int frame_size
Definition: mxfenc.c:2166
#define DVB_PRIVATE_NETWORK_START
Definition: mpegtsenc.c:42
#define STREAM_ID_PRIVATE_STREAM_1
Definition: mpegts.h:141
#define M2TS_TEXTSUB_PID
Definition: mpegts.h:74
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:91
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
#define MPEGTS_FLAG_PAT_PMT_AT_FRAMES
Definition: mpegtsenc.c:106
const AVClass * av_class
Definition: mpegtsenc.c:76
int first_dts_checked
Definition: mpegtsenc.c:84
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:206
#define STREAM_TYPE_PRIVATE_DATA
Definition: mpeg.h:54
Undefined Behavior In the C language
Definition: undefined.txt:3
Describe the class of an AVClass context structure.
Definition: log.h:67
static int opus_get_packet_samples(AVFormatContext *s, AVPacket *pkt)
Definition: mpegtsenc.c:1620
int original_network_id
Definition: mpegtsenc.c:91
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1592
ff_const59 AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c:51
int service_id
Definition: mpegtsenc.c:92
Recommmends skipping the specified number of samples.
Definition: packet.h:156
byte swapping routines
static int mpegts_write_end(AVFormatContext *s)
Definition: mpegtsenc.c:2009
#define STREAM_TYPE_AUDIO_AC3
Definition: mpeg.h:61
#define snprintf
Definition: snprintf.h:34
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4382
uint8_t bsid_flag
Definition: mpegts.h:194
int transport_stream_id
Definition: mpegtsenc.c:90
MpegTSService ** services
Definition: mpegtsenc.c:79
static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
Definition: mpegtsenc.c:855
uint8_t * payload
Definition: mpegtsenc.c:240
AVDictionary * metadata
Definition: avformat.h:1162
static int64_t pts
static void mpegts_write_flush(AVFormatContext *s)
Definition: mpegtsenc.c:1974
#define flags(name, subs,...)
Definition: cbs_av1.c:560
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
int m2ts_mode
Definition: mpegtsenc.c:97
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
int sample_rate
Audio only.
Definition: codec_par.h:170
#define DEFAULT_SERVICE_NAME
Definition: mpegtsenc.c:223
Main libavformat public API header.
#define M2TS_PMT_PID
Definition: mpegts.h:69
#define M2TS_VIDEO_PID
Definition: mpegts.h:71
common internal api header.
int64_t last_pat_ts
Definition: mpegtsenc.c:114
int64_t sdt_period
Definition: mpegtsenc.c:80
#define flag(name)
Definition: cbs_av1.c:552
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:120
static int64_t get_pcr(const MpegTSWrite *ts)
Definition: mpegtsenc.c:835
uint8_t name[256]
Definition: mpegtsenc.c:58
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:933
int pcr_period_ms
Definition: mpegtsenc.c:103
static void putbuf(uint8_t **q_ptr, const uint8_t *buf, size_t len)
Definition: mpegtsenc.c:271
int m2ts_textsub_pid
Definition: mpegtsenc.c:101
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1200
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:931
int den
Denominator.
Definition: rational.h:60
#define STREAM_ID_METADATA_STREAM
Definition: mpegts.h:144
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:465
#define av_free(p)
char * value
Definition: dict.h:87
#define STREAM_ID_EXTENDED_STREAM_ID
Definition: mpegts.h:145
uint8_t asvc
Definition: mpegts.h:201
int len
#define PAT_PID
Definition: mpegts.h:37
#define STREAM_TYPE_VIDEO_MPEG2
Definition: mpeg.h:50
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5502
void * priv_data
Format private data.
Definition: avformat.h:1267
int first_timestamp_checked
first pts/dts check needed
Definition: mpegtsenc.c:235
MpegTSSection pat
Definition: mpegtsenc.c:77
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:466
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1075
static void mpegts_write_pat(AVFormatContext *s)
Definition: mpegtsenc.c:254
int64_t pat_period
Definition: mpegtsenc.c:81
MpegTSSection sdt
Definition: mpegtsenc.c:78
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
uint8_t mainid_flag
Definition: mpegts.h:195
int channels
Audio only.
Definition: codec_par.h:166
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
int64_t pcr_period
Definition: mpegtsenc.c:244
static const AVClass mpegts_muxer_class
Definition: mpegtsenc.c:2124
#define av_freep(p)
static int get_m2ts_stream_type(AVFormatContext *s, AVStream *st)
Definition: mpegtsenc.c:380
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
int opus_pending_trim_start
Definition: mpegtsenc.c:249
uint8_t channel_mode
Definition: ac3.h:186
int stream_index
Definition: packet.h:365
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:909
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
#define MKTAG(a, b, c, d)
Definition: common.h:405
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2071
#define STREAM_TYPE_AUDIO_MPEG1
Definition: mpeg.h:51
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len)
Definition: mpegtsenc.c:129
#define REGISTRATION_DESCRIPTOR
Definition: mpegts.h:149
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define STREAM_TYPE_AUDIO_TRUEHD
Definition: mpegts.h:137
AVProgram ** programs
Definition: avformat.h:1419
#define SDT_TID
Definition: mpegts.h:87
int tables_version
Definition: mpegtsenc.c:111
const char * name
Definition: opengl_enc.c:102