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