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