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