FFmpeg
mpegtsenc.c
Go to the documentation of this file.
1 /*
2  * MPEG-2 transport stream (aka DVB) muxer
3  * Copyright (c) 2003 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avassert.h"
23 #include "libavutil/bswap.h"
24 #include "libavutil/crc.h"
25 #include "libavutil/dict.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavutil/mathematics.h"
28 #include "libavutil/opt.h"
29 
30 #include "libavcodec/internal.h"
31 
32 #include "avformat.h"
33 #include "avio_internal.h"
34 #include "internal.h"
35 #include "mpegts.h"
36 
37 #define PCR_TIME_BASE 27000000
38 
39 /* write DVB SI sections */
40 
41 #define DVB_PRIVATE_NETWORK_START 0xff01
42 
43 /*********************************************/
44 /* mpegts section writer */
45 
46 typedef struct MpegTSSection {
47  int pid;
48  int cc;
50  void (*write_packet)(struct MpegTSSection *s, const uint8_t *packet);
51  void *opaque;
53 
54 typedef struct MpegTSService {
55  MpegTSSection pmt; /* MPEG-2 PMT table context */
56  int sid; /* service ID */
57  uint8_t name[256];
58  uint8_t provider_name[256];
59  int pcr_pid;
62 
63 // service_type values as defined in ETSI 300 468
64 enum {
73 };
74 typedef struct MpegTSWrite {
75  const AVClass *av_class;
76  MpegTSSection pat; /* MPEG-2 PAT table */
77  MpegTSSection sdt; /* MPEG-2 SDT table context */
79  int64_t sdt_period; /* SDT period in PCR time base */
80  int64_t pat_period; /* PAT/PMT period in PCR time base */
82  int onid;
83  int tsid;
84  int64_t first_pcr;
85  int64_t next_pcr;
86  int mux_rate; ///< set to 1 when VBR
88 
93 
95  int start_pid;
96  int m2ts_mode;
97 
99 #define MPEGTS_FLAG_REEMIT_PAT_PMT 0x01
100 #define MPEGTS_FLAG_AAC_LATM 0x02
101 #define MPEGTS_FLAG_PAT_PMT_AT_FRAMES 0x04
102 #define MPEGTS_FLAG_SYSTEM_B 0x08
103 #define MPEGTS_FLAG_DISCONT 0x10
104  int flags;
105  int copyts;
107  int64_t pat_period_us;
108  int64_t sdt_period_us;
109  int64_t last_pat_ts;
110  int64_t last_sdt_ts;
111 
113 } MpegTSWrite;
114 
115 /* a PES packet header is generated every DEFAULT_PES_HEADER_FREQ packets */
116 #define DEFAULT_PES_HEADER_FREQ 16
117 #define DEFAULT_PES_PAYLOAD_SIZE ((DEFAULT_PES_HEADER_FREQ - 1) * 184 + 170)
118 
119 /* The section length is 12 bits. The first 2 are set to 0, the remaining
120  * 10 bits should not exceed 1021. */
121 #define SECTION_LENGTH 1020
122 
123 /* NOTE: 4 bytes must be left at the end for the crc32 */
125 {
126  unsigned int crc;
127  unsigned char packet[TS_PACKET_SIZE];
128  const unsigned char *buf_ptr;
129  unsigned char *q;
130  int first, b, len1, left;
131 
133  -1, buf, len - 4));
134 
135  buf[len - 4] = (crc >> 24) & 0xff;
136  buf[len - 3] = (crc >> 16) & 0xff;
137  buf[len - 2] = (crc >> 8) & 0xff;
138  buf[len - 1] = crc & 0xff;
139 
140  /* send each packet */
141  buf_ptr = buf;
142  while (len > 0) {
143  first = buf == buf_ptr;
144  q = packet;
145  *q++ = 0x47;
146  b = s->pid >> 8;
147  if (first)
148  b |= 0x40;
149  *q++ = b;
150  *q++ = s->pid;
151  s->cc = s->cc + 1 & 0xf;
152  *q++ = 0x10 | s->cc;
153  if (s->discontinuity) {
154  q[-1] |= 0x20;
155  *q++ = 1;
156  *q++ = 0x80;
157  s->discontinuity = 0;
158  }
159  if (first)
160  *q++ = 0; /* 0 offset */
161  len1 = TS_PACKET_SIZE - (q - packet);
162  if (len1 > len)
163  len1 = len;
164  memcpy(q, buf_ptr, len1);
165  q += len1;
166  /* add known padding data */
167  left = TS_PACKET_SIZE - (q - packet);
168  if (left > 0)
169  memset(q, 0xff, left);
170 
171  s->write_packet(s, packet);
172 
173  buf_ptr += len1;
174  len -= len1;
175  }
176 }
177 
178 static inline void put16(uint8_t **q_ptr, int val)
179 {
180  uint8_t *q;
181  q = *q_ptr;
182  *q++ = val >> 8;
183  *q++ = val;
184  *q_ptr = q;
185 }
186 
187 static int mpegts_write_section1(MpegTSSection *s, int tid, int id,
188  int version, int sec_num, int last_sec_num,
189  uint8_t *buf, int len)
190 {
191  uint8_t section[1024], *q;
192  unsigned int tot_len;
193  /* reserved_future_use field must be set to 1 for SDT */
194  unsigned int flags = tid == SDT_TID ? 0xf000 : 0xb000;
195 
196  tot_len = 3 + 5 + len + 4;
197  /* check if not too big */
198  if (tot_len > 1024)
199  return AVERROR_INVALIDDATA;
200 
201  q = section;
202  *q++ = tid;
203  put16(&q, flags | (len + 5 + 4)); /* 5 byte header + 4 byte CRC */
204  put16(&q, id);
205  *q++ = 0xc1 | (version << 1); /* current_next_indicator = 1 */
206  *q++ = sec_num;
207  *q++ = last_sec_num;
208  memcpy(q, buf, len);
209 
210  mpegts_write_section(s, section, tot_len);
211  return 0;
212 }
213 
214 /*********************************************/
215 /* mpegts writer */
216 
217 #define DEFAULT_PROVIDER_NAME "FFmpeg"
218 #define DEFAULT_SERVICE_NAME "Service"
219 
220 /* we retransmit the SI info at this rate */
221 #define SDT_RETRANS_TIME 500
222 #define PAT_RETRANS_TIME 100
223 #define PCR_RETRANS_TIME 20
224 
225 typedef struct MpegTSWriteStream {
226  int pid; /* stream associated pid */
227  int cc;
230  int first_pts_check; ///< first pts check needed
232  int64_t payload_pts;
233  int64_t payload_dts;
237 
238  int64_t pcr_period; /* PCR period in PCR time base */
239  int64_t last_pcr;
240 
241  /* For Opus */
245 
247 {
248  MpegTSWrite *ts = s->priv_data;
249  MpegTSService *service;
251  int i;
252 
253  q = data;
254  for (i = 0; i < ts->nb_services; i++) {
255  service = ts->services[i];
256  put16(&q, service->sid);
257  put16(&q, 0xe000 | service->pmt.pid);
258  }
259  mpegts_write_section1(&ts->pat, PAT_TID, ts->tsid, ts->tables_version, 0, 0,
260  data, q - data);
261 }
262 
263 static void putbuf(uint8_t **q_ptr, const uint8_t *buf, size_t len)
264 {
265  memcpy(*q_ptr, buf, len);
266  *q_ptr += len;
267 }
268 
269 static void put_registration_descriptor(uint8_t **q_ptr, uint32_t tag)
270 {
271  uint8_t *q = *q_ptr;
272  *q++ = 0x05; /* MPEG-2 registration descriptor*/
273  *q++ = 4;
274  *q++ = tag;
275  *q++ = tag >> 8;
276  *q++ = tag >> 16;
277  *q++ = tag >> 24;
278  *q_ptr = q;
279 }
280 
282 {
283  MpegTSWrite *ts = s->priv_data;
284  uint8_t data[SECTION_LENGTH], *q, *desc_length_ptr, *program_info_length_ptr;
285  int val, stream_type, i, err = 0;
286 
287  q = data;
288  put16(&q, 0xe000 | service->pcr_pid);
289 
290  program_info_length_ptr = q;
291  q += 2; /* patched after */
292 
293  /* put program info here */
294 
295  val = 0xf000 | (q - program_info_length_ptr - 2);
296  program_info_length_ptr[0] = val >> 8;
297  program_info_length_ptr[1] = val;
298 
299  for (i = 0; i < s->nb_streams; i++) {
300  AVStream *st = s->streams[i];
301  MpegTSWriteStream *ts_st = st->priv_data;
302  AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
303 
304  if (s->nb_programs) {
305  int k, found = 0;
306  AVProgram *program = service->program;
307 
308  for (k = 0; k < program->nb_stream_indexes; k++)
309  if (program->stream_index[k] == i) {
310  found = 1;
311  break;
312  }
313 
314  if (!found)
315  continue;
316  }
317 
318  if (q - data > SECTION_LENGTH - 32) {
319  err = 1;
320  break;
321  }
322  switch (st->codecpar->codec_id) {
325  stream_type = STREAM_TYPE_VIDEO_MPEG2;
326  break;
327  case AV_CODEC_ID_MPEG4:
328  stream_type = STREAM_TYPE_VIDEO_MPEG4;
329  break;
330  case AV_CODEC_ID_H264:
331  stream_type = STREAM_TYPE_VIDEO_H264;
332  break;
333  case AV_CODEC_ID_HEVC:
334  stream_type = STREAM_TYPE_VIDEO_HEVC;
335  break;
336  case AV_CODEC_ID_CAVS:
337  stream_type = STREAM_TYPE_VIDEO_CAVS;
338  break;
339  case AV_CODEC_ID_DIRAC:
340  stream_type = STREAM_TYPE_VIDEO_DIRAC;
341  break;
342  case AV_CODEC_ID_VC1:
343  stream_type = STREAM_TYPE_VIDEO_VC1;
344  break;
345  case AV_CODEC_ID_MP2:
346  case AV_CODEC_ID_MP3:
347  if ( st->codecpar->sample_rate > 0
348  && st->codecpar->sample_rate < 32000) {
349  stream_type = STREAM_TYPE_AUDIO_MPEG2;
350  } else {
351  stream_type = STREAM_TYPE_AUDIO_MPEG1;
352  }
353  break;
354  case AV_CODEC_ID_AAC:
355  stream_type = (ts->flags & MPEGTS_FLAG_AAC_LATM)
358  break;
360  stream_type = STREAM_TYPE_AUDIO_AAC_LATM;
361  break;
362  case AV_CODEC_ID_AC3:
363  stream_type = (ts->flags & MPEGTS_FLAG_SYSTEM_B)
366  break;
367  case AV_CODEC_ID_EAC3:
368  stream_type = (ts->flags & MPEGTS_FLAG_SYSTEM_B)
371  break;
372  case AV_CODEC_ID_DTS:
373  stream_type = STREAM_TYPE_AUDIO_DTS;
374  break;
375  case AV_CODEC_ID_TRUEHD:
376  stream_type = STREAM_TYPE_AUDIO_TRUEHD;
377  break;
378  case AV_CODEC_ID_OPUS:
379  stream_type = STREAM_TYPE_PRIVATE_DATA;
380  break;
382  stream_type = STREAM_TYPE_METADATA;
383  break;
384  default:
385  stream_type = STREAM_TYPE_PRIVATE_DATA;
386  break;
387  }
388 
389  *q++ = stream_type;
390  put16(&q, 0xe000 | ts_st->pid);
391  desc_length_ptr = q;
392  q += 2; /* patched after */
393 
394  /* write optional descriptors here */
395  switch (st->codecpar->codec_type) {
396  case AVMEDIA_TYPE_AUDIO:
398  *q++=0x6a; // AC3 descriptor see A038 DVB SI
399  *q++=1; // 1 byte, all flags sets to 0
400  *q++=0; // omit all fields...
401  }
403  *q++=0x7a; // EAC3 descriptor see A038 DVB SI
404  *q++=1; // 1 byte, all flags sets to 0
405  *q++=0; // omit all fields...
406  }
408  put_registration_descriptor(&q, MKTAG('B', 'S', 'S', 'D'));
409  if (st->codecpar->codec_id==AV_CODEC_ID_OPUS) {
410  /* 6 bytes registration descriptor, 4 bytes Opus audio descriptor */
411  if (q - data > SECTION_LENGTH - 6 - 4) {
412  err = 1;
413  break;
414  }
415 
416  put_registration_descriptor(&q, MKTAG('O', 'p', 'u', 's'));
417 
418  *q++ = 0x7f; /* DVB extension descriptor */
419  *q++ = 2;
420  *q++ = 0x80;
421 
422  if (st->codecpar->extradata && st->codecpar->extradata_size >= 19) {
423  if (st->codecpar->extradata[18] == 0 && st->codecpar->channels <= 2) {
424  /* RTP mapping family */
425  *q++ = st->codecpar->channels;
426  } else if (st->codecpar->extradata[18] == 1 && st->codecpar->channels <= 8 &&
427  st->codecpar->extradata_size >= 21 + st->codecpar->channels) {
428  static const uint8_t coupled_stream_counts[9] = {
429  1, 0, 1, 1, 2, 2, 2, 3, 3
430  };
431  static const uint8_t channel_map_a[8][8] = {
432  {0},
433  {0, 1},
434  {0, 2, 1},
435  {0, 1, 2, 3},
436  {0, 4, 1, 2, 3},
437  {0, 4, 1, 2, 3, 5},
438  {0, 4, 1, 2, 3, 5, 6},
439  {0, 6, 1, 2, 3, 4, 5, 7},
440  };
441  static const uint8_t channel_map_b[8][8] = {
442  {0},
443  {0, 1},
444  {0, 1, 2},
445  {0, 1, 2, 3},
446  {0, 1, 2, 3, 4},
447  {0, 1, 2, 3, 4, 5},
448  {0, 1, 2, 3, 4, 5, 6},
449  {0, 1, 2, 3, 4, 5, 6, 7},
450  };
451  /* Vorbis mapping family */
452 
453  if (st->codecpar->extradata[19] == st->codecpar->channels - coupled_stream_counts[st->codecpar->channels] &&
454  st->codecpar->extradata[20] == coupled_stream_counts[st->codecpar->channels] &&
455  memcmp(&st->codecpar->extradata[21], channel_map_a[st->codecpar->channels-1], st->codecpar->channels) == 0) {
456  *q++ = st->codecpar->channels;
457  } else if (st->codecpar->channels >= 2 && st->codecpar->extradata[19] == st->codecpar->channels &&
458  st->codecpar->extradata[20] == 0 &&
459  memcmp(&st->codecpar->extradata[21], channel_map_b[st->codecpar->channels-1], st->codecpar->channels) == 0) {
460  *q++ = st->codecpar->channels | 0x80;
461  } else {
462  /* Unsupported, could write an extended descriptor here */
463  av_log(s, AV_LOG_ERROR, "Unsupported Opus Vorbis-style channel mapping");
464  *q++ = 0xff;
465  }
466  } else {
467  /* Unsupported */
468  av_log(s, AV_LOG_ERROR, "Unsupported Opus channel mapping for family %d", st->codecpar->extradata[18]);
469  *q++ = 0xff;
470  }
471  } else if (st->codecpar->channels <= 2) {
472  /* Assume RTP mapping family */
473  *q++ = st->codecpar->channels;
474  } else {
475  /* Unsupported */
476  av_log(s, AV_LOG_ERROR, "Unsupported Opus channel mapping");
477  *q++ = 0xff;
478  }
479  }
480 
481  if (lang) {
482  char *p;
483  char *next = lang->value;
484  uint8_t *len_ptr;
485 
486  *q++ = 0x0a; /* ISO 639 language descriptor */
487  len_ptr = q++;
488  *len_ptr = 0;
489 
490  for (p = lang->value; next && *len_ptr < 255 / 4 * 4; p = next + 1) {
491  if (q - data > SECTION_LENGTH - 4) {
492  err = 1;
493  break;
494  }
495  next = strchr(p, ',');
496  if (strlen(p) != 3 && (!next || next != p + 3))
497  continue; /* not a 3-letter code */
498 
499  *q++ = *p++;
500  *q++ = *p++;
501  *q++ = *p++;
502 
504  *q++ = 0x01;
506  *q++ = 0x02;
508  *q++ = 0x03;
509  else
510  *q++ = 0; /* undefined type */
511 
512  *len_ptr += 4;
513  }
514 
515  if (*len_ptr == 0)
516  q -= 2; /* no language codes were written */
517  }
518  break;
520  {
521  const char default_language[] = "und";
522  const char *language = lang && strlen(lang->value) >= 3 ? lang->value : default_language;
523 
525  uint8_t *len_ptr;
526  int extradata_copied = 0;
527 
528  *q++ = 0x59; /* subtitling_descriptor */
529  len_ptr = q++;
530 
531  while (strlen(language) >= 3) {
532  if (sizeof(data) - (q - data) < 8) { /* 8 bytes per DVB subtitle substream data */
533  err = 1;
534  break;
535  }
536  *q++ = *language++;
537  *q++ = *language++;
538  *q++ = *language++;
539  /* Skip comma */
540  if (*language != '\0')
541  language++;
542 
543  if (st->codecpar->extradata_size - extradata_copied >= 5) {
544  *q++ = st->codecpar->extradata[extradata_copied + 4]; /* subtitling_type */
545  memcpy(q, st->codecpar->extradata + extradata_copied, 4); /* composition_page_id and ancillary_page_id */
546  extradata_copied += 5;
547  q += 4;
548  } else {
549  /* subtitling_type:
550  * 0x10 - normal with no monitor aspect ratio criticality
551  * 0x20 - for the hard of hearing with no monitor aspect ratio criticality */
552  *q++ = (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED) ? 0x20 : 0x10;
553  if ((st->codecpar->extradata_size == 4) && (extradata_copied == 0)) {
554  /* support of old 4-byte extradata format */
555  memcpy(q, st->codecpar->extradata, 4); /* composition_page_id and ancillary_page_id */
556  extradata_copied += 4;
557  q += 4;
558  } else {
559  put16(&q, 1); /* composition_page_id */
560  put16(&q, 1); /* ancillary_page_id */
561  }
562  }
563  }
564 
565  *len_ptr = q - len_ptr - 1;
566  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT) {
567  uint8_t *len_ptr = NULL;
568  int extradata_copied = 0;
569 
570  /* The descriptor tag. teletext_descriptor */
571  *q++ = 0x56;
572  len_ptr = q++;
573 
574  while (strlen(language) >= 3 && q - data < sizeof(data) - 6) {
575  *q++ = *language++;
576  *q++ = *language++;
577  *q++ = *language++;
578  /* Skip comma */
579  if (*language != '\0')
580  language++;
581 
582  if (st->codecpar->extradata_size - 1 > extradata_copied) {
583  memcpy(q, st->codecpar->extradata + extradata_copied, 2);
584  extradata_copied += 2;
585  q += 2;
586  } else {
587  /* The Teletext descriptor:
588  * teletext_type: This 5-bit field indicates the type of Teletext page indicated. (0x01 Initial Teletext page)
589  * teletext_magazine_number: This is a 3-bit field which identifies the magazine number.
590  * teletext_page_number: This is an 8-bit field giving two 4-bit hex digits identifying the page number. */
591  *q++ = 0x08;
592  *q++ = 0x00;
593  }
594  }
595 
596  *len_ptr = q - len_ptr - 1;
597  }
598  }
599  break;
600  case AVMEDIA_TYPE_VIDEO:
601  if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
602  put_registration_descriptor(&q, MKTAG('d', 'r', 'a', 'c'));
603  } else if (stream_type == STREAM_TYPE_VIDEO_VC1) {
604  put_registration_descriptor(&q, MKTAG('V', 'C', '-', '1'));
605  } else if (stream_type == STREAM_TYPE_VIDEO_HEVC && s->strict_std_compliance <= FF_COMPLIANCE_NORMAL) {
606  put_registration_descriptor(&q, MKTAG('H', 'E', 'V', 'C'));
607  }
608  break;
609  case AVMEDIA_TYPE_DATA:
611  put_registration_descriptor(&q, MKTAG('K', 'L', 'V', 'A'));
612  } else if (st->codecpar->codec_id == AV_CODEC_ID_TIMED_ID3) {
613  const char *tag = "ID3 ";
614  *q++ = 0x26; /* metadata descriptor */
615  *q++ = 13;
616  put16(&q, 0xffff); /* metadata application format */
617  putbuf(&q, tag, strlen(tag));
618  *q++ = 0xff; /* metadata format */
619  putbuf(&q, tag, strlen(tag));
620  *q++ = 0; /* metadata service ID */
621  *q++ = 0xF; /* metadata_locator_record_flag|MPEG_carriage_flags|reserved */
622  }
623  break;
624  }
625 
626  val = 0xf000 | (q - desc_length_ptr - 2);
627  desc_length_ptr[0] = val >> 8;
628  desc_length_ptr[1] = val;
629  }
630 
631  if (err)
632  av_log(s, AV_LOG_ERROR,
633  "The PMT section cannot fit stream %d and all following streams.\n"
634  "Try reducing the number of languages in the audio streams "
635  "or the total number of streams.\n", i);
636 
637  mpegts_write_section1(&service->pmt, PMT_TID, service->sid, ts->tables_version, 0, 0,
638  data, q - data);
639  return 0;
640 }
641 
643 {
644  MpegTSWrite *ts = s->priv_data;
645  MpegTSService *service;
646  uint8_t data[SECTION_LENGTH], *q, *desc_list_len_ptr, *desc_len_ptr;
647  int i, running_status, free_ca_mode, val;
648 
649  q = data;
650  put16(&q, ts->onid);
651  *q++ = 0xff;
652  for (i = 0; i < ts->nb_services; i++) {
653  service = ts->services[i];
654  put16(&q, service->sid);
655  *q++ = 0xfc | 0x00; /* currently no EIT info */
656  desc_list_len_ptr = q;
657  q += 2;
658  running_status = 4; /* running */
659  free_ca_mode = 0;
660 
661  /* write only one descriptor for the service name and provider */
662  *q++ = 0x48;
663  desc_len_ptr = q;
664  q++;
665  *q++ = ts->service_type;
666  putbuf(&q, service->provider_name, service->provider_name[0] + 1);
667  putbuf(&q, service->name, service->name[0] + 1);
668  desc_len_ptr[0] = q - desc_len_ptr - 1;
669 
670  /* fill descriptor length */
671  val = (running_status << 13) | (free_ca_mode << 12) |
672  (q - desc_list_len_ptr - 2);
673  desc_list_len_ptr[0] = val >> 8;
674  desc_list_len_ptr[1] = val;
675  }
676  mpegts_write_section1(&ts->sdt, SDT_TID, ts->tsid, ts->tables_version, 0, 0,
677  data, q - data);
678 }
679 
680 /* This stores a string in buf with the correct encoding and also sets the
681  * first byte as the length. !str is accepted for an empty string.
682  * If the string is already encoded, invalid UTF-8 or has no multibyte sequence
683  * then we keep it as is, otherwise we signal UTF-8 encoding. */
684 static int encode_str8(uint8_t *buf, const char *str)
685 {
686  size_t str_len;
687  if (!str)
688  str = "";
689  str_len = strlen(str);
690  if (str[0] && (unsigned)str[0] >= 0x20) { /* Make sure the string is not already encoded. */
691  const uint8_t *q = str;
692  int has_multibyte = 0;
693  while (*q) {
694  uint32_t code;
695  GET_UTF8(code, *q++, goto invalid;) /* Is it valid UTF-8? */
696  has_multibyte |= (code > 127); /* Does it have multibyte UTF-8 chars in it? */
697  }
698  if (has_multibyte) { /* If we have multibyte chars and valid UTF-8, then encode as such! */
699  if (str_len > 254)
700  return AVERROR(EINVAL);
701  buf[0] = str_len + 1;
702  buf[1] = 0x15;
703  memcpy(&buf[2], str, str_len);
704  return 0;
705  }
706  }
707 invalid:
708  /* Otherwise let's just encode the string as is! */
709  if (str_len > 255)
710  return AVERROR(EINVAL);
711  buf[0] = str_len;
712  memcpy(&buf[1], str, str_len);
713  return 0;
714 }
715 
716 static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb)
717 {
718  return av_rescale(avio_tell(pb) + 11, 8 * PCR_TIME_BASE, ts->mux_rate) +
719  ts->first_pcr;
720 }
721 
723 {
724  MpegTSWrite *ts = s->priv_data;
725  if (ts->m2ts_mode) {
726  int64_t pcr = get_pcr(s->priv_data, s->pb);
727  uint32_t tp_extra_header = pcr % 0x3fffffff;
728  tp_extra_header = AV_RB32(&tp_extra_header);
729  avio_write(s->pb, (unsigned char *) &tp_extra_header,
730  sizeof(tp_extra_header));
731  }
732 }
733 
734 static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
735 {
736  AVFormatContext *ctx = s->opaque;
738  avio_write(ctx->pb, packet, TS_PACKET_SIZE);
739 }
740 
742  const AVDictionary *metadata,
744 {
745  MpegTSWrite *ts = s->priv_data;
746  MpegTSService *service;
747  AVDictionaryEntry *title, *provider;
748  char default_service_name[32];
749  const char *service_name;
750  const char *provider_name;
751 
752  title = av_dict_get(metadata, "service_name", NULL, 0);
753  if (!title)
754  title = av_dict_get(metadata, "title", NULL, 0);
755  snprintf(default_service_name, sizeof(default_service_name), "%s%02d", DEFAULT_SERVICE_NAME, ts->nb_services + 1);
756  service_name = title ? title->value : default_service_name;
757  provider = av_dict_get(metadata, "service_provider", NULL, 0);
758  provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME;
759 
760  service = av_mallocz(sizeof(MpegTSService));
761  if (!service)
762  return NULL;
763  service->pmt.pid = ts->pmt_start_pid + ts->nb_services;
764  service->sid = sid;
765  service->pcr_pid = 0x1fff;
766  if (encode_str8(service->provider_name, provider_name) < 0 ||
767  encode_str8(service->name, service_name) < 0) {
768  av_log(s, AV_LOG_ERROR, "Too long service or provider name\n");
769  goto fail;
770  }
771  if (av_dynarray_add_nofree(&ts->services, &ts->nb_services, service) < 0)
772  goto fail;
773 
775  service->pmt.opaque = s;
776  service->pmt.cc = 15;
777  service->pmt.discontinuity= ts->flags & MPEGTS_FLAG_DISCONT;
778  service->program = program;
779 
780  return service;
781 fail:
782  av_free(service);
783  return NULL;
784 }
785 
787 {
788  MpegTSWrite *ts = s->priv_data;
789  MpegTSWriteStream *ts_st = pcr_st->priv_data;
790 
791  if (ts->mux_rate > 1 || ts->pcr_period_ms >= 0) {
792  int pcr_period_ms = ts->pcr_period_ms == -1 ? PCR_RETRANS_TIME : ts->pcr_period_ms;
793  ts_st->pcr_period = av_rescale(pcr_period_ms, PCR_TIME_BASE, 1000);
794  } else {
795  /* By default, for VBR we select the highest multiple of frame duration which is less than 100 ms. */
796  int64_t frame_period = 0;
797  if (pcr_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
799  if (!frame_size) {
800  av_log(s, AV_LOG_WARNING, "frame size not set\n");
801  frame_size = 512;
802  }
803  frame_period = av_rescale_rnd(frame_size, PCR_TIME_BASE, pcr_st->codecpar->sample_rate, AV_ROUND_UP);
804  } else if (pcr_st->avg_frame_rate.num) {
805  frame_period = av_rescale_rnd(pcr_st->avg_frame_rate.den, PCR_TIME_BASE, pcr_st->avg_frame_rate.num, AV_ROUND_UP);
806  }
807  if (frame_period > 0 && frame_period <= PCR_TIME_BASE / 10)
808  ts_st->pcr_period = frame_period * (PCR_TIME_BASE / 10 / frame_period);
809  else
810  ts_st->pcr_period = 1;
811  }
812 
813  // output a PCR as soon as possible
814  ts_st->last_pcr = ts->first_pcr - ts_st->pcr_period;
815 }
816 
818 {
819  MpegTSWrite *ts = s->priv_data;
820 
821  for (int i = 0; i < ts->nb_services; i++) {
822  MpegTSService *service = ts->services[i];
823  AVStream *pcr_st = NULL;
824  AVProgram *program = service->program;
825  int nb_streams = program ? program->nb_stream_indexes : s->nb_streams;
826 
827  for (int j = 0; j < nb_streams; j++) {
828  AVStream *st = s->streams[program ? program->stream_index[j] : j];
829  if (!pcr_st ||
831  {
832  pcr_st = st;
833  }
834  }
835 
836  if (pcr_st) {
837  MpegTSWriteStream *ts_st = pcr_st->priv_data;
838  service->pcr_pid = ts_st->pid;
840  av_log(s, AV_LOG_VERBOSE, "service %i using PCR in pid=%i, pcr_period=%"PRId64"ms\n",
841  service->sid, service->pcr_pid, av_rescale(ts_st->pcr_period, 1000, PCR_TIME_BASE));
842  }
843  }
844 }
845 
847 {
848  MpegTSWrite *ts = s->priv_data;
849  int i, j;
850  int *pids;
851  int ret;
852 
853  if (s->max_delay < 0) /* Not set by the caller */
854  s->max_delay = 0;
855 
856  // round up to a whole number of TS packets
857  ts->pes_payload_size = (ts->pes_payload_size + 14 + 183) / 184 * 184 - 14;
858 
859  ts->tsid = ts->transport_stream_id;
860  ts->onid = ts->original_network_id;
861  if (!s->nb_programs) {
862  /* allocate a single DVB service */
863  if (!mpegts_add_service(s, ts->service_id, s->metadata, NULL))
864  return AVERROR(ENOMEM);
865  } else {
866  for (i = 0; i < s->nb_programs; i++) {
867  AVProgram *program = s->programs[i];
868  if (!mpegts_add_service(s, program->id, program->metadata, program))
869  return AVERROR(ENOMEM);
870  }
871  }
872 
873  ts->pat.pid = PAT_PID;
874  /* Initialize at 15 so that it wraps and is equal to 0 for the
875  * first packet we write. */
876  ts->pat.cc = 15;
879  ts->pat.opaque = s;
880 
881  ts->sdt.pid = SDT_PID;
882  ts->sdt.cc = 15;
885  ts->sdt.opaque = s;
886 
887  pids = av_malloc_array(s->nb_streams, sizeof(*pids));
888  if (!pids) {
889  ret = AVERROR(ENOMEM);
890  goto fail;
891  }
892 
893  /* assign pids to each stream */
894  for (i = 0; i < s->nb_streams; i++) {
895  AVStream *st = s->streams[i];
896  MpegTSWriteStream *ts_st;
897 
898  ts_st = av_mallocz(sizeof(MpegTSWriteStream));
899  if (!ts_st) {
900  ret = AVERROR(ENOMEM);
901  goto fail;
902  }
903  st->priv_data = ts_st;
904 
905  avpriv_set_pts_info(st, 33, 1, 90000);
906 
907  ts_st->payload = av_mallocz(ts->pes_payload_size);
908  if (!ts_st->payload) {
909  ret = AVERROR(ENOMEM);
910  goto fail;
911  }
912 
913  /* MPEG pid values < 16 are reserved. Applications which set st->id in
914  * this range are assigned a calculated pid. */
915  if (st->id < 16) {
916  ts_st->pid = ts->start_pid + i;
917  } else if (st->id < 0x1FFF) {
918  ts_st->pid = st->id;
919  } else {
920  av_log(s, AV_LOG_ERROR,
921  "Invalid stream id %d, must be less than 8191\n", st->id);
922  ret = AVERROR(EINVAL);
923  goto fail;
924  }
925  for (j = 0; j < ts->nb_services; j++) {
926  if (ts_st->pid == ts->services[j]->pmt.pid) {
927  av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
928  ret = AVERROR(EINVAL);
929  goto fail;
930  }
931  }
932  for (j = 0; j < i; j++) {
933  if (pids[j] == ts_st->pid) {
934  av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
935  ret = AVERROR(EINVAL);
936  goto fail;
937  }
938  }
939  pids[i] = ts_st->pid;
940  ts_st->payload_pts = AV_NOPTS_VALUE;
941  ts_st->payload_dts = AV_NOPTS_VALUE;
942  ts_st->first_pts_check = 1;
943  ts_st->cc = 15;
944  ts_st->discontinuity = ts->flags & MPEGTS_FLAG_DISCONT;
945  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
946  st->codecpar->extradata_size > 0) {
947  AVStream *ast;
948  ts_st->amux = avformat_alloc_context();
949  if (!ts_st->amux) {
950  ret = AVERROR(ENOMEM);
951  goto fail;
952  }
953  ts_st->amux->oformat =
954  av_guess_format((ts->flags & MPEGTS_FLAG_AAC_LATM) ? "latm" : "adts",
955  NULL, NULL);
956  if (!ts_st->amux->oformat) {
957  ret = AVERROR(EINVAL);
958  goto fail;
959  }
960  if (!(ast = avformat_new_stream(ts_st->amux, NULL))) {
961  ret = AVERROR(ENOMEM);
962  goto fail;
963  }
964  ret = avcodec_parameters_copy(ast->codecpar, st->codecpar);
965  if (ret != 0)
966  goto fail;
967  ast->time_base = st->time_base;
968  ret = avformat_write_header(ts_st->amux, NULL);
969  if (ret < 0)
970  goto fail;
971  }
972  if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
974  }
975  }
976 
977  av_freep(&pids);
978 
979  if (ts->copyts < 1)
981 
983 
988 
989  if (ts->mux_rate == 1)
990  av_log(s, AV_LOG_VERBOSE, "muxrate VBR, ");
991  else
992  av_log(s, AV_LOG_VERBOSE, "muxrate %d, ", ts->mux_rate);
994  "sdt every %"PRId64" ms, pat/pmt every %"PRId64" ms\n",
995  av_rescale(ts->sdt_period, 1000, PCR_TIME_BASE),
996  av_rescale(ts->pat_period, 1000, PCR_TIME_BASE));
997 
998  if (ts->m2ts_mode == -1) {
999  if (av_match_ext(s->url, "m2ts")) {
1000  ts->m2ts_mode = 1;
1001  } else {
1002  ts->m2ts_mode = 0;
1003  }
1004  }
1005 
1006  return 0;
1007 
1008 fail:
1009  av_freep(&pids);
1010  return ret;
1011 }
1012 
1013 /* send SDT, PAT and PMT tables regularly */
1014 static void retransmit_si_info(AVFormatContext *s, int force_pat, int force_sdt, int64_t pcr)
1015 {
1016  MpegTSWrite *ts = s->priv_data;
1017  int i;
1018 
1019  if ((pcr != AV_NOPTS_VALUE && ts->last_sdt_ts == AV_NOPTS_VALUE) ||
1020  (pcr != AV_NOPTS_VALUE && pcr - ts->last_sdt_ts >= ts->sdt_period) ||
1021  force_sdt
1022  ) {
1023  if (pcr != AV_NOPTS_VALUE)
1024  ts->last_sdt_ts = FFMAX(pcr, ts->last_sdt_ts);
1025  mpegts_write_sdt(s);
1026  }
1027  if ((pcr != AV_NOPTS_VALUE && ts->last_pat_ts == AV_NOPTS_VALUE) ||
1028  (pcr != AV_NOPTS_VALUE && pcr - ts->last_pat_ts >= ts->pat_period) ||
1029  force_pat) {
1030  if (pcr != AV_NOPTS_VALUE)
1031  ts->last_pat_ts = FFMAX(pcr, ts->last_pat_ts);
1032  mpegts_write_pat(s);
1033  for (i = 0; i < ts->nb_services; i++)
1034  mpegts_write_pmt(s, ts->services[i]);
1035  }
1036 }
1037 
1038 static int write_pcr_bits(uint8_t *buf, int64_t pcr)
1039 {
1040  int64_t pcr_low = pcr % 300, pcr_high = pcr / 300;
1041 
1042  *buf++ = pcr_high >> 25;
1043  *buf++ = pcr_high >> 17;
1044  *buf++ = pcr_high >> 9;
1045  *buf++ = pcr_high >> 1;
1046  *buf++ = pcr_high << 7 | pcr_low >> 8 | 0x7e;
1047  *buf++ = pcr_low;
1048 
1049  return 6;
1050 }
1051 
1052 /* Write a single null transport stream packet */
1054 {
1055  uint8_t *q;
1057 
1058  q = buf;
1059  *q++ = 0x47;
1060  *q++ = 0x00 | 0x1f;
1061  *q++ = 0xff;
1062  *q++ = 0x10;
1063  memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
1065  avio_write(s->pb, buf, TS_PACKET_SIZE);
1066 }
1067 
1068 /* Write a single transport stream packet with a PCR and no payload */
1070 {
1071  MpegTSWrite *ts = s->priv_data;
1072  MpegTSWriteStream *ts_st = st->priv_data;
1073  uint8_t *q;
1075 
1076  q = buf;
1077  *q++ = 0x47;
1078  *q++ = ts_st->pid >> 8;
1079  *q++ = ts_st->pid;
1080  *q++ = 0x20 | ts_st->cc; /* Adaptation only */
1081  /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
1082  *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */
1083  *q++ = 0x10; /* Adaptation flags: PCR present */
1084  if (ts_st->discontinuity) {
1085  q[-1] |= 0x80;
1086  ts_st->discontinuity = 0;
1087  }
1088 
1089  /* PCR coded into 6 bytes */
1090  q += write_pcr_bits(q, get_pcr(ts, s->pb));
1091 
1092  /* stuffing bytes */
1093  memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
1095  avio_write(s->pb, buf, TS_PACKET_SIZE);
1096 }
1097 
1098 static void write_pts(uint8_t *q, int fourbits, int64_t pts)
1099 {
1100  int val;
1101 
1102  val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1;
1103  *q++ = val;
1104  val = (((pts >> 15) & 0x7fff) << 1) | 1;
1105  *q++ = val >> 8;
1106  *q++ = val;
1107  val = (((pts) & 0x7fff) << 1) | 1;
1108  *q++ = val >> 8;
1109  *q++ = val;
1110 }
1111 
1112 /* Set an adaptation field flag in an MPEG-TS packet*/
1113 static void set_af_flag(uint8_t *pkt, int flag)
1114 {
1115  // expect at least one flag to set
1116  av_assert0(flag);
1117 
1118  if ((pkt[3] & 0x20) == 0) {
1119  // no AF yet, set adaptation field flag
1120  pkt[3] |= 0x20;
1121  // 1 byte length, no flags
1122  pkt[4] = 1;
1123  pkt[5] = 0;
1124  }
1125  pkt[5] |= flag;
1126 }
1127 
1128 /* Extend the adaptation field by size bytes */
1129 static void extend_af(uint8_t *pkt, int size)
1130 {
1131  // expect already existing adaptation field
1132  av_assert0(pkt[3] & 0x20);
1133  pkt[4] += size;
1134 }
1135 
1136 /* Get a pointer to MPEG-TS payload (right after TS packet header) */
1138 {
1139  if (pkt[3] & 0x20)
1140  return pkt + 5 + pkt[4];
1141  else
1142  return pkt + 4;
1143 }
1144 
1145 /* Add a PES header to the front of the payload, and segment into an integer
1146  * number of TS packets. The final TS packet is padded using an oversized
1147  * adaptation header to exactly fill the last TS packet.
1148  * NOTE: 'payload' contains a complete PES payload. */
1150  const uint8_t *payload, int payload_size,
1151  int64_t pts, int64_t dts, int key, int stream_id)
1152 {
1153  MpegTSWriteStream *ts_st = st->priv_data;
1154  MpegTSWrite *ts = s->priv_data;
1156  uint8_t *q;
1157  int val, is_start, len, header_len, write_pcr, is_dvb_subtitle, is_dvb_teletext, flags;
1158  int afc_len, stuffing_len;
1159  int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
1160  int force_pat = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && key && !ts_st->prev_payload_key;
1161  int force_sdt = 0;
1162 
1163  av_assert0(ts_st->payload != buf || st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO);
1165  force_pat = 1;
1166  }
1167 
1168  if (ts->flags & MPEGTS_FLAG_REEMIT_PAT_PMT) {
1169  force_pat = 1;
1170  force_sdt = 1;
1172  }
1173 
1174  is_start = 1;
1175  while (payload_size > 0) {
1176  int64_t pcr = AV_NOPTS_VALUE;
1177  if (ts->mux_rate > 1)
1178  pcr = get_pcr(ts, s->pb);
1179  else if (dts != AV_NOPTS_VALUE)
1180  pcr = (dts - delay) * 300;
1181 
1182  retransmit_si_info(s, force_pat, force_sdt, pcr);
1183  force_pat = 0;
1184  force_sdt = 0;
1185 
1186  write_pcr = 0;
1187  if (ts->mux_rate > 1) {
1188  /* Send PCR packets for all PCR streams if needed */
1189  pcr = get_pcr(ts, s->pb);
1190  if (pcr >= ts->next_pcr) {
1191  int64_t next_pcr = INT64_MAX;
1192  for (int i = 0; i < s->nb_streams; i++) {
1193  /* Make the current stream the last, because for that we
1194  * can insert the pcr into the payload later */
1195  int st2_index = i < st->index ? i : (i + 1 == s->nb_streams ? st->index : i + 1);
1196  AVStream *st2 = s->streams[st2_index];
1197  MpegTSWriteStream *ts_st2 = st2->priv_data;
1198  if (ts_st2->pcr_period) {
1199  if (pcr - ts_st2->last_pcr >= ts_st2->pcr_period) {
1200  ts_st2->last_pcr = FFMAX(pcr - ts_st2->pcr_period, ts_st2->last_pcr + ts_st2->pcr_period);
1201  if (st2 != st) {
1202  mpegts_insert_pcr_only(s, st2);
1203  pcr = get_pcr(ts, s->pb);
1204  } else {
1205  write_pcr = 1;
1206  }
1207  }
1208  next_pcr = FFMIN(next_pcr, ts_st2->last_pcr + ts_st2->pcr_period);
1209  }
1210  }
1211  ts->next_pcr = next_pcr;
1212  }
1213  if (dts != AV_NOPTS_VALUE && (dts - pcr / 300) > delay) {
1214  /* pcr insert gets priority over null packet insert */
1215  if (write_pcr)
1216  mpegts_insert_pcr_only(s, st);
1217  else
1219  /* recalculate write_pcr and possibly retransmit si_info */
1220  continue;
1221  }
1222  } else if (ts_st->pcr_period && pcr != AV_NOPTS_VALUE) {
1223  if (pcr - ts_st->last_pcr >= ts_st->pcr_period && is_start) {
1224  ts_st->last_pcr = FFMAX(pcr - ts_st->pcr_period, ts_st->last_pcr + ts_st->pcr_period);
1225  write_pcr = 1;
1226  }
1227  }
1228 
1229  /* prepare packet header */
1230  q = buf;
1231  *q++ = 0x47;
1232  val = ts_st->pid >> 8;
1233  if (is_start)
1234  val |= 0x40;
1235  *q++ = val;
1236  *q++ = ts_st->pid;
1237  ts_st->cc = ts_st->cc + 1 & 0xf;
1238  *q++ = 0x10 | ts_st->cc; // payload indicator + CC
1239  if (ts_st->discontinuity) {
1240  set_af_flag(buf, 0x80);
1241  q = get_ts_payload_start(buf);
1242  ts_st->discontinuity = 0;
1243  }
1244  if (key && is_start && pts != AV_NOPTS_VALUE) {
1245  // set Random Access for key frames
1246  if (ts_st->pcr_period)
1247  write_pcr = 1;
1248  set_af_flag(buf, 0x40);
1249  q = get_ts_payload_start(buf);
1250  }
1251  if (write_pcr) {
1252  set_af_flag(buf, 0x10);
1253  q = get_ts_payload_start(buf);
1254  // add 11, pcr references the last byte of program clock reference base
1255  if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
1256  av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
1257  extend_af(buf, write_pcr_bits(q, pcr));
1258  q = get_ts_payload_start(buf);
1259  }
1260  if (is_start) {
1261  int pes_extension = 0;
1262  int pes_header_stuffing_bytes = 0;
1263  /* write PES header */
1264  *q++ = 0x00;
1265  *q++ = 0x00;
1266  *q++ = 0x01;
1267  is_dvb_subtitle = 0;
1268  is_dvb_teletext = 0;
1269  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1270  if (st->codecpar->codec_id == AV_CODEC_ID_DIRAC)
1271  *q++ = 0xfd;
1272  else
1273  *q++ = 0xe0;
1274  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1275  (st->codecpar->codec_id == AV_CODEC_ID_MP2 ||
1276  st->codecpar->codec_id == AV_CODEC_ID_MP3 ||
1277  st->codecpar->codec_id == AV_CODEC_ID_AAC)) {
1278  *q++ = 0xc0;
1279  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1280  st->codecpar->codec_id == AV_CODEC_ID_AC3 &&
1281  ts->m2ts_mode) {
1282  *q++ = 0xfd;
1283  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA &&
1285  *q++ = 0xbd;
1286  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
1287  *q++ = stream_id != -1 ? stream_id : 0xfc;
1288 
1289  if (stream_id == 0xbd) /* asynchronous KLV */
1290  pts = dts = AV_NOPTS_VALUE;
1291  } else {
1292  *q++ = 0xbd;
1295  is_dvb_subtitle = 1;
1296  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT) {
1297  is_dvb_teletext = 1;
1298  }
1299  }
1300  }
1301  header_len = 0;
1302  flags = 0;
1303  if (pts != AV_NOPTS_VALUE) {
1304  header_len += 5;
1305  flags |= 0x80;
1306  }
1307  if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1308  header_len += 5;
1309  flags |= 0x40;
1310  }
1311  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1313  /* set PES_extension_flag */
1314  pes_extension = 1;
1315  flags |= 0x01;
1316 
1317  /* One byte for PES2 extension flag +
1318  * one byte for extension length +
1319  * one byte for extension id */
1320  header_len += 3;
1321  }
1322  /* for Blu-ray AC3 Audio the PES Extension flag should be as follow
1323  * otherwise it will not play sound on blu-ray
1324  */
1325  if (ts->m2ts_mode &&
1327  st->codecpar->codec_id == AV_CODEC_ID_AC3) {
1328  /* set PES_extension_flag */
1329  pes_extension = 1;
1330  flags |= 0x01;
1331  header_len += 3;
1332  }
1333  if (is_dvb_teletext) {
1334  pes_header_stuffing_bytes = 0x24 - header_len;
1335  header_len = 0x24;
1336  }
1337  len = payload_size + header_len + 3;
1338  /* 3 extra bytes should be added to DVB subtitle payload: 0x20 0x00 at the beginning and trailing 0xff */
1339  if (is_dvb_subtitle) {
1340  len += 3;
1341  payload_size++;
1342  }
1343  if (len > 0xffff)
1344  len = 0;
1346  len = 0;
1347  }
1348  *q++ = len >> 8;
1349  *q++ = len;
1350  val = 0x80;
1351  /* data alignment indicator is required for subtitle and data streams */
1353  val |= 0x04;
1354  *q++ = val;
1355  *q++ = flags;
1356  *q++ = header_len;
1357  if (pts != AV_NOPTS_VALUE) {
1358  write_pts(q, flags >> 6, pts);
1359  q += 5;
1360  }
1361  if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1362  write_pts(q, 1, dts);
1363  q += 5;
1364  }
1365  if (pes_extension && st->codecpar->codec_id == AV_CODEC_ID_DIRAC) {
1366  flags = 0x01; /* set PES_extension_flag_2 */
1367  *q++ = flags;
1368  *q++ = 0x80 | 0x01; /* marker bit + extension length */
1369  /* Set the stream ID extension flag bit to 0 and
1370  * write the extended stream ID. */
1371  *q++ = 0x00 | 0x60;
1372  }
1373  /* For Blu-ray AC3 Audio Setting extended flags */
1374  if (ts->m2ts_mode &&
1375  pes_extension &&
1376  st->codecpar->codec_id == AV_CODEC_ID_AC3) {
1377  flags = 0x01; /* set PES_extension_flag_2 */
1378  *q++ = flags;
1379  *q++ = 0x80 | 0x01; /* marker bit + extension length */
1380  *q++ = 0x00 | 0x71; /* for AC3 Audio (specifically on blue-rays) */
1381  }
1382 
1383 
1384  if (is_dvb_subtitle) {
1385  /* First two fields of DVB subtitles PES data:
1386  * data_identifier: for DVB subtitle streams shall be coded with the value 0x20
1387  * subtitle_stream_id: for DVB subtitle stream shall be identified by the value 0x00 */
1388  *q++ = 0x20;
1389  *q++ = 0x00;
1390  }
1391  if (is_dvb_teletext) {
1392  memset(q, 0xff, pes_header_stuffing_bytes);
1393  q += pes_header_stuffing_bytes;
1394  }
1395  is_start = 0;
1396  }
1397  /* header size */
1398  header_len = q - buf;
1399  /* data len */
1400  len = TS_PACKET_SIZE - header_len;
1401  if (len > payload_size)
1402  len = payload_size;
1403  stuffing_len = TS_PACKET_SIZE - header_len - len;
1404  if (stuffing_len > 0) {
1405  /* add stuffing with AFC */
1406  if (buf[3] & 0x20) {
1407  /* stuffing already present: increase its size */
1408  afc_len = buf[4] + 1;
1409  memmove(buf + 4 + afc_len + stuffing_len,
1410  buf + 4 + afc_len,
1411  header_len - (4 + afc_len));
1412  buf[4] += stuffing_len;
1413  memset(buf + 4 + afc_len, 0xff, stuffing_len);
1414  } else {
1415  /* add stuffing */
1416  memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4);
1417  buf[3] |= 0x20;
1418  buf[4] = stuffing_len - 1;
1419  if (stuffing_len >= 2) {
1420  buf[5] = 0x00;
1421  memset(buf + 6, 0xff, stuffing_len - 2);
1422  }
1423  }
1424  }
1425 
1426  if (is_dvb_subtitle && payload_size == len) {
1427  memcpy(buf + TS_PACKET_SIZE - len, payload, len - 1);
1428  buf[TS_PACKET_SIZE - 1] = 0xff; /* end_of_PES_data_field_marker: an 8-bit field with fixed contents 0xff for DVB subtitle */
1429  } else {
1430  memcpy(buf + TS_PACKET_SIZE - len, payload, len);
1431  }
1432 
1433  payload += len;
1434  payload_size -= len;
1436  avio_write(s->pb, buf, TS_PACKET_SIZE);
1437  }
1438  ts_st->prev_payload_key = key;
1439 }
1440 
1442 {
1443  if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001 && AV_RB24(pkt->data) != 0x000001) {
1444  if (!st->nb_frames) {
1445  av_log(s, AV_LOG_ERROR, "H.264 bitstream malformed, "
1446  "no startcode found, use the video bitstream filter 'h264_mp4toannexb' to fix it "
1447  "('-bsf:v h264_mp4toannexb' option with ffmpeg)\n");
1448  return AVERROR_INVALIDDATA;
1449  }
1450  av_log(s, AV_LOG_WARNING, "H.264 bitstream error, startcode missing, size %d", pkt->size);
1451  if (pkt->size)
1452  av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
1453  av_log(s, AV_LOG_WARNING, "\n");
1454  }
1455  return 0;
1456 }
1457 
1459 {
1460  if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001 && AV_RB24(pkt->data) != 0x000001) {
1461  if (!st->nb_frames) {
1462  av_log(s, AV_LOG_ERROR, "HEVC bitstream malformed, no startcode found\n");
1463  return AVERROR_PATCHWELCOME;
1464  }
1465  av_log(s, AV_LOG_WARNING, "HEVC bitstream error, startcode missing, size %d", pkt->size);
1466  if (pkt->size)
1467  av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
1468  av_log(s, AV_LOG_WARNING, "\n");
1469  }
1470  return 0;
1471 }
1472 
1473 /* Based on GStreamer's gst-plugins-base/ext/ogg/gstoggstream.c
1474  * Released under the LGPL v2.1+, written by
1475  * Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
1476  */
1478 {
1479  static const int durations[32] = {
1480  480, 960, 1920, 2880, /* Silk NB */
1481  480, 960, 1920, 2880, /* Silk MB */
1482  480, 960, 1920, 2880, /* Silk WB */
1483  480, 960, /* Hybrid SWB */
1484  480, 960, /* Hybrid FB */
1485  120, 240, 480, 960, /* CELT NB */
1486  120, 240, 480, 960, /* CELT NB */
1487  120, 240, 480, 960, /* CELT NB */
1488  120, 240, 480, 960, /* CELT NB */
1489  };
1490  int toc, frame_duration, nframes, duration;
1491 
1492  if (pkt->size < 1)
1493  return 0;
1494 
1495  toc = pkt->data[0];
1496 
1497  frame_duration = durations[toc >> 3];
1498  switch (toc & 3) {
1499  case 0:
1500  nframes = 1;
1501  break;
1502  case 1:
1503  nframes = 2;
1504  break;
1505  case 2:
1506  nframes = 2;
1507  break;
1508  case 3:
1509  if (pkt->size < 2)
1510  return 0;
1511  nframes = pkt->data[1] & 63;
1512  break;
1513  }
1514 
1515  duration = nframes * frame_duration;
1516  if (duration > 5760) {
1518  "Opus packet duration > 120 ms, invalid");
1519  return 0;
1520  }
1521 
1522  return duration;
1523 }
1524 
1526 {
1527  AVStream *st = s->streams[pkt->stream_index];
1528  int size = pkt->size;
1529  uint8_t *buf = pkt->data;
1530  uint8_t *data = NULL;
1531  MpegTSWrite *ts = s->priv_data;
1532  MpegTSWriteStream *ts_st = st->priv_data;
1533  const int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) * 2;
1534  const int64_t max_audio_delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) / 2;
1535  int64_t dts = pkt->dts, pts = pkt->pts;
1536  int opus_samples = 0;
1537  int side_data_size;
1538  uint8_t *side_data = NULL;
1539  int stream_id = -1;
1540 
1541  side_data = av_packet_get_side_data(pkt,
1543  &side_data_size);
1544  if (side_data)
1545  stream_id = side_data[0];
1546 
1547  if (ts->copyts < 1) {
1548  if (pts != AV_NOPTS_VALUE)
1549  pts += delay;
1550  if (dts != AV_NOPTS_VALUE)
1551  dts += delay;
1552  }
1553 
1554  if (ts_st->first_pts_check && pts == AV_NOPTS_VALUE) {
1555  av_log(s, AV_LOG_ERROR, "first pts value must be set\n");
1556  return AVERROR_INVALIDDATA;
1557  }
1558  ts_st->first_pts_check = 0;
1559 
1560  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
1561  const uint8_t *p = buf, *buf_end = p + size;
1562  uint32_t state = -1;
1563  int extradd = (pkt->flags & AV_PKT_FLAG_KEY) ? st->codecpar->extradata_size : 0;
1564  int ret = ff_check_h264_startcode(s, st, pkt);
1565  if (ret < 0)
1566  return ret;
1567 
1568  if (extradd && AV_RB24(st->codecpar->extradata) > 1)
1569  extradd = 0;
1570 
1571  do {
1572  p = avpriv_find_start_code(p, buf_end, &state);
1573  av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", state & 0x1f);
1574  if ((state & 0x1f) == 7)
1575  extradd = 0;
1576  } while (p < buf_end && (state & 0x1f) != 9 &&
1577  (state & 0x1f) != 5 && (state & 0x1f) != 1);
1578 
1579  if ((state & 0x1f) != 5)
1580  extradd = 0;
1581  if ((state & 0x1f) != 9) { // AUD NAL
1582  data = av_malloc(pkt->size + 6 + extradd);
1583  if (!data)
1584  return AVERROR(ENOMEM);
1585  memcpy(data + 6, st->codecpar->extradata, extradd);
1586  memcpy(data + 6 + extradd, pkt->data, pkt->size);
1587  AV_WB32(data, 0x00000001);
1588  data[4] = 0x09;
1589  data[5] = 0xf0; // any slice type (0xe) + rbsp stop one bit
1590  buf = data;
1591  size = pkt->size + 6 + extradd;
1592  }
1593  } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1594  if (pkt->size < 2) {
1595  av_log(s, AV_LOG_ERROR, "AAC packet too short\n");
1596  return AVERROR_INVALIDDATA;
1597  }
1598  if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) {
1599  int ret;
1600  AVPacket pkt2;
1601 
1602  if (!ts_st->amux) {
1603  av_log(s, AV_LOG_ERROR, "AAC bitstream not in ADTS format "
1604  "and extradata missing\n");
1605  } else {
1606  av_init_packet(&pkt2);
1607  pkt2.data = pkt->data;
1608  pkt2.size = pkt->size;
1609  av_assert0(pkt->dts != AV_NOPTS_VALUE);
1610  pkt2.dts = av_rescale_q(pkt->dts, st->time_base, ts_st->amux->streams[0]->time_base);
1611 
1612  ret = avio_open_dyn_buf(&ts_st->amux->pb);
1613  if (ret < 0)
1614  return AVERROR(ENOMEM);
1615 
1616  ret = av_write_frame(ts_st->amux, &pkt2);
1617  if (ret < 0) {
1618  ffio_free_dyn_buf(&ts_st->amux->pb);
1619  return ret;
1620  }
1621  size = avio_close_dyn_buf(ts_st->amux->pb, &data);
1622  ts_st->amux->pb = NULL;
1623  buf = data;
1624  }
1625  }
1626  } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
1627  const uint8_t *p = buf, *buf_end = p + size;
1628  uint32_t state = -1;
1629  int extradd = (pkt->flags & AV_PKT_FLAG_KEY) ? st->codecpar->extradata_size : 0;
1630  int ret = check_hevc_startcode(s, st, pkt);
1631  if (ret < 0)
1632  return ret;
1633 
1634  if (extradd && AV_RB24(st->codecpar->extradata) > 1)
1635  extradd = 0;
1636 
1637  do {
1638  p = avpriv_find_start_code(p, buf_end, &state);
1639  av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", (state & 0x7e)>>1);
1640  if ((state & 0x7e) == 2*32)
1641  extradd = 0;
1642  } while (p < buf_end && (state & 0x7e) != 2*35 &&
1643  (state & 0x7e) >= 2*32);
1644 
1645  if ((state & 0x7e) < 2*16 && (state & 0x7e) >= 2*24)
1646  extradd = 0;
1647  if ((state & 0x7e) != 2*35) { // AUD NAL
1648  data = av_malloc(pkt->size + 7 + extradd);
1649  if (!data)
1650  return AVERROR(ENOMEM);
1651  memcpy(data + 7, st->codecpar->extradata, extradd);
1652  memcpy(data + 7 + extradd, pkt->data, pkt->size);
1653  AV_WB32(data, 0x00000001);
1654  data[4] = 2*35;
1655  data[5] = 1;
1656  data[6] = 0x50; // any slice type (0x4) + rbsp stop one bit
1657  buf = data;
1658  size = pkt->size + 7 + extradd;
1659  }
1660  } else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
1661  if (pkt->size < 2) {
1662  av_log(s, AV_LOG_ERROR, "Opus packet too short\n");
1663  return AVERROR_INVALIDDATA;
1664  }
1665 
1666  /* Add Opus control header */
1667  if ((AV_RB16(pkt->data) >> 5) != 0x3ff) {
1668  uint8_t *side_data;
1669  int side_data_size;
1670  int i, n;
1671  int ctrl_header_size;
1672  int trim_start = 0, trim_end = 0;
1673 
1674  opus_samples = opus_get_packet_samples(s, pkt);
1675 
1676  side_data = av_packet_get_side_data(pkt,
1678  &side_data_size);
1679 
1680  if (side_data && side_data_size >= 10) {
1681  trim_end = AV_RL32(side_data + 4) * 48000 / st->codecpar->sample_rate;
1682  }
1683 
1684  ctrl_header_size = pkt->size + 2 + pkt->size / 255 + 1;
1685  if (ts_st->opus_pending_trim_start)
1686  ctrl_header_size += 2;
1687  if (trim_end)
1688  ctrl_header_size += 2;
1689 
1690  data = av_malloc(ctrl_header_size);
1691  if (!data)
1692  return AVERROR(ENOMEM);
1693 
1694  data[0] = 0x7f;
1695  data[1] = 0xe0;
1696  if (ts_st->opus_pending_trim_start)
1697  data[1] |= 0x10;
1698  if (trim_end)
1699  data[1] |= 0x08;
1700 
1701  n = pkt->size;
1702  i = 2;
1703  do {
1704  data[i] = FFMIN(n, 255);
1705  n -= 255;
1706  i++;
1707  } while (n >= 0);
1708 
1709  av_assert0(2 + pkt->size / 255 + 1 == i);
1710 
1711  if (ts_st->opus_pending_trim_start) {
1712  trim_start = FFMIN(ts_st->opus_pending_trim_start, opus_samples);
1713  AV_WB16(data + i, trim_start);
1714  i += 2;
1715  ts_st->opus_pending_trim_start -= trim_start;
1716  }
1717  if (trim_end) {
1718  trim_end = FFMIN(trim_end, opus_samples - trim_start);
1719  AV_WB16(data + i, trim_end);
1720  i += 2;
1721  }
1722 
1723  memcpy(data + i, pkt->data, pkt->size);
1724  buf = data;
1725  size = ctrl_header_size;
1726  } else {
1727  /* TODO: Can we get TS formatted data here? If so we will
1728  * need to count the samples of that too! */
1729  av_log(s, AV_LOG_WARNING, "Got MPEG-TS formatted Opus data, unhandled");
1730  }
1731  }
1732 
1733  if (ts_st->payload_size && (ts_st->payload_size + size > ts->pes_payload_size ||
1734  (dts != AV_NOPTS_VALUE && ts_st->payload_dts != AV_NOPTS_VALUE &&
1735  dts - ts_st->payload_dts >= max_audio_delay) ||
1736  ts_st->opus_queued_samples + opus_samples >= 5760 /* 120ms */)) {
1737  mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
1738  ts_st->payload_pts, ts_st->payload_dts,
1739  ts_st->payload_flags & AV_PKT_FLAG_KEY, stream_id);
1740  ts_st->payload_size = 0;
1741  ts_st->opus_queued_samples = 0;
1742  }
1743 
1744  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || size > ts->pes_payload_size) {
1745  av_assert0(!ts_st->payload_size);
1746  // for video and subtitle, write a single pes packet
1747  mpegts_write_pes(s, st, buf, size, pts, dts,
1748  pkt->flags & AV_PKT_FLAG_KEY, stream_id);
1749  ts_st->opus_queued_samples = 0;
1750  av_free(data);
1751  return 0;
1752  }
1753 
1754  if (!ts_st->payload_size) {
1755  ts_st->payload_pts = pts;
1756  ts_st->payload_dts = dts;
1757  ts_st->payload_flags = pkt->flags;
1758  }
1759 
1760  memcpy(ts_st->payload + ts_st->payload_size, buf, size);
1761  ts_st->payload_size += size;
1762  ts_st->opus_queued_samples += opus_samples;
1763 
1764  av_free(data);
1765 
1766  return 0;
1767 }
1768 
1770 {
1771  int i;
1772 
1773  /* flush current packets */
1774  for (i = 0; i < s->nb_streams; i++) {
1775  AVStream *st = s->streams[i];
1776  MpegTSWriteStream *ts_st = st->priv_data;
1777  if (ts_st->payload_size > 0) {
1778  mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
1779  ts_st->payload_pts, ts_st->payload_dts,
1780  ts_st->payload_flags & AV_PKT_FLAG_KEY, -1);
1781  ts_st->payload_size = 0;
1782  ts_st->opus_queued_samples = 0;
1783  }
1784  }
1785 }
1786 
1788 {
1789  if (!pkt) {
1790  mpegts_write_flush(s);
1791  return 1;
1792  } else {
1793  return mpegts_write_packet_internal(s, pkt);
1794  }
1795 }
1796 
1798 {
1799  if (s->pb)
1800  mpegts_write_flush(s);
1801 
1802  return 0;
1803 }
1804 
1806 {
1807  MpegTSWrite *ts = s->priv_data;
1808  MpegTSService *service;
1809  int i;
1810 
1811  for (i = 0; i < s->nb_streams; i++) {
1812  AVStream *st = s->streams[i];
1813  MpegTSWriteStream *ts_st = st->priv_data;
1814  if (ts_st) {
1815  av_freep(&ts_st->payload);
1816  if (ts_st->amux) {
1817  avformat_free_context(ts_st->amux);
1818  ts_st->amux = NULL;
1819  }
1820  }
1821  }
1822 
1823  for (i = 0; i < ts->nb_services; i++) {
1824  service = ts->services[i];
1825  av_freep(&service);
1826  }
1827  av_freep(&ts->services);
1828 }
1829 
1831 {
1832  int ret = 1;
1833  AVStream *st = s->streams[pkt->stream_index];
1834 
1835  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
1836  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
1837  (AV_RB24(pkt->data) != 0x000001 ||
1838  (st->codecpar->extradata_size > 0 &&
1839  st->codecpar->extradata[0] == 1)))
1840  ret = ff_stream_add_bitstream_filter(st, "h264_mp4toannexb", NULL);
1841  } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
1842  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
1843  (AV_RB24(pkt->data) != 0x000001 ||
1844  (st->codecpar->extradata_size > 0 &&
1845  st->codecpar->extradata[0] == 1)))
1846  ret = ff_stream_add_bitstream_filter(st, "hevc_mp4toannexb", NULL);
1847  }
1848 
1849  return ret;
1850 }
1851 
1852 static const AVOption options[] = {
1853  { "mpegts_transport_stream_id", "Set transport_stream_id field.",
1854  offsetof(MpegTSWrite, transport_stream_id), AV_OPT_TYPE_INT,
1855  { .i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM },
1856  { "mpegts_original_network_id", "Set original_network_id field.",
1857  offsetof(MpegTSWrite, original_network_id), AV_OPT_TYPE_INT,
1858  { .i64 = DVB_PRIVATE_NETWORK_START }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM },
1859  { "mpegts_service_id", "Set service_id field.",
1860  offsetof(MpegTSWrite, service_id), AV_OPT_TYPE_INT,
1861  { .i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM },
1862  { "mpegts_service_type", "Set service_type field.",
1863  offsetof(MpegTSWrite, service_type), AV_OPT_TYPE_INT,
1864  { .i64 = 0x01 }, 0x01, 0xff, AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1865  { "digital_tv", "Digital Television.",
1866  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_DIGITAL_TV }, 0x01, 0xff,
1867  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1868  { "digital_radio", "Digital Radio.",
1869  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_DIGITAL_RADIO }, 0x01, 0xff,
1870  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1871  { "teletext", "Teletext.",
1872  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_TELETEXT }, 0x01, 0xff,
1873  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1874  { "advanced_codec_digital_radio", "Advanced Codec Digital Radio.",
1876  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1877  { "mpeg2_digital_hdtv", "MPEG2 Digital HDTV.",
1878  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_MPEG2_DIGITAL_HDTV }, 0x01, 0xff,
1879  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1880  { "advanced_codec_digital_sdtv", "Advanced Codec Digital SDTV.",
1882  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1883  { "advanced_codec_digital_hdtv", "Advanced Codec Digital HDTV.",
1885  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1886  { "hevc_digital_hdtv", "HEVC Digital Television Service.",
1887  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_HEVC_DIGITAL_HDTV }, 0x01, 0xff,
1888  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1889  { "mpegts_pmt_start_pid", "Set the first pid of the PMT.",
1890  offsetof(MpegTSWrite, pmt_start_pid), AV_OPT_TYPE_INT,
1891  { .i64 = 0x1000 }, 0x0010, 0x1f00, AV_OPT_FLAG_ENCODING_PARAM },
1892  { "mpegts_start_pid", "Set the first pid.",
1893  offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT,
1894  { .i64 = 0x0100 }, 0x0010, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM },
1895  { "mpegts_m2ts_mode", "Enable m2ts mode.",
1896  offsetof(MpegTSWrite, m2ts_mode), AV_OPT_TYPE_BOOL,
1897  { .i64 = -1 }, -1, 1, AV_OPT_FLAG_ENCODING_PARAM },
1898  { "muxrate", NULL,
1899  offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT,
1900  { .i64 = 1 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1901  { "pes_payload_size", "Minimum PES packet payload in bytes",
1902  offsetof(MpegTSWrite, pes_payload_size), AV_OPT_TYPE_INT,
1903  { .i64 = DEFAULT_PES_PAYLOAD_SIZE }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1904  { "mpegts_flags", "MPEG-TS muxing flags",
1905  offsetof(MpegTSWrite, flags), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, 0, INT_MAX,
1906  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1907  { "resend_headers", "Reemit PAT/PMT before writing the next packet",
1908  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_REEMIT_PAT_PMT }, 0, INT_MAX,
1909  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1910  { "latm", "Use LATM packetization for AAC",
1911  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_AAC_LATM }, 0, INT_MAX,
1912  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1913  { "pat_pmt_at_frames", "Reemit PAT and PMT at each video frame",
1914  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_PAT_PMT_AT_FRAMES}, 0, INT_MAX,
1915  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1916  { "system_b", "Conform to System B (DVB) instead of System A (ATSC)",
1917  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_SYSTEM_B }, 0, INT_MAX,
1918  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1919  { "initial_discontinuity", "Mark initial packets as discontinuous",
1920  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_DISCONT }, 0, INT_MAX,
1921  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1922  { "mpegts_copyts", "don't offset dts/pts",
1923  offsetof(MpegTSWrite, copyts), AV_OPT_TYPE_BOOL,
1924  { .i64 = -1 }, -1, 1, AV_OPT_FLAG_ENCODING_PARAM },
1925  { "tables_version", "set PAT, PMT and SDT version",
1926  offsetof(MpegTSWrite, tables_version), AV_OPT_TYPE_INT,
1927  { .i64 = 0 }, 0, 31, AV_OPT_FLAG_ENCODING_PARAM },
1928  { "omit_video_pes_length", "Omit the PES packet length for video packets",
1929  offsetof(MpegTSWrite, omit_video_pes_length), AV_OPT_TYPE_BOOL,
1930  { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
1931  { "pcr_period", "PCR retransmission time in milliseconds",
1932  offsetof(MpegTSWrite, pcr_period_ms), AV_OPT_TYPE_INT,
1933  { .i64 = -1 }, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1934  { "pat_period", "PAT/PMT retransmission time limit in seconds",
1935  offsetof(MpegTSWrite, pat_period_us), AV_OPT_TYPE_DURATION,
1936  { .i64 = PAT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1937  { "sdt_period", "SDT retransmission time limit in seconds",
1938  offsetof(MpegTSWrite, sdt_period_us), AV_OPT_TYPE_DURATION,
1939  { .i64 = SDT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1940  { NULL },
1941 };
1942 
1943 static const AVClass mpegts_muxer_class = {
1944  .class_name = "MPEGTS muxer",
1945  .item_name = av_default_item_name,
1946  .option = options,
1947  .version = LIBAVUTIL_VERSION_INT,
1948 };
1949 
1951  .name = "mpegts",
1952  .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
1953  .mime_type = "video/MP2T",
1954  .extensions = "ts,m2t,m2ts,mts",
1955  .priv_data_size = sizeof(MpegTSWrite),
1956  .audio_codec = AV_CODEC_ID_MP2,
1957  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1958  .init = mpegts_init,
1961  .deinit = mpegts_deinit,
1962  .check_bitstream = mpegts_check_bitstream,
1964  .priv_class = &mpegts_muxer_class,
1965 };
#define NULL
Definition: coverity.c:32
#define SDT_PID
Definition: mpegts.h:43
const char const char void * val
Definition: avisynth_c.h:863
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define PMT_TID
Definition: mpegts.h:69
#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:385
#define SECTION_LENGTH
Definition: mpegtsenc.c:121
#define STREAM_TYPE_AUDIO_MPEG2
Definition: mpeg.h:52
uint8_t provider_name[256]
Definition: mpegtsenc.c:58
MpegTSSection pmt
Definition: mpegtsenc.c:55
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1459
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:878
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void avpriv_set_pts_info(AVStream *s, 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:4926
static void retransmit_si_info(AVFormatContext *s, int force_pat, int force_sdt, int64_t pcr)
Definition: mpegtsenc.c:1014
#define STREAM_TYPE_VIDEO_CAVS
Definition: mpeg.h:59
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static void put_registration_descriptor(uint8_t **q_ptr, uint32_t tag)
Definition: mpegtsenc.c:269
int64_t payload_dts
Definition: mpegtsenc.c:233
static int mpegts_init(AVFormatContext *s)
Definition: mpegtsenc.c:846
int64_t sdt_period_us
Definition: mpegtsenc.c:108
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3968
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1481
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
int64_t last_sdt_ts
Definition: mpegtsenc.c:110
#define PCR_TIME_BASE
Definition: mpegtsenc.c:37
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:839
#define STREAM_TYPE_AUDIO_EAC3
Definition: mpegts.h:126
void * priv_data
Definition: avformat.h:896
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:841
const char * key
int version
Definition: avisynth_c.h:858
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
#define PCR_RETRANS_TIME
Definition: mpegtsenc.c:223
static AVPacket pkt
int64_t first_pcr
Definition: mpegtsenc.c:84
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:87
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:476
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1430
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1666
Format I/O context.
Definition: avformat.h:1358
#define MPEGTS_FLAG_DISCONT
Definition: mpegtsenc.c:103
int first_pts_check
first pts check needed
Definition: mpegtsenc.c:230
static void enable_pcr_generation_for_stream(AVFormatContext *s, AVStream *pcr_st)
Definition: mpegtsenc.c:786
unsigned int nb_stream_indexes
Definition: avformat.h:1280
#define SDT_RETRANS_TIME
Definition: mpegtsenc.c:221
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:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
static int mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
Definition: mpegtsenc.c:281
int64_t last_pcr
Definition: mpegtsenc.c:239
int64_t payload_pts
Definition: mpegtsenc.c:232
uint8_t
Round toward +infinity.
Definition: mathematics.h:83
static int nb_streams
Definition: ffprobe.c:280
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:203
AVOptions.
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
void * opaque
Definition: mpegtsenc.c:51
int64_t pat_period_us
Definition: mpegtsenc.c:107
#define DEFAULT_PES_PAYLOAD_SIZE
Definition: mpegtsenc.c:117
int id
Format-specific stream ID.
Definition: avformat.h:888
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
#define STREAM_TYPE_VIDEO_HEVC
Definition: mpeg.h:58
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4499
static int mpegts_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
Definition: mpegtsenc.c:1830
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:87
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int64_t duration
Definition: movenc.c:63
#define TS_PACKET_SIZE
Definition: mpegts.h:29
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpegtsenc.c:1787
Public header for CRC hash function implementation.
static int encode_str8(uint8_t *buf, const char *str)
Definition: mpegtsenc.c:684
int initial_padding
Audio only.
Definition: avcodec.h:4097
int omit_video_pes_length
Definition: mpegtsenc.c:112
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
static void mpegts_insert_null_packet(AVFormatContext *s)
Definition: mpegtsenc.c:1053
uint8_t * data
Definition: avcodec.h:1480
uint32_t tag
Definition: movenc.c:1531
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
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
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:294
static void mpegts_write_sdt(AVFormatContext *s)
Definition: mpegtsenc.c:642
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
#define STREAM_TYPE_VIDEO_VC1
Definition: mpegts.h:120
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
static void extend_af(uint8_t *pkt, int size)
Definition: mpegtsenc.c:1129
unsigned int * stream_index
Definition: avformat.h:1279
#define MPEGTS_FLAG_AAC_LATM
Definition: mpegtsenc.c:100
#define av_log(a,...)
#define PAT_TID
Definition: mpegts.h:67
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
#define STREAM_TYPE_AUDIO_AAC
Definition: mpeg.h:55
MPEGTS stream ID as uint8_t, this is required to pass the stream ID information from the demuxer to t...
Definition: avcodec.h:1362
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
#define STREAM_TYPE_AUDIO_DTS
Definition: mpegts.h:124
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:1149
static void mpegts_prefix_m2ts_header(AVFormatContext *s)
Definition: mpegtsenc.c:722
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2035
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
AVProgram * program
Definition: mpegtsenc.c:60
static void put16(uint8_t **q_ptr, int val)
Definition: mpegtsenc.c:178
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:187
static void write_pts(uint8_t *q, int fourbits, int64_t pts)
Definition: mpegtsenc.c:1098
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
int pes_payload_size
Definition: mpegtsenc.c:87
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static uint8_t * get_ts_payload_start(uint8_t *pkt)
Definition: mpegtsenc.c:1137
char * url
input or output URL.
Definition: avformat.h:1454
unsigned int nb_programs
Definition: avformat.h:1537
#define STREAM_TYPE_VIDEO_DIRAC
Definition: mpegts.h:121
static void set_af_flag(uint8_t *pkt, int flag)
Definition: mpegtsenc.c:1113
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:566
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
Definition: mpegtsenc.c:1069
simple assert() macros that are a bit more flexible than ISO C assert().
int nb_services
Definition: mpegtsenc.c:81
#define PAT_RETRANS_TIME
Definition: mpegtsenc.c:222
int mux_rate
set to 1 when VBR
Definition: mpegtsenc.c:86
static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
Definition: mpegtsenc.c:1525
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1275
static int write_pcr_bits(uint8_t *buf, int64_t pcr)
Definition: mpegtsenc.c:1038
#define FFMAX(a, b)
Definition: common.h:94
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:1741
static void select_pcr_streams(AVFormatContext *s)
Definition: mpegtsenc.c:817
#define fail()
Definition: checkasm.h:122
#define MPEGTS_FLAG_SYSTEM_B
Definition: mpegtsenc.c:102
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3986
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
#define STREAM_TYPE_AUDIO_AAC_LATM
Definition: mpegts.h:114
int ff_check_h264_startcode(AVFormatContext *s, const AVStream *st, const AVPacket *pkt)
Check presence of H264 startcode.
Definition: mpegtsenc.c:1441
static const AVOption options[]
Definition: mpegtsenc.c:1852
#define b
Definition: input.c:41
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
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:508
#define FFMIN(a, b)
Definition: common.h:96
#define STREAM_TYPE_VIDEO_H264
Definition: mpeg.h:57
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
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:3
const char * name
Definition: avformat.h:505
#define DEFAULT_PROVIDER_NAME
Definition: mpegtsenc.c:217
AVFormatContext * ctx
Definition: movenc.c:48
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
int discontinuity
Definition: mpegtsenc.c:49
int64_t next_pcr
Definition: mpegtsenc.c:85
static int check_hevc_startcode(AVFormatContext *s, const AVStream *st, const AVPacket *pkt)
Definition: mpegtsenc.c:1458
static MpegTSService * mpegts_add_service(AVFormatContext *s, int sid, const AVDictionary *metadata, AVProgram *program)
Definition: mpegtsenc.c:741
#define s(width, name)
Definition: cbs_vp9.c:257
AVOutputFormat ff_mpegts_muxer
Definition: mpegtsenc.c:1950
int n
Definition: avisynth_c.h:760
AVFormatContext * amux
Definition: mpegtsenc.c:236
AVDictionary * metadata
Definition: avformat.h:945
#define MPEGTS_FLAG_REEMIT_PAT_PMT
Definition: mpegtsenc.c:99
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
#define STREAM_TYPE_VIDEO_MPEG4
Definition: mpeg.h:56
static void mpegts_deinit(AVFormatContext *s)
Definition: mpegtsenc.c:1805
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1377
int pmt_start_pid
Definition: mpegtsenc.c:94
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1489
int service_type
Definition: mpegtsenc.c:92
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:840
void(* write_packet)(struct MpegTSSection *s, const uint8_t *packet)
Definition: mpegtsenc.c:50
Stream structure.
Definition: avformat.h:881
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int start_pid
Definition: mpegtsenc.c:95
#define STREAM_TYPE_METADATA
Definition: mpegts.h:116
#define av_bswap32
Definition: bswap.h:33
int frame_size
Definition: mxfenc.c:2214
#define DVB_PRIVATE_NETWORK_START
Definition: mpegtsenc.c:41
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:87
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
#define MPEGTS_FLAG_PAT_PMT_AT_FRAMES
Definition: mpegtsenc.c:101
const AVClass * av_class
Definition: mpegtsenc.c:75
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:206
#define STREAM_TYPE_PRIVATE_DATA
Definition: mpeg.h:54
void * buf
Definition: avisynth_c.h:766
Undefined Behavior In the C language
Definition: undefined.txt:3
Describe the class of an AVClass context structure.
Definition: log.h:67
static int opus_get_packet_samples(AVFormatContext *s, AVPacket *pkt)
Definition: mpegtsenc.c:1477
int original_network_id
Definition: mpegtsenc.c:90
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2634
ff_const59 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
int service_id
Definition: mpegtsenc.c:91
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1303
byte swapping routines
static int mpegts_write_end(AVFormatContext *s)
Definition: mpegtsenc.c:1797
#define STREAM_TYPE_AUDIO_AC3
Definition: mpeg.h:61
#define snprintf
Definition: snprintf.h:34
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4433
int transport_stream_id
Definition: mpegtsenc.c:89
MpegTSService ** services
Definition: mpegtsenc.c:78
static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
Definition: mpegtsenc.c:734
uint8_t * payload
Definition: mpegtsenc.c:235
AVDictionary * metadata
Definition: avformat.h:1281
static int64_t pts
static void mpegts_write_flush(AVFormatContext *s)
Definition: mpegtsenc.c:1769
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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
int m2ts_mode
Definition: mpegtsenc.c:96
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
int sample_rate
Audio only.
Definition: avcodec.h:4078
#define DEFAULT_SERVICE_NAME
Definition: mpegtsenc.c:218
Main libavformat public API header.
common internal api header.
int64_t last_pat_ts
Definition: mpegtsenc.c:109
int64_t sdt_period
Definition: mpegtsenc.c:79
#define flag(name)
Definition: cbs_av1.c:553
static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb)
Definition: mpegtsenc.c:716
uint8_t name[256]
Definition: mpegtsenc.c:57
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:934
int pcr_period_ms
Definition: mpegtsenc.c:98
static void putbuf(uint8_t **q_ptr, const uint8_t *buf, size_t len)
Definition: mpegtsenc.c:263
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:932
int den
Denominator.
Definition: rational.h:60
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:470
#define av_free(p)
char * value
Definition: dict.h:87
int len
#define PAT_PID
Definition: mpegts.h:37
#define STREAM_TYPE_VIDEO_MPEG2
Definition: mpeg.h:50
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5556
void * priv_data
Format private data.
Definition: avformat.h:1386
MpegTSSection pat
Definition: mpegtsenc.c:76
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:471
static struct @316 state
static void mpegts_write_pat(AVFormatContext *s)
Definition: mpegtsenc.c:246
int64_t pat_period
Definition: mpegtsenc.c:80
MpegTSSection sdt
Definition: mpegtsenc.c:77
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3982
int channels
Audio only.
Definition: avcodec.h:4074
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1479
int64_t pcr_period
Definition: mpegtsenc.c:238
static const AVClass mpegts_muxer_class
Definition: mpegtsenc.c:1943
#define av_freep(p)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
#define av_malloc_array(a, b)
int opus_pending_trim_start
Definition: mpegtsenc.c:243
int stream_index
Definition: avcodec.h:1482
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
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
#define MKTAG(a, b, c, d)
Definition: common.h:366
#define STREAM_TYPE_AUDIO_MPEG1
Definition: mpeg.h:51
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1457
static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len)
Definition: mpegtsenc.c:124
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define STREAM_TYPE_AUDIO_TRUEHD
Definition: mpegts.h:125
AVProgram ** programs
Definition: avformat.h:1538
#define SDT_TID
Definition: mpegts.h:75
int tables_version
Definition: mpegtsenc.c:106
const char * name
Definition: opengl_enc.c:102