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