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