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