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 = av_packet_alloc();
1144  if (!ts->pkt)
1145  return AVERROR(ENOMEM);
1146 
1147  /* assign pids to each stream */
1148  for (i = 0; i < s->nb_streams; i++) {
1149  AVStream *st = s->streams[i];
1150  MpegTSWriteStream *ts_st;
1151 
1152  ts_st = av_mallocz(sizeof(MpegTSWriteStream));
1153  if (!ts_st) {
1154  return AVERROR(ENOMEM);
1155  }
1156  st->priv_data = ts_st;
1157 
1158  avpriv_set_pts_info(st, 33, 1, 90000);
1159 
1160  ts_st->payload = av_mallocz(ts->pes_payload_size);
1161  if (!ts_st->payload) {
1162  return AVERROR(ENOMEM);
1163  }
1164 
1165  /* MPEG pid values < 16 are reserved. Applications which set st->id in
1166  * this range are assigned a calculated pid. */
1167  if (st->id < 16) {
1168  if (ts->m2ts_mode) {
1169  switch (st->codecpar->codec_type) {
1170  case AVMEDIA_TYPE_VIDEO:
1171  ts_st->pid = ts->m2ts_video_pid++;
1172  break;
1173  case AVMEDIA_TYPE_AUDIO:
1174  ts_st->pid = ts->m2ts_audio_pid++;
1175  break;
1176  case AVMEDIA_TYPE_SUBTITLE:
1177  switch (st->codecpar->codec_id) {
1179  ts_st->pid = ts->m2ts_pgssub_pid++;
1180  break;
1182  ts_st->pid = ts->m2ts_textsub_pid++;
1183  break;
1184  }
1185  break;
1186  }
1187  if (ts->m2ts_video_pid > M2TS_VIDEO_PID + 1 ||
1188  ts->m2ts_audio_pid > M2TS_AUDIO_START_PID + 32 ||
1190  ts->m2ts_textsub_pid > M2TS_TEXTSUB_PID + 1 ||
1191  ts_st->pid < 16) {
1192  av_log(s, AV_LOG_ERROR, "Cannot automatically assign PID for stream %d\n", st->index);
1193  return AVERROR(EINVAL);
1194  }
1195  } else {
1196  ts_st->pid = ts->start_pid + i;
1197  }
1198  } else {
1199  ts_st->pid = st->id;
1200  }
1201  if (ts_st->pid >= 0x1FFF) {
1203  "Invalid stream id %d, must be less than 8191\n", st->id);
1204  return AVERROR(EINVAL);
1205  }
1206  for (j = 0; j < ts->nb_services; j++) {
1207  if (ts->services[j]->pmt.pid > LAST_OTHER_PID) {
1209  "Invalid PMT PID %d, must be less than %d\n", ts->services[j]->pmt.pid, LAST_OTHER_PID + 1);
1210  return AVERROR(EINVAL);
1211  }
1212  if (ts_st->pid == ts->services[j]->pmt.pid) {
1213  av_log(s, AV_LOG_ERROR, "PID %d cannot be both elementary and PMT PID\n", ts_st->pid);
1214  return AVERROR(EINVAL);
1215  }
1216  }
1217  for (j = 0; j < i; j++) {
1218  MpegTSWriteStream *ts_st_prev = s->streams[j]->priv_data;
1219  if (ts_st_prev->pid == ts_st->pid) {
1220  av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
1221  return AVERROR(EINVAL);
1222  }
1223  }
1224  ts_st->payload_pts = AV_NOPTS_VALUE;
1225  ts_st->payload_dts = AV_NOPTS_VALUE;
1226  ts_st->cc = 15;
1227  ts_st->discontinuity = ts->flags & MPEGTS_FLAG_DISCONT;
1228  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
1229  st->codecpar->extradata_size > 0) {
1230  AVStream *ast;
1231  ts_st->amux = avformat_alloc_context();
1232  if (!ts_st->amux) {
1233  return AVERROR(ENOMEM);
1234  }
1235  ts_st->amux->oformat =
1236  av_guess_format((ts->flags & MPEGTS_FLAG_AAC_LATM) ? "latm" : "adts",
1237  NULL, NULL);
1238  if (!ts_st->amux->oformat) {
1239  return AVERROR(EINVAL);
1240  }
1241  if (!(ast = avformat_new_stream(ts_st->amux, NULL))) {
1242  return AVERROR(ENOMEM);
1243  }
1245  if (ret != 0)
1246  return ret;
1247  ast->time_base = st->time_base;
1248  ret = avformat_write_header(ts_st->amux, NULL);
1249  if (ret < 0)
1250  return ret;
1251  }
1252  if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
1254  }
1255  }
1256 
1257  if (ts->copyts < 1)
1258  ts->first_pcr = av_rescale(s->max_delay, PCR_TIME_BASE, AV_TIME_BASE);
1259 
1261 
1268 
1269  /* assign provider name */
1270  provider = av_dict_get(s->metadata, "service_provider", NULL, 0);
1271  provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME;
1272  if (encode_str8(ts->provider_name, provider_name) < 0) {
1273  av_log(s, AV_LOG_ERROR, "Too long provider name\n");
1274  return AVERROR(EINVAL);
1275  }
1276 
1277  if (ts->mux_rate == 1)
1278  av_log(s, AV_LOG_VERBOSE, "muxrate VBR, ");
1279  else
1280  av_log(s, AV_LOG_VERBOSE, "muxrate %d, ", ts->mux_rate);
1282  "sdt every %"PRId64" ms, pat/pmt every %"PRId64" ms",
1283  av_rescale(ts->sdt_period, 1000, PCR_TIME_BASE),
1284  av_rescale(ts->pat_period, 1000, PCR_TIME_BASE));
1285  if (ts->flags & MPEGTS_FLAG_NIT)
1286  av_log(s, AV_LOG_VERBOSE, ", nit every %"PRId64" ms", av_rescale(ts->nit_period, 1000, PCR_TIME_BASE));
1287  av_log(s, AV_LOG_VERBOSE, "\n");
1288 
1289  return 0;
1290 }
1291 
1292 /* send SDT, NIT, PAT and PMT tables regularly */
1293 static void retransmit_si_info(AVFormatContext *s, int force_pat, int force_sdt, int force_nit, int64_t pcr)
1294 {
1295  MpegTSWrite *ts = s->priv_data;
1296  int i;
1297 
1298  if ((pcr != AV_NOPTS_VALUE && ts->last_sdt_ts == AV_NOPTS_VALUE) ||
1299  (pcr != AV_NOPTS_VALUE && pcr - ts->last_sdt_ts >= ts->sdt_period) ||
1300  force_sdt
1301  ) {
1302  if (pcr != AV_NOPTS_VALUE)
1303  ts->last_sdt_ts = FFMAX(pcr, ts->last_sdt_ts);
1305  }
1306  if ((pcr != AV_NOPTS_VALUE && ts->last_pat_ts == AV_NOPTS_VALUE) ||
1307  (pcr != AV_NOPTS_VALUE && pcr - ts->last_pat_ts >= ts->pat_period) ||
1308  force_pat) {
1309  if (pcr != AV_NOPTS_VALUE)
1310  ts->last_pat_ts = FFMAX(pcr, ts->last_pat_ts);
1312  for (i = 0; i < ts->nb_services; i++)
1313  mpegts_write_pmt(s, ts->services[i]);
1314  }
1315  if ((pcr != AV_NOPTS_VALUE && ts->last_nit_ts == AV_NOPTS_VALUE) ||
1316  (pcr != AV_NOPTS_VALUE && pcr - ts->last_nit_ts >= ts->nit_period) ||
1317  force_nit
1318  ) {
1319  if (pcr != AV_NOPTS_VALUE)
1320  ts->last_nit_ts = FFMAX(pcr, ts->last_nit_ts);
1321  if (ts->flags & MPEGTS_FLAG_NIT)
1323  }
1324 }
1325 
1326 static int write_pcr_bits(uint8_t *buf, int64_t pcr)
1327 {
1328  int64_t pcr_low = pcr % 300, pcr_high = pcr / 300;
1329 
1330  *buf++ = pcr_high >> 25;
1331  *buf++ = pcr_high >> 17;
1332  *buf++ = pcr_high >> 9;
1333  *buf++ = pcr_high >> 1;
1334  *buf++ = pcr_high << 7 | pcr_low >> 8 | 0x7e;
1335  *buf++ = pcr_low;
1336 
1337  return 6;
1338 }
1339 
1340 /* Write a single null transport stream packet */
1342 {
1343  uint8_t *q;
1344  uint8_t buf[TS_PACKET_SIZE];
1345 
1346  q = buf;
1347  *q++ = 0x47;
1348  *q++ = 0x00 | 0x1f;
1349  *q++ = 0xff;
1350  *q++ = 0x10;
1351  memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
1352  write_packet(s, buf);
1353 }
1354 
1355 /* Write a single transport stream packet with a PCR and no payload */
1357 {
1358  MpegTSWrite *ts = s->priv_data;
1359  MpegTSWriteStream *ts_st = st->priv_data;
1360  uint8_t *q;
1361  uint8_t buf[TS_PACKET_SIZE];
1362 
1363  q = buf;
1364  *q++ = 0x47;
1365  *q++ = ts_st->pid >> 8;
1366  *q++ = ts_st->pid;
1367  *q++ = 0x20 | ts_st->cc; /* Adaptation only */
1368  /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
1369  *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */
1370  *q++ = 0x10; /* Adaptation flags: PCR present */
1371  if (ts_st->discontinuity) {
1372  q[-1] |= 0x80;
1373  ts_st->discontinuity = 0;
1374  }
1375 
1376  /* PCR coded into 6 bytes */
1377  q += write_pcr_bits(q, get_pcr(ts));
1378 
1379  /* stuffing bytes */
1380  memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
1381  write_packet(s, buf);
1382 }
1383 
1384 static void write_pts(uint8_t *q, int fourbits, int64_t pts)
1385 {
1386  int val;
1387 
1388  val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1;
1389  *q++ = val;
1390  val = (((pts >> 15) & 0x7fff) << 1) | 1;
1391  *q++ = val >> 8;
1392  *q++ = val;
1393  val = (((pts) & 0x7fff) << 1) | 1;
1394  *q++ = val >> 8;
1395  *q++ = val;
1396 }
1397 
1398 /* Set an adaptation field flag in an MPEG-TS packet*/
1399 static void set_af_flag(uint8_t *pkt, int flag)
1400 {
1401  // expect at least one flag to set
1402  av_assert0(flag);
1403 
1404  if ((pkt[3] & 0x20) == 0) {
1405  // no AF yet, set adaptation field flag
1406  pkt[3] |= 0x20;
1407  // 1 byte length, no flags
1408  pkt[4] = 1;
1409  pkt[5] = 0;
1410  }
1411  pkt[5] |= flag;
1412 }
1413 
1414 /* Extend the adaptation field by size bytes */
1415 static void extend_af(uint8_t *pkt, int size)
1416 {
1417  // expect already existing adaptation field
1418  av_assert0(pkt[3] & 0x20);
1419  pkt[4] += size;
1420 }
1421 
1422 /* Get a pointer to MPEG-TS payload (right after TS packet header) */
1423 static uint8_t *get_ts_payload_start(uint8_t *pkt)
1424 {
1425  if (pkt[3] & 0x20)
1426  return pkt + 5 + pkt[4];
1427  else
1428  return pkt + 4;
1429 }
1430 
1431 static int get_pes_stream_id(AVFormatContext *s, AVStream *st, int stream_id, int *async)
1432 {
1433  MpegTSWrite *ts = s->priv_data;
1434  *async = 0;
1435  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1436  if (st->codecpar->codec_id == AV_CODEC_ID_DIRAC)
1438  else
1439  return STREAM_ID_VIDEO_STREAM_0;
1440  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1441  (st->codecpar->codec_id == AV_CODEC_ID_MP2 ||
1442  st->codecpar->codec_id == AV_CODEC_ID_MP3 ||
1443  st->codecpar->codec_id == AV_CODEC_ID_AAC)) {
1444  return STREAM_ID_AUDIO_STREAM_0;
1445  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1446  st->codecpar->codec_id == AV_CODEC_ID_AC3 &&
1447  ts->m2ts_mode) {
1449  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA &&
1452  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
1453  if (stream_id == STREAM_ID_PRIVATE_STREAM_1) /* asynchronous KLV */
1454  *async = 1;
1455  return stream_id != -1 ? stream_id : STREAM_ID_METADATA_STREAM;
1456  } else {
1458  }
1459 }
1460 
1461 /* Add a PES header to the front of the payload, and segment into an integer
1462  * number of TS packets. The final TS packet is padded using an oversized
1463  * adaptation header to exactly fill the last TS packet.
1464  * NOTE: 'payload' contains a complete PES payload. */
1466  const uint8_t *payload, int payload_size,
1467  int64_t pts, int64_t dts, int key, int stream_id)
1468 {
1469  MpegTSWriteStream *ts_st = st->priv_data;
1470  MpegTSWrite *ts = s->priv_data;
1471  uint8_t buf[TS_PACKET_SIZE];
1472  uint8_t *q;
1473  int val, is_start, len, header_len, write_pcr, flags;
1474  int afc_len, stuffing_len;
1475  int is_dvb_subtitle = (st->codecpar->codec_id == AV_CODEC_ID_DVB_SUBTITLE);
1476  int is_dvb_teletext = (st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT);
1477  int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
1478  int force_pat = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && key && !ts_st->prev_payload_key;
1479  int force_sdt = 0;
1480  int force_nit = 0;
1481 
1482  av_assert0(ts_st->payload != buf || st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO);
1484  force_pat = 1;
1485  }
1486 
1487  if (ts->flags & MPEGTS_FLAG_REEMIT_PAT_PMT) {
1488  force_pat = 1;
1489  force_sdt = 1;
1490  force_nit = 1;
1492  }
1493 
1494  is_start = 1;
1495  while (payload_size > 0) {
1496  int64_t pcr = AV_NOPTS_VALUE;
1497  if (ts->mux_rate > 1)
1498  pcr = get_pcr(ts);
1499  else if (dts != AV_NOPTS_VALUE)
1500  pcr = (dts - delay) * 300;
1501 
1502  retransmit_si_info(s, force_pat, force_sdt, force_nit, pcr);
1503  force_pat = 0;
1504  force_sdt = 0;
1505  force_nit = 0;
1506 
1507  write_pcr = 0;
1508  if (ts->mux_rate > 1) {
1509  /* Send PCR packets for all PCR streams if needed */
1510  pcr = get_pcr(ts);
1511  if (pcr >= ts->next_pcr) {
1512  int64_t next_pcr = INT64_MAX;
1513  for (int i = 0; i < s->nb_streams; i++) {
1514  /* Make the current stream the last, because for that we
1515  * can insert the pcr into the payload later */
1516  int st2_index = i < st->index ? i : (i + 1 == s->nb_streams ? st->index : i + 1);
1517  AVStream *st2 = s->streams[st2_index];
1518  MpegTSWriteStream *ts_st2 = st2->priv_data;
1519  if (ts_st2->pcr_period) {
1520  if (pcr - ts_st2->last_pcr >= ts_st2->pcr_period) {
1521  ts_st2->last_pcr = FFMAX(pcr - ts_st2->pcr_period, ts_st2->last_pcr + ts_st2->pcr_period);
1522  if (st2 != st) {
1523  mpegts_insert_pcr_only(s, st2);
1524  pcr = get_pcr(ts);
1525  } else {
1526  write_pcr = 1;
1527  }
1528  }
1529  next_pcr = FFMIN(next_pcr, ts_st2->last_pcr + ts_st2->pcr_period);
1530  }
1531  }
1532  ts->next_pcr = next_pcr;
1533  }
1534  if (dts != AV_NOPTS_VALUE && (dts - pcr / 300) > delay) {
1535  /* pcr insert gets priority over null packet insert */
1536  if (write_pcr)
1538  else
1540  /* recalculate write_pcr and possibly retransmit si_info */
1541  continue;
1542  }
1543  } else if (ts_st->pcr_period && pcr != AV_NOPTS_VALUE) {
1544  if (pcr - ts_st->last_pcr >= ts_st->pcr_period && is_start) {
1545  ts_st->last_pcr = FFMAX(pcr - ts_st->pcr_period, ts_st->last_pcr + ts_st->pcr_period);
1546  write_pcr = 1;
1547  }
1548  }
1549 
1550  /* prepare packet header */
1551  q = buf;
1552  *q++ = 0x47;
1553  val = ts_st->pid >> 8;
1554  if (ts->m2ts_mode && st->codecpar->codec_id == AV_CODEC_ID_AC3)
1555  val |= 0x20;
1556  if (is_start)
1557  val |= 0x40;
1558  *q++ = val;
1559  *q++ = ts_st->pid;
1560  ts_st->cc = ts_st->cc + 1 & 0xf;
1561  *q++ = 0x10 | ts_st->cc; // payload indicator + CC
1562  if (ts_st->discontinuity) {
1563  set_af_flag(buf, 0x80);
1564  q = get_ts_payload_start(buf);
1565  ts_st->discontinuity = 0;
1566  }
1567  if (key && is_start && pts != AV_NOPTS_VALUE) {
1568  // set Random Access for key frames
1569  if (ts_st->pcr_period)
1570  write_pcr = 1;
1571  set_af_flag(buf, 0x40);
1572  q = get_ts_payload_start(buf);
1573  }
1574  if (write_pcr) {
1575  set_af_flag(buf, 0x10);
1576  q = get_ts_payload_start(buf);
1577  // add 11, pcr references the last byte of program clock reference base
1578  if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
1579  av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
1580  extend_af(buf, write_pcr_bits(q, pcr));
1581  q = get_ts_payload_start(buf);
1582  }
1583  if (is_start) {
1584  int pes_extension = 0;
1585  int pes_header_stuffing_bytes = 0;
1586  int async;
1587  /* write PES header */
1588  *q++ = 0x00;
1589  *q++ = 0x00;
1590  *q++ = 0x01;
1591  *q++ = stream_id = get_pes_stream_id(s, st, stream_id, &async);
1592  if (async)
1593  pts = dts = AV_NOPTS_VALUE;
1594 
1595  header_len = 0;
1596 
1597  if (stream_id != STREAM_ID_PROGRAM_STREAM_MAP &&
1598  stream_id != STREAM_ID_PADDING_STREAM &&
1599  stream_id != STREAM_ID_PRIVATE_STREAM_2 &&
1600  stream_id != STREAM_ID_ECM_STREAM &&
1601  stream_id != STREAM_ID_EMM_STREAM &&
1602  stream_id != STREAM_ID_PROGRAM_STREAM_DIRECTORY &&
1603  stream_id != STREAM_ID_DSMCC_STREAM &&
1604  stream_id != STREAM_ID_TYPE_E_STREAM) {
1605 
1606  flags = 0;
1607  if (pts != AV_NOPTS_VALUE) {
1608  header_len += 5;
1609  flags |= 0x80;
1610  }
1611  if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1612  header_len += 5;
1613  flags |= 0x40;
1614  }
1615  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1617  /* set PES_extension_flag */
1618  pes_extension = 1;
1619  flags |= 0x01;
1620 
1621  /* One byte for PES2 extension flag +
1622  * one byte for extension length +
1623  * one byte for extension id */
1624  header_len += 3;
1625  }
1626  /* for Blu-ray AC3 Audio the PES Extension flag should be as follow
1627  * otherwise it will not play sound on blu-ray
1628  */
1629  if (ts->m2ts_mode &&
1631  st->codecpar->codec_id == AV_CODEC_ID_AC3) {
1632  /* set PES_extension_flag */
1633  pes_extension = 1;
1634  flags |= 0x01;
1635  header_len += 3;
1636  }
1637  if (is_dvb_teletext) {
1638  pes_header_stuffing_bytes = 0x24 - header_len;
1639  header_len = 0x24;
1640  }
1641  len = payload_size + header_len + 3;
1642  /* 3 extra bytes should be added to DVB subtitle payload: 0x20 0x00 at the beginning and trailing 0xff */
1643  if (is_dvb_subtitle) {
1644  len += 3;
1645  payload_size++;
1646  }
1647  if (len > 0xffff)
1648  len = 0;
1650  len = 0;
1651  }
1652  *q++ = len >> 8;
1653  *q++ = len;
1654  val = 0x80;
1655  /* data alignment indicator is required for subtitle and data streams */
1657  val |= 0x04;
1658  *q++ = val;
1659  *q++ = flags;
1660  *q++ = header_len;
1661  if (pts != AV_NOPTS_VALUE) {
1662  write_pts(q, flags >> 6, pts);
1663  q += 5;
1664  }
1665  if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1666  write_pts(q, 1, dts);
1667  q += 5;
1668  }
1669  if (pes_extension && st->codecpar->codec_id == AV_CODEC_ID_DIRAC) {
1670  flags = 0x01; /* set PES_extension_flag_2 */
1671  *q++ = flags;
1672  *q++ = 0x80 | 0x01; /* marker bit + extension length */
1673  /* Set the stream ID extension flag bit to 0 and
1674  * write the extended stream ID. */
1675  *q++ = 0x00 | 0x60;
1676  }
1677  /* For Blu-ray AC3 Audio Setting extended flags */
1678  if (ts->m2ts_mode &&
1679  pes_extension &&
1680  st->codecpar->codec_id == AV_CODEC_ID_AC3) {
1681  flags = 0x01; /* set PES_extension_flag_2 */
1682  *q++ = flags;
1683  *q++ = 0x80 | 0x01; /* marker bit + extension length */
1684  *q++ = 0x00 | 0x71; /* for AC3 Audio (specifically on blue-rays) */
1685  }
1686 
1687 
1688  if (is_dvb_subtitle) {
1689  /* First two fields of DVB subtitles PES data:
1690  * data_identifier: for DVB subtitle streams shall be coded with the value 0x20
1691  * subtitle_stream_id: for DVB subtitle stream shall be identified by the value 0x00 */
1692  *q++ = 0x20;
1693  *q++ = 0x00;
1694  }
1695  if (is_dvb_teletext) {
1696  memset(q, 0xff, pes_header_stuffing_bytes);
1697  q += pes_header_stuffing_bytes;
1698  }
1699  } else {
1700  len = payload_size;
1701  *q++ = len >> 8;
1702  *q++ = len;
1703  }
1704  is_start = 0;
1705  }
1706  /* header size */
1707  header_len = q - buf;
1708  /* data len */
1709  len = TS_PACKET_SIZE - header_len;
1710  if (len > payload_size)
1711  len = payload_size;
1712  stuffing_len = TS_PACKET_SIZE - header_len - len;
1713  if (stuffing_len > 0) {
1714  /* add stuffing with AFC */
1715  if (buf[3] & 0x20) {
1716  /* stuffing already present: increase its size */
1717  afc_len = buf[4] + 1;
1718  memmove(buf + 4 + afc_len + stuffing_len,
1719  buf + 4 + afc_len,
1720  header_len - (4 + afc_len));
1721  buf[4] += stuffing_len;
1722  memset(buf + 4 + afc_len, 0xff, stuffing_len);
1723  } else {
1724  /* add stuffing */
1725  memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4);
1726  buf[3] |= 0x20;
1727  buf[4] = stuffing_len - 1;
1728  if (stuffing_len >= 2) {
1729  buf[5] = 0x00;
1730  memset(buf + 6, 0xff, stuffing_len - 2);
1731  }
1732  }
1733  }
1734 
1735  if (is_dvb_subtitle && payload_size == len) {
1736  memcpy(buf + TS_PACKET_SIZE - len, payload, len - 1);
1737  buf[TS_PACKET_SIZE - 1] = 0xff; /* end_of_PES_data_field_marker: an 8-bit field with fixed contents 0xff for DVB subtitle */
1738  } else {
1739  memcpy(buf + TS_PACKET_SIZE - len, payload, len);
1740  }
1741 
1742  payload += len;
1743  payload_size -= len;
1744  write_packet(s, buf);
1745  }
1746  ts_st->prev_payload_key = key;
1747 }
1748 
1750 {
1751  if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001 && AV_RB24(pkt->data) != 0x000001) {
1752  if (!st->nb_frames) {
1753  av_log(s, AV_LOG_ERROR, "H.264 bitstream malformed, "
1754  "no startcode found, use the video bitstream filter 'h264_mp4toannexb' to fix it "
1755  "('-bsf:v h264_mp4toannexb' option with ffmpeg)\n");
1756  return AVERROR_INVALIDDATA;
1757  }
1758  av_log(s, AV_LOG_WARNING, "H.264 bitstream error, startcode missing, size %d", pkt->size);
1759  if (pkt->size)
1760  av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
1761  av_log(s, AV_LOG_WARNING, "\n");
1762  }
1763  return 0;
1764 }
1765 
1767 {
1768  if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001 && AV_RB24(pkt->data) != 0x000001) {
1769  if (!st->nb_frames) {
1770  av_log(s, AV_LOG_ERROR, "HEVC bitstream malformed, no startcode found\n");
1771  return AVERROR_PATCHWELCOME;
1772  }
1773  av_log(s, AV_LOG_WARNING, "HEVC bitstream error, startcode missing, size %d", pkt->size);
1774  if (pkt->size)
1775  av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
1776  av_log(s, AV_LOG_WARNING, "\n");
1777  }
1778  return 0;
1779 }
1780 
1781 /* Based on GStreamer's gst-plugins-base/ext/ogg/gstoggstream.c
1782  * Released under the LGPL v2.1+, written by
1783  * Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
1784  */
1786 {
1787  static const int durations[32] = {
1788  480, 960, 1920, 2880, /* Silk NB */
1789  480, 960, 1920, 2880, /* Silk MB */
1790  480, 960, 1920, 2880, /* Silk WB */
1791  480, 960, /* Hybrid SWB */
1792  480, 960, /* Hybrid FB */
1793  120, 240, 480, 960, /* CELT NB */
1794  120, 240, 480, 960, /* CELT NB */
1795  120, 240, 480, 960, /* CELT NB */
1796  120, 240, 480, 960, /* CELT NB */
1797  };
1798  int toc, frame_duration, nframes, duration;
1799 
1800  if (pkt->size < 1)
1801  return 0;
1802 
1803  toc = pkt->data[0];
1804 
1805  frame_duration = durations[toc >> 3];
1806  switch (toc & 3) {
1807  case 0:
1808  nframes = 1;
1809  break;
1810  case 1:
1811  nframes = 2;
1812  break;
1813  case 2:
1814  nframes = 2;
1815  break;
1816  case 3:
1817  if (pkt->size < 2)
1818  return 0;
1819  nframes = pkt->data[1] & 63;
1820  break;
1821  }
1822 
1823  duration = nframes * frame_duration;
1824  if (duration > 5760) {
1826  "Opus packet duration > 120 ms, invalid");
1827  return 0;
1828  }
1829 
1830  return duration;
1831 }
1832 
1834 {
1835  AVStream *st = s->streams[pkt->stream_index];
1836  int size = pkt->size;
1837  uint8_t *buf = pkt->data;
1838  uint8_t *data = NULL;
1839  MpegTSWrite *ts = s->priv_data;
1840  MpegTSWriteStream *ts_st = st->priv_data;
1841  const int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) * 2;
1842  const int64_t max_audio_delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) / 2;
1843  int64_t dts = pkt->dts, pts = pkt->pts;
1844  int opus_samples = 0;
1845  size_t side_data_size;
1846  uint8_t *side_data = NULL;
1847  int stream_id = -1;
1848 
1849  side_data = av_packet_get_side_data(pkt,
1851  &side_data_size);
1852  if (side_data)
1853  stream_id = side_data[0];
1854 
1855  if (ts->copyts < 1) {
1856  if (!ts->first_dts_checked && dts != AV_NOPTS_VALUE) {
1857  ts->first_pcr += dts * 300;
1858  ts->first_dts_checked = 1;
1859  }
1860 
1861  if (pts != AV_NOPTS_VALUE)
1862  pts += delay;
1863  if (dts != AV_NOPTS_VALUE)
1864  dts += delay;
1865  }
1866 
1867  if (!ts_st->first_timestamp_checked && (pts == AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)) {
1868  av_log(s, AV_LOG_ERROR, "first pts and dts value must be set\n");
1869  return AVERROR_INVALIDDATA;
1870  }
1871  ts_st->first_timestamp_checked = 1;
1872 
1873  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
1874  const uint8_t *p = buf, *buf_end = p + size;
1875  uint32_t state = -1;
1876  int extradd = (pkt->flags & AV_PKT_FLAG_KEY) ? st->codecpar->extradata_size : 0;
1877  int ret = ff_check_h264_startcode(s, st, pkt);
1878  if (ret < 0)
1879  return ret;
1880 
1881  if (extradd && AV_RB24(st->codecpar->extradata) > 1)
1882  extradd = 0;
1883 
1884  do {
1885  p = avpriv_find_start_code(p, buf_end, &state);
1886  av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", state & 0x1f);
1887  if ((state & 0x1f) == 7)
1888  extradd = 0;
1889  } while (p < buf_end && (state & 0x1f) != 9 &&
1890  (state & 0x1f) != 5 && (state & 0x1f) != 1);
1891 
1892  if ((state & 0x1f) != 5)
1893  extradd = 0;
1894  if ((state & 0x1f) != 9) { // AUD NAL
1895  data = av_malloc(pkt->size + 6 + extradd);
1896  if (!data)
1897  return AVERROR(ENOMEM);
1898  memcpy(data + 6, st->codecpar->extradata, extradd);
1899  memcpy(data + 6 + extradd, pkt->data, pkt->size);
1900  AV_WB32(data, 0x00000001);
1901  data[4] = 0x09;
1902  data[5] = 0xf0; // any slice type (0xe) + rbsp stop one bit
1903  buf = data;
1904  size = pkt->size + 6 + extradd;
1905  }
1906  } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1907  if (pkt->size < 2) {
1908  av_log(s, AV_LOG_ERROR, "AAC packet too short\n");
1909  return AVERROR_INVALIDDATA;
1910  }
1911  if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) {
1912  int ret;
1913  AVPacket *pkt2 = ts->pkt;
1914 
1915  if (!ts_st->amux) {
1916  av_log(s, AV_LOG_ERROR, "AAC bitstream not in ADTS format "
1917  "and extradata missing\n");
1918  } else {
1919  av_packet_unref(pkt2);
1920  pkt2->data = pkt->data;
1921  pkt2->size = pkt->size;
1923  pkt2->dts = av_rescale_q(pkt->dts, st->time_base, ts_st->amux->streams[0]->time_base);
1924 
1925  ret = avio_open_dyn_buf(&ts_st->amux->pb);
1926  if (ret < 0)
1927  return ret;
1928 
1929  ret = av_write_frame(ts_st->amux, pkt2);
1930  if (ret < 0) {
1931  ffio_free_dyn_buf(&ts_st->amux->pb);
1932  return ret;
1933  }
1934  size = avio_close_dyn_buf(ts_st->amux->pb, &data);
1935  ts_st->amux->pb = NULL;
1936  buf = data;
1937  }
1938  }
1939  } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
1940  const uint8_t *p = buf, *buf_end = p + size;
1941  uint32_t state = -1;
1942  int extradd = (pkt->flags & AV_PKT_FLAG_KEY) ? st->codecpar->extradata_size : 0;
1943  int ret = check_hevc_startcode(s, st, pkt);
1944  if (ret < 0)
1945  return ret;
1946 
1947  if (extradd && AV_RB24(st->codecpar->extradata) > 1)
1948  extradd = 0;
1949 
1950  do {
1951  p = avpriv_find_start_code(p, buf_end, &state);
1952  av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", (state & 0x7e)>>1);
1953  if ((state & 0x7e) == 2*32)
1954  extradd = 0;
1955  } while (p < buf_end && (state & 0x7e) != 2*35 &&
1956  (state & 0x7e) >= 2*32);
1957 
1958  if ((state & 0x7e) < 2*16 || (state & 0x7e) >= 2*24)
1959  extradd = 0;
1960  if ((state & 0x7e) != 2*35) { // AUD NAL
1961  data = av_malloc(pkt->size + 7 + extradd);
1962  if (!data)
1963  return AVERROR(ENOMEM);
1964  memcpy(data + 7, st->codecpar->extradata, extradd);
1965  memcpy(data + 7 + extradd, pkt->data, pkt->size);
1966  AV_WB32(data, 0x00000001);
1967  data[4] = 2*35;
1968  data[5] = 1;
1969  data[6] = 0x50; // any slice type (0x4) + rbsp stop one bit
1970  buf = data;
1971  size = pkt->size + 7 + extradd;
1972  }
1973  } else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
1974  if (pkt->size < 2) {
1975  av_log(s, AV_LOG_ERROR, "Opus packet too short\n");
1976  return AVERROR_INVALIDDATA;
1977  }
1978 
1979  /* Add Opus control header */
1980  if ((AV_RB16(pkt->data) >> 5) != 0x3ff) {
1981  uint8_t *side_data;
1982  size_t side_data_size;
1983  int i, n;
1984  int ctrl_header_size;
1985  int trim_start = 0, trim_end = 0;
1986 
1987  opus_samples = opus_get_packet_samples(s, pkt);
1988 
1989  side_data = av_packet_get_side_data(pkt,
1991  &side_data_size);
1992 
1993  if (side_data && side_data_size >= 10) {
1994  trim_end = AV_RL32(side_data + 4) * 48000 / st->codecpar->sample_rate;
1995  }
1996 
1997  ctrl_header_size = pkt->size + 2 + pkt->size / 255 + 1;
1998  if (ts_st->opus_pending_trim_start)
1999  ctrl_header_size += 2;
2000  if (trim_end)
2001  ctrl_header_size += 2;
2002 
2003  data = av_malloc(ctrl_header_size);
2004  if (!data)
2005  return AVERROR(ENOMEM);
2006 
2007  data[0] = 0x7f;
2008  data[1] = 0xe0;
2009  if (ts_st->opus_pending_trim_start)
2010  data[1] |= 0x10;
2011  if (trim_end)
2012  data[1] |= 0x08;
2013 
2014  n = pkt->size;
2015  i = 2;
2016  do {
2017  data[i] = FFMIN(n, 255);
2018  n -= 255;
2019  i++;
2020  } while (n >= 0);
2021 
2022  av_assert0(2 + pkt->size / 255 + 1 == i);
2023 
2024  if (ts_st->opus_pending_trim_start) {
2025  trim_start = FFMIN(ts_st->opus_pending_trim_start, opus_samples);
2026  AV_WB16(data + i, trim_start);
2027  i += 2;
2028  ts_st->opus_pending_trim_start -= trim_start;
2029  }
2030  if (trim_end) {
2031  trim_end = FFMIN(trim_end, opus_samples - trim_start);
2032  AV_WB16(data + i, trim_end);
2033  i += 2;
2034  }
2035 
2036  memcpy(data + i, pkt->data, pkt->size);
2037  buf = data;
2038  size = ctrl_header_size;
2039  } else {
2040  /* TODO: Can we get TS formatted data here? If so we will
2041  * need to count the samples of that too! */
2042  av_log(s, AV_LOG_WARNING, "Got MPEG-TS formatted Opus data, unhandled");
2043  }
2044  } else if (st->codecpar->codec_id == AV_CODEC_ID_AC3 && !ts_st->dvb_ac3_desc) {
2045  AC3HeaderInfo *hdr = NULL;
2046 
2047  if (avpriv_ac3_parse_header(&hdr, pkt->data, pkt->size) >= 0) {
2048  uint8_t number_of_channels_flag;
2049  uint8_t service_type_flag;
2050  uint8_t full_service_flag = 1;
2051  DVBAC3Descriptor *dvb_ac3_desc;
2052 
2053  dvb_ac3_desc = av_mallocz(sizeof(*dvb_ac3_desc));
2054  if (!dvb_ac3_desc) {
2055  av_free(hdr);
2056  return AVERROR(ENOMEM);
2057  }
2058 
2059  service_type_flag = hdr->bitstream_mode;
2060  switch (hdr->channel_mode) {
2061  case AC3_CHMODE_DUALMONO:
2062  number_of_channels_flag = 1;
2063  break;
2064  case AC3_CHMODE_MONO:
2065  number_of_channels_flag = 0;
2066  break;
2067  case AC3_CHMODE_STEREO:
2068  if (hdr->dolby_surround_mode == AC3_DSURMOD_ON)
2069  number_of_channels_flag = 3;
2070  else
2071  number_of_channels_flag = 2;
2072  break;
2073  case AC3_CHMODE_3F:
2074  case AC3_CHMODE_2F1R:
2075  case AC3_CHMODE_3F1R:
2076  case AC3_CHMODE_2F2R:
2077  case AC3_CHMODE_3F2R:
2078  number_of_channels_flag = 4;
2079  break;
2080  default: /* reserved */
2081  number_of_channels_flag = 7;
2082  break;
2083  }
2084 
2085  if (service_type_flag == 1 || service_type_flag == 4 ||
2086  (service_type_flag == 7 && !number_of_channels_flag))
2087  full_service_flag = 0;
2088 
2089  dvb_ac3_desc->component_type_flag = 1;
2090  dvb_ac3_desc->component_type = (full_service_flag << 6) |
2091  ((service_type_flag & 0x7) << 3) |
2092  (number_of_channels_flag & 0x7);
2093  dvb_ac3_desc->bsid_flag = 1;
2094  dvb_ac3_desc->bsid = hdr->bitstream_id;
2095  dvb_ac3_desc->mainid_flag = 0;
2096  dvb_ac3_desc->asvc_flag = 0;
2097 
2098  ts_st->dvb_ac3_desc = dvb_ac3_desc;
2099  }
2100  av_free(hdr);
2101  }
2102 
2103  if (ts_st->payload_size && (ts_st->payload_size + size > ts->pes_payload_size ||
2104  (dts != AV_NOPTS_VALUE && ts_st->payload_dts != AV_NOPTS_VALUE &&
2105  dts - ts_st->payload_dts >= max_audio_delay) ||
2106  ts_st->opus_queued_samples + opus_samples >= 5760 /* 120ms */)) {
2107  mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
2108  ts_st->payload_pts, ts_st->payload_dts,
2109  ts_st->payload_flags & AV_PKT_FLAG_KEY, stream_id);
2110  ts_st->payload_size = 0;
2111  ts_st->opus_queued_samples = 0;
2112  }
2113 
2115  av_assert0(!ts_st->payload_size);
2116  // for video and subtitle, write a single pes packet
2117  mpegts_write_pes(s, st, buf, size, pts, dts,
2118  pkt->flags & AV_PKT_FLAG_KEY, stream_id);
2119  ts_st->opus_queued_samples = 0;
2120  av_free(data);
2121  return 0;
2122  }
2123 
2124  if (!ts_st->payload_size) {
2125  ts_st->payload_pts = pts;
2126  ts_st->payload_dts = dts;
2127  ts_st->payload_flags = pkt->flags;
2128  }
2129 
2130  memcpy(ts_st->payload + ts_st->payload_size, buf, size);
2131  ts_st->payload_size += size;
2132  ts_st->opus_queued_samples += opus_samples;
2133 
2134  av_free(data);
2135 
2136  return 0;
2137 }
2138 
2140 {
2141  MpegTSWrite *ts = s->priv_data;
2142  int i;
2143 
2144  /* flush current packets */
2145  for (i = 0; i < s->nb_streams; i++) {
2146  AVStream *st = s->streams[i];
2147  MpegTSWriteStream *ts_st = st->priv_data;
2148  if (ts_st->payload_size > 0) {
2149  mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
2150  ts_st->payload_pts, ts_st->payload_dts,
2151  ts_st->payload_flags & AV_PKT_FLAG_KEY, -1);
2152  ts_st->payload_size = 0;
2153  ts_st->opus_queued_samples = 0;
2154  }
2155  }
2156 
2157  if (ts->m2ts_mode) {
2158  int packets = (avio_tell(s->pb) / (TS_PACKET_SIZE + 4)) % 32;
2159  while (packets++ < 32)
2161  }
2162 }
2163 
2165 {
2166  if (!pkt) {
2168  return 1;
2169  } else {
2171  }
2172 }
2173 
2175 {
2176  if (s->pb)
2178 
2179  return 0;
2180 }
2181 
2183 {
2184  MpegTSWrite *ts = s->priv_data;
2185  MpegTSService *service;
2186  int i;
2187 
2188  av_packet_free(&ts->pkt);
2189 
2190  for (i = 0; i < s->nb_streams; i++) {
2191  AVStream *st = s->streams[i];
2192  MpegTSWriteStream *ts_st = st->priv_data;
2193  if (ts_st) {
2194  av_freep(&ts_st->dvb_ac3_desc);
2195  av_freep(&ts_st->payload);
2196  if (ts_st->amux) {
2197  avformat_free_context(ts_st->amux);
2198  ts_st->amux = NULL;
2199  }
2200  }
2201  }
2202 
2203  for (i = 0; i < ts->nb_services; i++) {
2204  service = ts->services[i];
2205  av_freep(&service);
2206  }
2207  av_freep(&ts->services);
2208 }
2209 
2211 {
2212  int ret = 1;
2213  AVStream *st = s->streams[pkt->stream_index];
2214 
2215  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2216  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
2217  (AV_RB24(pkt->data) != 0x000001 ||
2218  (st->codecpar->extradata_size > 0 &&
2219  st->codecpar->extradata[0] == 1)))
2220  ret = ff_stream_add_bitstream_filter(st, "h264_mp4toannexb", NULL);
2221  } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
2222  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
2223  (AV_RB24(pkt->data) != 0x000001 ||
2224  (st->codecpar->extradata_size > 0 &&
2225  st->codecpar->extradata[0] == 1)))
2226  ret = ff_stream_add_bitstream_filter(st, "hevc_mp4toannexb", NULL);
2227  }
2228 
2229  return ret;
2230 }
2231 
2232 #define OFFSET(x) offsetof(MpegTSWrite, x)
2233 #define ENC AV_OPT_FLAG_ENCODING_PARAM
2234 static const AVOption options[] = {
2235  { "mpegts_transport_stream_id", "Set transport_stream_id field.",
2236  OFFSET(transport_stream_id), AV_OPT_TYPE_INT, { .i64 = 0x0001 }, 0x0001, 0xffff, ENC },
2237  { "mpegts_original_network_id", "Set original_network_id field.",
2238  OFFSET(original_network_id), AV_OPT_TYPE_INT, { .i64 = DVB_PRIVATE_NETWORK_START }, 0x0001, 0xffff, ENC },
2239  { "mpegts_service_id", "Set service_id field.",
2240  OFFSET(service_id), AV_OPT_TYPE_INT, { .i64 = 0x0001 }, 0x0001, 0xffff, ENC },
2241  { "mpegts_service_type", "Set service_type field.",
2242  OFFSET(service_type), AV_OPT_TYPE_INT, { .i64 = 0x01 }, 0x01, 0xff, ENC, "mpegts_service_type" },
2243  { "digital_tv", "Digital Television.",
2244  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_DIGITAL_TV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2245  { "digital_radio", "Digital Radio.",
2246  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_DIGITAL_RADIO }, 0x01, 0xff, ENC, "mpegts_service_type" },
2247  { "teletext", "Teletext.",
2248  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_TELETEXT }, 0x01, 0xff, ENC, "mpegts_service_type" },
2249  { "advanced_codec_digital_radio", "Advanced Codec Digital Radio.",
2250  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_RADIO }, 0x01, 0xff, ENC, "mpegts_service_type" },
2251  { "mpeg2_digital_hdtv", "MPEG2 Digital HDTV.",
2252  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_MPEG2_DIGITAL_HDTV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2253  { "advanced_codec_digital_sdtv", "Advanced Codec Digital SDTV.",
2254  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_SDTV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2255  { "advanced_codec_digital_hdtv", "Advanced Codec Digital HDTV.",
2256  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_HDTV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2257  { "hevc_digital_hdtv", "HEVC Digital Television Service.",
2258  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_HEVC_DIGITAL_HDTV }, 0x01, 0xff, ENC, "mpegts_service_type" },
2259  { "mpegts_pmt_start_pid", "Set the first pid of the PMT.",
2260  OFFSET(pmt_start_pid), AV_OPT_TYPE_INT, { .i64 = 0x1000 }, FIRST_OTHER_PID, LAST_OTHER_PID, ENC },
2261  { "mpegts_start_pid", "Set the first pid.",
2262  OFFSET(start_pid), AV_OPT_TYPE_INT, { .i64 = 0x0100 }, FIRST_OTHER_PID, LAST_OTHER_PID, ENC },
2263  { "mpegts_m2ts_mode", "Enable m2ts mode.", OFFSET(m2ts_mode), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, ENC },
2264  { "muxrate", NULL, OFFSET(mux_rate), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, INT_MAX, ENC },
2265  { "pes_payload_size", "Minimum PES packet payload in bytes",
2266  OFFSET(pes_payload_size), AV_OPT_TYPE_INT, { .i64 = DEFAULT_PES_PAYLOAD_SIZE }, 0, INT_MAX, ENC },
2267  { "mpegts_flags", "MPEG-TS muxing flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, 0, INT_MAX, ENC, "mpegts_flags" },
2268  { "resend_headers", "Reemit PAT/PMT before writing the next packet",
2269  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_REEMIT_PAT_PMT }, 0, INT_MAX, ENC, "mpegts_flags" },
2270  { "latm", "Use LATM packetization for AAC",
2271  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_AAC_LATM }, 0, INT_MAX, ENC, "mpegts_flags" },
2272  { "pat_pmt_at_frames", "Reemit PAT and PMT at each video frame",
2273  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_PAT_PMT_AT_FRAMES}, 0, INT_MAX, ENC, "mpegts_flags" },
2274  { "system_b", "Conform to System B (DVB) instead of System A (ATSC)",
2275  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_SYSTEM_B }, 0, INT_MAX, ENC, "mpegts_flags" },
2276  { "initial_discontinuity", "Mark initial packets as discontinuous",
2277  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_DISCONT }, 0, INT_MAX, ENC, "mpegts_flags" },
2278  { "nit", "Enable NIT transmission",
2279  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_NIT}, 0, INT_MAX, ENC, "mpegts_flags" },
2280  { "mpegts_copyts", "don't offset dts/pts", OFFSET(copyts), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, ENC },
2281  { "tables_version", "set PAT, PMT, SDT and NIT version", OFFSET(tables_version), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 31, ENC },
2282  { "omit_video_pes_length", "Omit the PES packet length for video packets",
2283  OFFSET(omit_video_pes_length), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, ENC },
2284  { "pcr_period", "PCR retransmission time in milliseconds",
2285  OFFSET(pcr_period_ms), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, ENC },
2286  { "pat_period", "PAT/PMT retransmission time limit in seconds",
2287  OFFSET(pat_period_us), AV_OPT_TYPE_DURATION, { .i64 = PAT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, ENC },
2288  { "sdt_period", "SDT retransmission time limit in seconds",
2289  OFFSET(sdt_period_us), AV_OPT_TYPE_DURATION, { .i64 = SDT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, ENC },
2290  { "nit_period", "NIT retransmission time limit in seconds",
2291  OFFSET(nit_period_us), AV_OPT_TYPE_DURATION, { .i64 = NIT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, ENC },
2292  { NULL },
2293 };
2294 
2295 static const AVClass mpegts_muxer_class = {
2296  .class_name = "MPEGTS muxer",
2297  .item_name = av_default_item_name,
2298  .option = options,
2299  .version = LIBAVUTIL_VERSION_INT,
2300 };
2301 
2303  .name = "mpegts",
2304  .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
2305  .mime_type = "video/MP2T",
2306  .extensions = "ts,m2t,m2ts,mts",
2307  .priv_data_size = sizeof(MpegTSWrite),
2308  .audio_codec = AV_CODEC_ID_MP2,
2309  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
2310  .init = mpegts_init,
2313  .deinit = mpegts_deinit,
2316  .priv_class = &mpegts_muxer_class,
2317 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:417
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
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AVOutputFormat::name
const char * name
Definition: avformat.h:496
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:724
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:471
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
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:866
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:470
MpegTSWriteStream::payload_dts
int64_t payload_dts
Definition: mpegtsenc.c:247
mpegts_write_flush
static void mpegts_write_flush(AVFormatContext *s)
Definition: mpegtsenc.c:2139
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:1070
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:1399
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:1177
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:50
mpegts_deinit
static void mpegts_deinit(AVFormatContext *s)
Definition: mpegtsenc.c:2182
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:924
get_pcr
static int64_t get_pcr(const MpegTSWrite *ts)
Definition: mpegtsenc.c:945
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
MPEGTS_SERVICE_TYPE_MPEG2_DIGITAL_HDTV
@ MPEGTS_SERVICE_TYPE_MPEG2_DIGITAL_HDTV
Definition: mpegtsenc.c:70
DVBAC3Descriptor::component_type
uint8_t component_type
Definition: mpegts.h:208
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:2302
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:1785
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:425
mpegts_write_end
static int mpegts_write_end(AVFormatContext *s)
Definition: mpegtsenc.c:2174
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
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:827
MpegTSSection::pid
int pid
Definition: mpegtsenc.c:48
state
static struct @319 state
crc.h
mpegts_write_packet
static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegtsenc.c:2164
OFFSET
#define OFFSET(x)
Definition: mpegtsenc.c:2232
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:1465
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:127
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
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
stream without voice
Definition: avformat.h:819
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:1488
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:1326
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1443
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
MPEGTS_SERVICE_TYPE_DIGITAL_RADIO
@ MPEGTS_SERVICE_TYPE_DIGITAL_RADIO
Definition: mpegtsenc.c:67
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:2205
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
options
static const AVOption options[]
Definition: mpegtsenc.c:2234
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:289
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:1415
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:467
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:1293
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:1341
AV_CODEC_ID_AVS3
@ AV_CODEC_ID_AVS3
Definition: codec_id.h:246
AVFormatContext
Format I/O context.
Definition: avformat.h:1109
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1004
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:880
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:1739
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1151
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:915
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:1188
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
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:902
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:1833
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:476
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_check_bitstream
static int mpegts_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
Definition: mpegtsenc.c:2210
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
stream for hearing impaired audiences
Definition: avformat.h:817
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
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
MpegTSWrite::pes_payload_size
int pes_payload_size
Definition: mpegtsenc.c:90
version
version
Definition: libkvazaar.c:307
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:454
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:495
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:246
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:1384
STREAM_TYPE_AUDIO_TRUEHD
#define STREAM_TYPE_AUDIO_TRUEHD
Definition: mpegts.h:139
ENC
#define ENC
Definition: mpegtsenc.c:2233
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:1033
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
AV_DISPOSITION_* bit field.
Definition: avformat.h:904
AV_DISPOSITION_VISUAL_IMPAIRED
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:818
STREAM_ID_VIDEO_STREAM_0
#define STREAM_ID_VIDEO_STREAM_0
Definition: mpegts.h:148
tag
uint32_t tag
Definition: movenc.c:1595
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1516
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:864
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:857
bswap.h
MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_RADIO
@ MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_RADIO
Definition: mpegtsenc.c:69
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:1128
FF_PROFILE_KLVA_SYNC
#define FF_PROFILE_KLVA_SYNC
Definition: avcodec.h:1643
MpegTSSection
Definition: mpegtsenc.c:47
avformat.h
dict.h
MPEGTS_SERVICE_TYPE_HEVC_DIGITAL_HDTV
@ MPEGTS_SERVICE_TYPE_HEVC_DIGITAL_HDTV
Definition: mpegtsenc.c:73
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:858
MpegTSWrite::pat
MpegTSSection pat
Definition: mpegtsenc.c:77
MPEGTS_SERVICE_TYPE_DIGITAL_TV
@ MPEGTS_SERVICE_TYPE_DIGITAL_TV
Definition: mpegtsenc.c:66
STREAM_TYPE_VIDEO_H264
#define STREAM_TYPE_VIDEO_H264
Definition: mpeg.h:57
AC3_CHMODE_2F2R
@ AC3_CHMODE_2F2R
Definition: ac3.h:130
mpegts_write_sdt
static void mpegts_write_sdt(AVFormatContext *s)
Definition: mpegtsenc.c:830
MPEGTS_SERVICE_TYPE_TELETEXT
@ MPEGTS_SERVICE_TYPE_TELETEXT
Definition: mpegtsenc.c:68
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:679
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:1766
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:1146
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:2295
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
MpegTSService
Definition: mpegtsenc.c:55
STREAM_TYPE_METADATA
#define STREAM_TYPE_METADATA
Definition: mpegts.h:128
AC3_CHMODE_3F1R
@ AC3_CHMODE_3F1R
Definition: ac3.h:129
MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_SDTV
@ MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_SDTV
Definition: mpegtsenc.c:71
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:1431
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:1423
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:1356
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
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
MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_HDTV
@ MPEGTS_SERVICE_TYPE_ADVANCED_CODEC_DIGITAL_HDTV
Definition: mpegtsenc.c:72
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:1749
put_arib_caption_descriptor
static int put_arib_caption_descriptor(AVFormatContext *s, uint8_t **q_ptr, AVCodecParameters *codecpar)
Definition: mpegtsenc.c:290