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  av_log(s, AV_LOG_WARNING, "Stream %d, codec %s, is muxed as a private data stream "
386  "and may not be recognized upon reading.\n", i, avcodec_get_name(st->codecpar->codec_id));
387  stream_type = STREAM_TYPE_PRIVATE_DATA;
388  break;
389  }
390 
391  *q++ = stream_type;
392  put16(&q, 0xe000 | ts_st->pid);
393  desc_length_ptr = q;
394  q += 2; /* patched after */
395 
396  /* write optional descriptors here */
397  switch (st->codecpar->codec_type) {
398  case AVMEDIA_TYPE_AUDIO:
400  *q++=0x6a; // AC3 descriptor see A038 DVB SI
401  *q++=1; // 1 byte, all flags sets to 0
402  *q++=0; // omit all fields...
403  }
405  *q++=0x7a; // EAC3 descriptor see A038 DVB SI
406  *q++=1; // 1 byte, all flags sets to 0
407  *q++=0; // omit all fields...
408  }
410  put_registration_descriptor(&q, MKTAG('B', 'S', 'S', 'D'));
411  if (st->codecpar->codec_id==AV_CODEC_ID_OPUS) {
412  /* 6 bytes registration descriptor, 4 bytes Opus audio descriptor */
413  if (q - data > SECTION_LENGTH - 6 - 4) {
414  err = 1;
415  break;
416  }
417 
418  put_registration_descriptor(&q, MKTAG('O', 'p', 'u', 's'));
419 
420  *q++ = 0x7f; /* DVB extension descriptor */
421  *q++ = 2;
422  *q++ = 0x80;
423 
424  if (st->codecpar->extradata && st->codecpar->extradata_size >= 19) {
425  if (st->codecpar->extradata[18] == 0 && st->codecpar->channels <= 2) {
426  /* RTP mapping family */
427  *q++ = st->codecpar->channels;
428  } else if (st->codecpar->extradata[18] == 1 && st->codecpar->channels <= 8 &&
429  st->codecpar->extradata_size >= 21 + st->codecpar->channels) {
430  static const uint8_t coupled_stream_counts[9] = {
431  1, 0, 1, 1, 2, 2, 2, 3, 3
432  };
433  static const uint8_t channel_map_a[8][8] = {
434  {0},
435  {0, 1},
436  {0, 2, 1},
437  {0, 1, 2, 3},
438  {0, 4, 1, 2, 3},
439  {0, 4, 1, 2, 3, 5},
440  {0, 4, 1, 2, 3, 5, 6},
441  {0, 6, 1, 2, 3, 4, 5, 7},
442  };
443  static const uint8_t channel_map_b[8][8] = {
444  {0},
445  {0, 1},
446  {0, 1, 2},
447  {0, 1, 2, 3},
448  {0, 1, 2, 3, 4},
449  {0, 1, 2, 3, 4, 5},
450  {0, 1, 2, 3, 4, 5, 6},
451  {0, 1, 2, 3, 4, 5, 6, 7},
452  };
453  /* Vorbis mapping family */
454 
455  if (st->codecpar->extradata[19] == st->codecpar->channels - coupled_stream_counts[st->codecpar->channels] &&
456  st->codecpar->extradata[20] == coupled_stream_counts[st->codecpar->channels] &&
457  memcmp(&st->codecpar->extradata[21], channel_map_a[st->codecpar->channels-1], st->codecpar->channels) == 0) {
458  *q++ = st->codecpar->channels;
459  } else if (st->codecpar->channels >= 2 && st->codecpar->extradata[19] == st->codecpar->channels &&
460  st->codecpar->extradata[20] == 0 &&
461  memcmp(&st->codecpar->extradata[21], channel_map_b[st->codecpar->channels-1], st->codecpar->channels) == 0) {
462  *q++ = st->codecpar->channels | 0x80;
463  } else {
464  /* Unsupported, could write an extended descriptor here */
465  av_log(s, AV_LOG_ERROR, "Unsupported Opus Vorbis-style channel mapping");
466  *q++ = 0xff;
467  }
468  } else {
469  /* Unsupported */
470  av_log(s, AV_LOG_ERROR, "Unsupported Opus channel mapping for family %d", st->codecpar->extradata[18]);
471  *q++ = 0xff;
472  }
473  } else if (st->codecpar->channels <= 2) {
474  /* Assume RTP mapping family */
475  *q++ = st->codecpar->channels;
476  } else {
477  /* Unsupported */
478  av_log(s, AV_LOG_ERROR, "Unsupported Opus channel mapping");
479  *q++ = 0xff;
480  }
481  }
482 
483  if (lang) {
484  char *p;
485  char *next = lang->value;
486  uint8_t *len_ptr;
487 
488  *q++ = 0x0a; /* ISO 639 language descriptor */
489  len_ptr = q++;
490  *len_ptr = 0;
491 
492  for (p = lang->value; next && *len_ptr < 255 / 4 * 4; p = next + 1) {
493  if (q - data > SECTION_LENGTH - 4) {
494  err = 1;
495  break;
496  }
497  next = strchr(p, ',');
498  if (strlen(p) != 3 && (!next || next != p + 3))
499  continue; /* not a 3-letter code */
500 
501  *q++ = *p++;
502  *q++ = *p++;
503  *q++ = *p++;
504 
506  *q++ = 0x01;
508  *q++ = 0x02;
510  *q++ = 0x03;
511  else
512  *q++ = 0; /* undefined type */
513 
514  *len_ptr += 4;
515  }
516 
517  if (*len_ptr == 0)
518  q -= 2; /* no language codes were written */
519  }
520  break;
522  {
523  const char default_language[] = "und";
524  const char *language = lang && strlen(lang->value) >= 3 ? lang->value : default_language;
525 
527  uint8_t *len_ptr;
528  int extradata_copied = 0;
529 
530  *q++ = 0x59; /* subtitling_descriptor */
531  len_ptr = q++;
532 
533  while (strlen(language) >= 3) {
534  if (sizeof(data) - (q - data) < 8) { /* 8 bytes per DVB subtitle substream data */
535  err = 1;
536  break;
537  }
538  *q++ = *language++;
539  *q++ = *language++;
540  *q++ = *language++;
541  /* Skip comma */
542  if (*language != '\0')
543  language++;
544 
545  if (st->codecpar->extradata_size - extradata_copied >= 5) {
546  *q++ = st->codecpar->extradata[extradata_copied + 4]; /* subtitling_type */
547  memcpy(q, st->codecpar->extradata + extradata_copied, 4); /* composition_page_id and ancillary_page_id */
548  extradata_copied += 5;
549  q += 4;
550  } else {
551  /* subtitling_type:
552  * 0x10 - normal with no monitor aspect ratio criticality
553  * 0x20 - for the hard of hearing with no monitor aspect ratio criticality */
554  *q++ = (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED) ? 0x20 : 0x10;
555  if ((st->codecpar->extradata_size == 4) && (extradata_copied == 0)) {
556  /* support of old 4-byte extradata format */
557  memcpy(q, st->codecpar->extradata, 4); /* composition_page_id and ancillary_page_id */
558  extradata_copied += 4;
559  q += 4;
560  } else {
561  put16(&q, 1); /* composition_page_id */
562  put16(&q, 1); /* ancillary_page_id */
563  }
564  }
565  }
566 
567  *len_ptr = q - len_ptr - 1;
568  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT) {
569  uint8_t *len_ptr = NULL;
570  int extradata_copied = 0;
571 
572  /* The descriptor tag. teletext_descriptor */
573  *q++ = 0x56;
574  len_ptr = q++;
575 
576  while (strlen(language) >= 3 && q - data < sizeof(data) - 6) {
577  *q++ = *language++;
578  *q++ = *language++;
579  *q++ = *language++;
580  /* Skip comma */
581  if (*language != '\0')
582  language++;
583 
584  if (st->codecpar->extradata_size - 1 > extradata_copied) {
585  memcpy(q, st->codecpar->extradata + extradata_copied, 2);
586  extradata_copied += 2;
587  q += 2;
588  } else {
589  /* The Teletext descriptor:
590  * teletext_type: This 5-bit field indicates the type of Teletext page indicated. (0x01 Initial Teletext page)
591  * teletext_magazine_number: This is a 3-bit field which identifies the magazine number.
592  * teletext_page_number: This is an 8-bit field giving two 4-bit hex digits identifying the page number. */
593  *q++ = 0x08;
594  *q++ = 0x00;
595  }
596  }
597 
598  *len_ptr = q - len_ptr - 1;
599  }
600  }
601  break;
602  case AVMEDIA_TYPE_VIDEO:
603  if (stream_type == STREAM_TYPE_VIDEO_DIRAC) {
604  put_registration_descriptor(&q, MKTAG('d', 'r', 'a', 'c'));
605  } else if (stream_type == STREAM_TYPE_VIDEO_VC1) {
606  put_registration_descriptor(&q, MKTAG('V', 'C', '-', '1'));
607  } else if (stream_type == STREAM_TYPE_VIDEO_HEVC && s->strict_std_compliance <= FF_COMPLIANCE_NORMAL) {
608  put_registration_descriptor(&q, MKTAG('H', 'E', 'V', 'C'));
609  }
610  break;
611  case AVMEDIA_TYPE_DATA:
613  put_registration_descriptor(&q, MKTAG('K', 'L', 'V', 'A'));
614  } else if (st->codecpar->codec_id == AV_CODEC_ID_TIMED_ID3) {
615  const char *tag = "ID3 ";
616  *q++ = 0x26; /* metadata descriptor */
617  *q++ = 13;
618  put16(&q, 0xffff); /* metadata application format */
619  putbuf(&q, tag, strlen(tag));
620  *q++ = 0xff; /* metadata format */
621  putbuf(&q, tag, strlen(tag));
622  *q++ = 0; /* metadata service ID */
623  *q++ = 0xF; /* metadata_locator_record_flag|MPEG_carriage_flags|reserved */
624  }
625  break;
626  }
627 
628  val = 0xf000 | (q - desc_length_ptr - 2);
629  desc_length_ptr[0] = val >> 8;
630  desc_length_ptr[1] = val;
631  }
632 
633  if (err)
634  av_log(s, AV_LOG_ERROR,
635  "The PMT section cannot fit stream %d and all following streams.\n"
636  "Try reducing the number of languages in the audio streams "
637  "or the total number of streams.\n", i);
638 
639  mpegts_write_section1(&service->pmt, PMT_TID, service->sid, ts->tables_version, 0, 0,
640  data, q - data);
641  return 0;
642 }
643 
645 {
646  MpegTSWrite *ts = s->priv_data;
647  MpegTSService *service;
648  uint8_t data[SECTION_LENGTH], *q, *desc_list_len_ptr, *desc_len_ptr;
649  int i, running_status, free_ca_mode, val;
650 
651  q = data;
652  put16(&q, ts->onid);
653  *q++ = 0xff;
654  for (i = 0; i < ts->nb_services; i++) {
655  service = ts->services[i];
656  put16(&q, service->sid);
657  *q++ = 0xfc | 0x00; /* currently no EIT info */
658  desc_list_len_ptr = q;
659  q += 2;
660  running_status = 4; /* running */
661  free_ca_mode = 0;
662 
663  /* write only one descriptor for the service name and provider */
664  *q++ = 0x48;
665  desc_len_ptr = q;
666  q++;
667  *q++ = ts->service_type;
668  putbuf(&q, service->provider_name, service->provider_name[0] + 1);
669  putbuf(&q, service->name, service->name[0] + 1);
670  desc_len_ptr[0] = q - desc_len_ptr - 1;
671 
672  /* fill descriptor length */
673  val = (running_status << 13) | (free_ca_mode << 12) |
674  (q - desc_list_len_ptr - 2);
675  desc_list_len_ptr[0] = val >> 8;
676  desc_list_len_ptr[1] = val;
677  }
678  mpegts_write_section1(&ts->sdt, SDT_TID, ts->tsid, ts->tables_version, 0, 0,
679  data, q - data);
680 }
681 
682 /* This stores a string in buf with the correct encoding and also sets the
683  * first byte as the length. !str is accepted for an empty string.
684  * If the string is already encoded, invalid UTF-8 or has no multibyte sequence
685  * then we keep it as is, otherwise we signal UTF-8 encoding. */
686 static int encode_str8(uint8_t *buf, const char *str)
687 {
688  size_t str_len;
689  if (!str)
690  str = "";
691  str_len = strlen(str);
692  if (str[0] && (unsigned)str[0] >= 0x20) { /* Make sure the string is not already encoded. */
693  const uint8_t *q = str;
694  int has_multibyte = 0;
695  while (*q) {
696  uint32_t code;
697  GET_UTF8(code, *q++, goto invalid;) /* Is it valid UTF-8? */
698  has_multibyte |= (code > 127); /* Does it have multibyte UTF-8 chars in it? */
699  }
700  if (has_multibyte) { /* If we have multibyte chars and valid UTF-8, then encode as such! */
701  if (str_len > 254)
702  return AVERROR(EINVAL);
703  buf[0] = str_len + 1;
704  buf[1] = 0x15;
705  memcpy(&buf[2], str, str_len);
706  return 0;
707  }
708  }
709 invalid:
710  /* Otherwise let's just encode the string as is! */
711  if (str_len > 255)
712  return AVERROR(EINVAL);
713  buf[0] = str_len;
714  memcpy(&buf[1], str, str_len);
715  return 0;
716 }
717 
718 static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb)
719 {
720  return av_rescale(avio_tell(pb) + 11, 8 * PCR_TIME_BASE, ts->mux_rate) +
721  ts->first_pcr;
722 }
723 
724 static void write_packet(AVFormatContext *s, const uint8_t *packet)
725 {
726  MpegTSWrite *ts = s->priv_data;
727  if (ts->m2ts_mode) {
728  int64_t pcr = get_pcr(s->priv_data, s->pb);
729  uint32_t tp_extra_header = pcr % 0x3fffffff;
730  tp_extra_header = AV_RB32(&tp_extra_header);
731  avio_write(s->pb, (unsigned char *) &tp_extra_header,
732  sizeof(tp_extra_header));
733  }
734  avio_write(s->pb, packet, TS_PACKET_SIZE);
735 }
736 
737 static void section_write_packet(MpegTSSection *s, const uint8_t *packet)
738 {
739  AVFormatContext *ctx = s->opaque;
740  write_packet(ctx, packet);
741 }
742 
744  const AVDictionary *metadata,
746 {
747  MpegTSWrite *ts = s->priv_data;
748  MpegTSService *service;
749  AVDictionaryEntry *title, *provider;
750  char default_service_name[32];
751  const char *service_name;
752  const char *provider_name;
753 
754  title = av_dict_get(metadata, "service_name", NULL, 0);
755  if (!title)
756  title = av_dict_get(metadata, "title", NULL, 0);
757  snprintf(default_service_name, sizeof(default_service_name), "%s%02d", DEFAULT_SERVICE_NAME, ts->nb_services + 1);
758  service_name = title ? title->value : default_service_name;
759  provider = av_dict_get(metadata, "service_provider", NULL, 0);
760  provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME;
761 
762  service = av_mallocz(sizeof(MpegTSService));
763  if (!service)
764  return NULL;
765  service->pmt.pid = ts->pmt_start_pid + ts->nb_services;
766  service->sid = sid;
767  service->pcr_pid = 0x1fff;
768  if (encode_str8(service->provider_name, provider_name) < 0 ||
769  encode_str8(service->name, service_name) < 0) {
770  av_log(s, AV_LOG_ERROR, "Too long service or provider name\n");
771  goto fail;
772  }
773  if (av_dynarray_add_nofree(&ts->services, &ts->nb_services, service) < 0)
774  goto fail;
775 
777  service->pmt.opaque = s;
778  service->pmt.cc = 15;
779  service->pmt.discontinuity= ts->flags & MPEGTS_FLAG_DISCONT;
780  service->program = program;
781 
782  return service;
783 fail:
784  av_free(service);
785  return NULL;
786 }
787 
789 {
790  MpegTSWrite *ts = s->priv_data;
791  MpegTSWriteStream *ts_st = pcr_st->priv_data;
792 
793  if (ts->mux_rate > 1 || ts->pcr_period_ms >= 0) {
794  int pcr_period_ms = ts->pcr_period_ms == -1 ? PCR_RETRANS_TIME : ts->pcr_period_ms;
795  ts_st->pcr_period = av_rescale(pcr_period_ms, PCR_TIME_BASE, 1000);
796  } else {
797  /* By default, for VBR we select the highest multiple of frame duration which is less than 100 ms. */
798  int64_t frame_period = 0;
799  if (pcr_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
801  if (!frame_size) {
802  av_log(s, AV_LOG_WARNING, "frame size not set\n");
803  frame_size = 512;
804  }
805  frame_period = av_rescale_rnd(frame_size, PCR_TIME_BASE, pcr_st->codecpar->sample_rate, AV_ROUND_UP);
806  } else if (pcr_st->avg_frame_rate.num) {
807  frame_period = av_rescale_rnd(pcr_st->avg_frame_rate.den, PCR_TIME_BASE, pcr_st->avg_frame_rate.num, AV_ROUND_UP);
808  }
809  if (frame_period > 0 && frame_period <= PCR_TIME_BASE / 10)
810  ts_st->pcr_period = frame_period * (PCR_TIME_BASE / 10 / frame_period);
811  else
812  ts_st->pcr_period = 1;
813  }
814 
815  // output a PCR as soon as possible
816  ts_st->last_pcr = ts->first_pcr - ts_st->pcr_period;
817 }
818 
820 {
821  MpegTSWrite *ts = s->priv_data;
822 
823  for (int i = 0; i < ts->nb_services; i++) {
824  MpegTSService *service = ts->services[i];
825  AVStream *pcr_st = NULL;
826  AVProgram *program = service->program;
827  int nb_streams = program ? program->nb_stream_indexes : s->nb_streams;
828 
829  for (int j = 0; j < nb_streams; j++) {
830  AVStream *st = s->streams[program ? program->stream_index[j] : j];
831  if (!pcr_st ||
833  {
834  pcr_st = st;
835  }
836  }
837 
838  if (pcr_st) {
839  MpegTSWriteStream *ts_st = pcr_st->priv_data;
840  service->pcr_pid = ts_st->pid;
842  av_log(s, AV_LOG_VERBOSE, "service %i using PCR in pid=%i, pcr_period=%"PRId64"ms\n",
843  service->sid, service->pcr_pid, av_rescale(ts_st->pcr_period, 1000, PCR_TIME_BASE));
844  }
845  }
846 }
847 
849 {
850  MpegTSWrite *ts = s->priv_data;
851  int i, j;
852  int *pids;
853  int ret;
854 
855  if (ts->m2ts_mode == -1) {
856  if (av_match_ext(s->url, "m2ts")) {
857  ts->m2ts_mode = 1;
858  } else {
859  ts->m2ts_mode = 0;
860  }
861  }
862 
863  if (s->max_delay < 0) /* Not set by the caller */
864  s->max_delay = 0;
865 
866  // round up to a whole number of TS packets
867  ts->pes_payload_size = (ts->pes_payload_size + 14 + 183) / 184 * 184 - 14;
868 
869  ts->tsid = ts->transport_stream_id;
870  ts->onid = ts->original_network_id;
871  if (!s->nb_programs) {
872  /* allocate a single DVB service */
873  if (!mpegts_add_service(s, ts->service_id, s->metadata, NULL))
874  return AVERROR(ENOMEM);
875  } else {
876  for (i = 0; i < s->nb_programs; i++) {
877  AVProgram *program = s->programs[i];
878  if (!mpegts_add_service(s, program->id, program->metadata, program))
879  return AVERROR(ENOMEM);
880  }
881  }
882 
883  ts->pat.pid = PAT_PID;
884  /* Initialize at 15 so that it wraps and is equal to 0 for the
885  * first packet we write. */
886  ts->pat.cc = 15;
889  ts->pat.opaque = s;
890 
891  ts->sdt.pid = SDT_PID;
892  ts->sdt.cc = 15;
895  ts->sdt.opaque = s;
896 
897  pids = av_malloc_array(s->nb_streams, sizeof(*pids));
898  if (!pids) {
899  ret = AVERROR(ENOMEM);
900  goto fail;
901  }
902 
903  /* assign pids to each stream */
904  for (i = 0; i < s->nb_streams; i++) {
905  AVStream *st = s->streams[i];
906  MpegTSWriteStream *ts_st;
907 
908  ts_st = av_mallocz(sizeof(MpegTSWriteStream));
909  if (!ts_st) {
910  ret = AVERROR(ENOMEM);
911  goto fail;
912  }
913  st->priv_data = ts_st;
914 
915  avpriv_set_pts_info(st, 33, 1, 90000);
916 
917  ts_st->payload = av_mallocz(ts->pes_payload_size);
918  if (!ts_st->payload) {
919  ret = AVERROR(ENOMEM);
920  goto fail;
921  }
922 
923  /* MPEG pid values < 16 are reserved. Applications which set st->id in
924  * this range are assigned a calculated pid. */
925  if (st->id < 16) {
926  ts_st->pid = ts->start_pid + i;
927  } else {
928  ts_st->pid = st->id;
929  }
930  if (ts_st->pid >= 0x1FFF) {
931  av_log(s, AV_LOG_ERROR,
932  "Invalid stream id %d, must be less than 8191\n", st->id);
933  ret = AVERROR(EINVAL);
934  goto fail;
935  }
936  for (j = 0; j < ts->nb_services; j++) {
937  if (ts->services[j]->pmt.pid > LAST_OTHER_PID) {
938  av_log(s, AV_LOG_ERROR,
939  "Invalid PMT PID %d, must be less than %d\n", ts->services[j]->pmt.pid, LAST_OTHER_PID + 1);
940  ret = AVERROR(EINVAL);
941  goto fail;
942  }
943  if (ts_st->pid == ts->services[j]->pmt.pid) {
944  av_log(s, AV_LOG_ERROR, "PID %d cannot be both elementary and PMT PID\n", ts_st->pid);
945  ret = AVERROR(EINVAL);
946  goto fail;
947  }
948  }
949  for (j = 0; j < i; j++) {
950  if (pids[j] == ts_st->pid) {
951  av_log(s, AV_LOG_ERROR, "Duplicate stream id %d\n", ts_st->pid);
952  ret = AVERROR(EINVAL);
953  goto fail;
954  }
955  }
956  pids[i] = ts_st->pid;
957  ts_st->payload_pts = AV_NOPTS_VALUE;
958  ts_st->payload_dts = AV_NOPTS_VALUE;
959  ts_st->first_pts_check = 1;
960  ts_st->cc = 15;
961  ts_st->discontinuity = ts->flags & MPEGTS_FLAG_DISCONT;
962  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
963  st->codecpar->extradata_size > 0) {
964  AVStream *ast;
965  ts_st->amux = avformat_alloc_context();
966  if (!ts_st->amux) {
967  ret = AVERROR(ENOMEM);
968  goto fail;
969  }
970  ts_st->amux->oformat =
971  av_guess_format((ts->flags & MPEGTS_FLAG_AAC_LATM) ? "latm" : "adts",
972  NULL, NULL);
973  if (!ts_st->amux->oformat) {
974  ret = AVERROR(EINVAL);
975  goto fail;
976  }
977  if (!(ast = avformat_new_stream(ts_st->amux, NULL))) {
978  ret = AVERROR(ENOMEM);
979  goto fail;
980  }
981  ret = avcodec_parameters_copy(ast->codecpar, st->codecpar);
982  if (ret != 0)
983  goto fail;
984  ast->time_base = st->time_base;
985  ret = avformat_write_header(ts_st->amux, NULL);
986  if (ret < 0)
987  goto fail;
988  }
989  if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
991  }
992  }
993 
994  av_freep(&pids);
995 
996  if (ts->copyts < 1)
998 
1000 
1005 
1006  if (ts->mux_rate == 1)
1007  av_log(s, AV_LOG_VERBOSE, "muxrate VBR, ");
1008  else
1009  av_log(s, AV_LOG_VERBOSE, "muxrate %d, ", ts->mux_rate);
1011  "sdt every %"PRId64" ms, pat/pmt every %"PRId64" ms\n",
1012  av_rescale(ts->sdt_period, 1000, PCR_TIME_BASE),
1013  av_rescale(ts->pat_period, 1000, PCR_TIME_BASE));
1014 
1015  return 0;
1016 
1017 fail:
1018  av_freep(&pids);
1019  return ret;
1020 }
1021 
1022 /* send SDT, PAT and PMT tables regularly */
1023 static void retransmit_si_info(AVFormatContext *s, int force_pat, int force_sdt, int64_t pcr)
1024 {
1025  MpegTSWrite *ts = s->priv_data;
1026  int i;
1027 
1028  if ((pcr != AV_NOPTS_VALUE && ts->last_sdt_ts == AV_NOPTS_VALUE) ||
1029  (pcr != AV_NOPTS_VALUE && pcr - ts->last_sdt_ts >= ts->sdt_period) ||
1030  force_sdt
1031  ) {
1032  if (pcr != AV_NOPTS_VALUE)
1033  ts->last_sdt_ts = FFMAX(pcr, ts->last_sdt_ts);
1034  mpegts_write_sdt(s);
1035  }
1036  if ((pcr != AV_NOPTS_VALUE && ts->last_pat_ts == AV_NOPTS_VALUE) ||
1037  (pcr != AV_NOPTS_VALUE && pcr - ts->last_pat_ts >= ts->pat_period) ||
1038  force_pat) {
1039  if (pcr != AV_NOPTS_VALUE)
1040  ts->last_pat_ts = FFMAX(pcr, ts->last_pat_ts);
1041  mpegts_write_pat(s);
1042  for (i = 0; i < ts->nb_services; i++)
1043  mpegts_write_pmt(s, ts->services[i]);
1044  }
1045 }
1046 
1047 static int write_pcr_bits(uint8_t *buf, int64_t pcr)
1048 {
1049  int64_t pcr_low = pcr % 300, pcr_high = pcr / 300;
1050 
1051  *buf++ = pcr_high >> 25;
1052  *buf++ = pcr_high >> 17;
1053  *buf++ = pcr_high >> 9;
1054  *buf++ = pcr_high >> 1;
1055  *buf++ = pcr_high << 7 | pcr_low >> 8 | 0x7e;
1056  *buf++ = pcr_low;
1057 
1058  return 6;
1059 }
1060 
1061 /* Write a single null transport stream packet */
1063 {
1064  uint8_t *q;
1065  uint8_t buf[TS_PACKET_SIZE];
1066 
1067  q = buf;
1068  *q++ = 0x47;
1069  *q++ = 0x00 | 0x1f;
1070  *q++ = 0xff;
1071  *q++ = 0x10;
1072  memset(q, 0x0FF, TS_PACKET_SIZE - (q - buf));
1073  write_packet(s, buf);
1074 }
1075 
1076 /* Write a single transport stream packet with a PCR and no payload */
1078 {
1079  MpegTSWrite *ts = s->priv_data;
1080  MpegTSWriteStream *ts_st = st->priv_data;
1081  uint8_t *q;
1082  uint8_t buf[TS_PACKET_SIZE];
1083 
1084  q = buf;
1085  *q++ = 0x47;
1086  *q++ = ts_st->pid >> 8;
1087  *q++ = ts_st->pid;
1088  *q++ = 0x20 | ts_st->cc; /* Adaptation only */
1089  /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
1090  *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */
1091  *q++ = 0x10; /* Adaptation flags: PCR present */
1092  if (ts_st->discontinuity) {
1093  q[-1] |= 0x80;
1094  ts_st->discontinuity = 0;
1095  }
1096 
1097  /* PCR coded into 6 bytes */
1098  q += write_pcr_bits(q, get_pcr(ts, s->pb));
1099 
1100  /* stuffing bytes */
1101  memset(q, 0xFF, TS_PACKET_SIZE - (q - buf));
1102  write_packet(s, buf);
1103 }
1104 
1105 static void write_pts(uint8_t *q, int fourbits, int64_t pts)
1106 {
1107  int val;
1108 
1109  val = fourbits << 4 | (((pts >> 30) & 0x07) << 1) | 1;
1110  *q++ = val;
1111  val = (((pts >> 15) & 0x7fff) << 1) | 1;
1112  *q++ = val >> 8;
1113  *q++ = val;
1114  val = (((pts) & 0x7fff) << 1) | 1;
1115  *q++ = val >> 8;
1116  *q++ = val;
1117 }
1118 
1119 /* Set an adaptation field flag in an MPEG-TS packet*/
1120 static void set_af_flag(uint8_t *pkt, int flag)
1121 {
1122  // expect at least one flag to set
1123  av_assert0(flag);
1124 
1125  if ((pkt[3] & 0x20) == 0) {
1126  // no AF yet, set adaptation field flag
1127  pkt[3] |= 0x20;
1128  // 1 byte length, no flags
1129  pkt[4] = 1;
1130  pkt[5] = 0;
1131  }
1132  pkt[5] |= flag;
1133 }
1134 
1135 /* Extend the adaptation field by size bytes */
1136 static void extend_af(uint8_t *pkt, int size)
1137 {
1138  // expect already existing adaptation field
1139  av_assert0(pkt[3] & 0x20);
1140  pkt[4] += size;
1141 }
1142 
1143 /* Get a pointer to MPEG-TS payload (right after TS packet header) */
1145 {
1146  if (pkt[3] & 0x20)
1147  return pkt + 5 + pkt[4];
1148  else
1149  return pkt + 4;
1150 }
1151 
1152 /* Add a PES header to the front of the payload, and segment into an integer
1153  * number of TS packets. The final TS packet is padded using an oversized
1154  * adaptation header to exactly fill the last TS packet.
1155  * NOTE: 'payload' contains a complete PES payload. */
1157  const uint8_t *payload, int payload_size,
1158  int64_t pts, int64_t dts, int key, int stream_id)
1159 {
1160  MpegTSWriteStream *ts_st = st->priv_data;
1161  MpegTSWrite *ts = s->priv_data;
1162  uint8_t buf[TS_PACKET_SIZE];
1163  uint8_t *q;
1164  int val, is_start, len, header_len, write_pcr, is_dvb_subtitle, is_dvb_teletext, flags;
1165  int afc_len, stuffing_len;
1166  int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE);
1167  int force_pat = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && key && !ts_st->prev_payload_key;
1168  int force_sdt = 0;
1169 
1170  av_assert0(ts_st->payload != buf || st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO);
1172  force_pat = 1;
1173  }
1174 
1175  if (ts->flags & MPEGTS_FLAG_REEMIT_PAT_PMT) {
1176  force_pat = 1;
1177  force_sdt = 1;
1179  }
1180 
1181  is_start = 1;
1182  while (payload_size > 0) {
1183  int64_t pcr = AV_NOPTS_VALUE;
1184  if (ts->mux_rate > 1)
1185  pcr = get_pcr(ts, s->pb);
1186  else if (dts != AV_NOPTS_VALUE)
1187  pcr = (dts - delay) * 300;
1188 
1189  retransmit_si_info(s, force_pat, force_sdt, pcr);
1190  force_pat = 0;
1191  force_sdt = 0;
1192 
1193  write_pcr = 0;
1194  if (ts->mux_rate > 1) {
1195  /* Send PCR packets for all PCR streams if needed */
1196  pcr = get_pcr(ts, s->pb);
1197  if (pcr >= ts->next_pcr) {
1198  int64_t next_pcr = INT64_MAX;
1199  for (int i = 0; i < s->nb_streams; i++) {
1200  /* Make the current stream the last, because for that we
1201  * can insert the pcr into the payload later */
1202  int st2_index = i < st->index ? i : (i + 1 == s->nb_streams ? st->index : i + 1);
1203  AVStream *st2 = s->streams[st2_index];
1204  MpegTSWriteStream *ts_st2 = st2->priv_data;
1205  if (ts_st2->pcr_period) {
1206  if (pcr - ts_st2->last_pcr >= ts_st2->pcr_period) {
1207  ts_st2->last_pcr = FFMAX(pcr - ts_st2->pcr_period, ts_st2->last_pcr + ts_st2->pcr_period);
1208  if (st2 != st) {
1209  mpegts_insert_pcr_only(s, st2);
1210  pcr = get_pcr(ts, s->pb);
1211  } else {
1212  write_pcr = 1;
1213  }
1214  }
1215  next_pcr = FFMIN(next_pcr, ts_st2->last_pcr + ts_st2->pcr_period);
1216  }
1217  }
1218  ts->next_pcr = next_pcr;
1219  }
1220  if (dts != AV_NOPTS_VALUE && (dts - pcr / 300) > delay) {
1221  /* pcr insert gets priority over null packet insert */
1222  if (write_pcr)
1223  mpegts_insert_pcr_only(s, st);
1224  else
1226  /* recalculate write_pcr and possibly retransmit si_info */
1227  continue;
1228  }
1229  } else if (ts_st->pcr_period && pcr != AV_NOPTS_VALUE) {
1230  if (pcr - ts_st->last_pcr >= ts_st->pcr_period && is_start) {
1231  ts_st->last_pcr = FFMAX(pcr - ts_st->pcr_period, ts_st->last_pcr + ts_st->pcr_period);
1232  write_pcr = 1;
1233  }
1234  }
1235 
1236  /* prepare packet header */
1237  q = buf;
1238  *q++ = 0x47;
1239  val = ts_st->pid >> 8;
1240  if (ts->m2ts_mode && st->codecpar->codec_id == AV_CODEC_ID_AC3)
1241  val |= 0x20;
1242  if (is_start)
1243  val |= 0x40;
1244  *q++ = val;
1245  *q++ = ts_st->pid;
1246  ts_st->cc = ts_st->cc + 1 & 0xf;
1247  *q++ = 0x10 | ts_st->cc; // payload indicator + CC
1248  if (ts_st->discontinuity) {
1249  set_af_flag(buf, 0x80);
1250  q = get_ts_payload_start(buf);
1251  ts_st->discontinuity = 0;
1252  }
1253  if (key && is_start && pts != AV_NOPTS_VALUE) {
1254  // set Random Access for key frames
1255  if (ts_st->pcr_period)
1256  write_pcr = 1;
1257  set_af_flag(buf, 0x40);
1258  q = get_ts_payload_start(buf);
1259  }
1260  if (write_pcr) {
1261  set_af_flag(buf, 0x10);
1262  q = get_ts_payload_start(buf);
1263  // add 11, pcr references the last byte of program clock reference base
1264  if (dts != AV_NOPTS_VALUE && dts < pcr / 300)
1265  av_log(s, AV_LOG_WARNING, "dts < pcr, TS is invalid\n");
1266  extend_af(buf, write_pcr_bits(q, pcr));
1267  q = get_ts_payload_start(buf);
1268  }
1269  if (is_start) {
1270  int pes_extension = 0;
1271  int pes_header_stuffing_bytes = 0;
1272  /* write PES header */
1273  *q++ = 0x00;
1274  *q++ = 0x00;
1275  *q++ = 0x01;
1276  is_dvb_subtitle = 0;
1277  is_dvb_teletext = 0;
1278  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1279  if (st->codecpar->codec_id == AV_CODEC_ID_DIRAC)
1280  *q++ = 0xfd;
1281  else
1282  *q++ = 0xe0;
1283  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1284  (st->codecpar->codec_id == AV_CODEC_ID_MP2 ||
1285  st->codecpar->codec_id == AV_CODEC_ID_MP3 ||
1286  st->codecpar->codec_id == AV_CODEC_ID_AAC)) {
1287  *q++ = 0xc0;
1288  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1289  st->codecpar->codec_id == AV_CODEC_ID_AC3 &&
1290  ts->m2ts_mode) {
1291  *q++ = 0xfd;
1292  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA &&
1294  *q++ = 0xbd;
1295  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
1296  *q++ = stream_id != -1 ? stream_id : 0xfc;
1297 
1298  if (stream_id == 0xbd) /* asynchronous KLV */
1299  pts = dts = AV_NOPTS_VALUE;
1300  } else {
1301  *q++ = 0xbd;
1304  is_dvb_subtitle = 1;
1305  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT) {
1306  is_dvb_teletext = 1;
1307  }
1308  }
1309  }
1310  header_len = 0;
1311  flags = 0;
1312  if (pts != AV_NOPTS_VALUE) {
1313  header_len += 5;
1314  flags |= 0x80;
1315  }
1316  if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1317  header_len += 5;
1318  flags |= 0x40;
1319  }
1320  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1322  /* set PES_extension_flag */
1323  pes_extension = 1;
1324  flags |= 0x01;
1325 
1326  /* One byte for PES2 extension flag +
1327  * one byte for extension length +
1328  * one byte for extension id */
1329  header_len += 3;
1330  }
1331  /* for Blu-ray AC3 Audio the PES Extension flag should be as follow
1332  * otherwise it will not play sound on blu-ray
1333  */
1334  if (ts->m2ts_mode &&
1336  st->codecpar->codec_id == AV_CODEC_ID_AC3) {
1337  /* set PES_extension_flag */
1338  pes_extension = 1;
1339  flags |= 0x01;
1340  header_len += 3;
1341  }
1342  if (is_dvb_teletext) {
1343  pes_header_stuffing_bytes = 0x24 - header_len;
1344  header_len = 0x24;
1345  }
1346  len = payload_size + header_len + 3;
1347  /* 3 extra bytes should be added to DVB subtitle payload: 0x20 0x00 at the beginning and trailing 0xff */
1348  if (is_dvb_subtitle) {
1349  len += 3;
1350  payload_size++;
1351  }
1352  if (len > 0xffff)
1353  len = 0;
1355  len = 0;
1356  }
1357  *q++ = len >> 8;
1358  *q++ = len;
1359  val = 0x80;
1360  /* data alignment indicator is required for subtitle and data streams */
1362  val |= 0x04;
1363  *q++ = val;
1364  *q++ = flags;
1365  *q++ = header_len;
1366  if (pts != AV_NOPTS_VALUE) {
1367  write_pts(q, flags >> 6, pts);
1368  q += 5;
1369  }
1370  if (dts != AV_NOPTS_VALUE && pts != AV_NOPTS_VALUE && dts != pts) {
1371  write_pts(q, 1, dts);
1372  q += 5;
1373  }
1374  if (pes_extension && st->codecpar->codec_id == AV_CODEC_ID_DIRAC) {
1375  flags = 0x01; /* set PES_extension_flag_2 */
1376  *q++ = flags;
1377  *q++ = 0x80 | 0x01; /* marker bit + extension length */
1378  /* Set the stream ID extension flag bit to 0 and
1379  * write the extended stream ID. */
1380  *q++ = 0x00 | 0x60;
1381  }
1382  /* For Blu-ray AC3 Audio Setting extended flags */
1383  if (ts->m2ts_mode &&
1384  pes_extension &&
1385  st->codecpar->codec_id == AV_CODEC_ID_AC3) {
1386  flags = 0x01; /* set PES_extension_flag_2 */
1387  *q++ = flags;
1388  *q++ = 0x80 | 0x01; /* marker bit + extension length */
1389  *q++ = 0x00 | 0x71; /* for AC3 Audio (specifically on blue-rays) */
1390  }
1391 
1392 
1393  if (is_dvb_subtitle) {
1394  /* First two fields of DVB subtitles PES data:
1395  * data_identifier: for DVB subtitle streams shall be coded with the value 0x20
1396  * subtitle_stream_id: for DVB subtitle stream shall be identified by the value 0x00 */
1397  *q++ = 0x20;
1398  *q++ = 0x00;
1399  }
1400  if (is_dvb_teletext) {
1401  memset(q, 0xff, pes_header_stuffing_bytes);
1402  q += pes_header_stuffing_bytes;
1403  }
1404  is_start = 0;
1405  }
1406  /* header size */
1407  header_len = q - buf;
1408  /* data len */
1409  len = TS_PACKET_SIZE - header_len;
1410  if (len > payload_size)
1411  len = payload_size;
1412  stuffing_len = TS_PACKET_SIZE - header_len - len;
1413  if (stuffing_len > 0) {
1414  /* add stuffing with AFC */
1415  if (buf[3] & 0x20) {
1416  /* stuffing already present: increase its size */
1417  afc_len = buf[4] + 1;
1418  memmove(buf + 4 + afc_len + stuffing_len,
1419  buf + 4 + afc_len,
1420  header_len - (4 + afc_len));
1421  buf[4] += stuffing_len;
1422  memset(buf + 4 + afc_len, 0xff, stuffing_len);
1423  } else {
1424  /* add stuffing */
1425  memmove(buf + 4 + stuffing_len, buf + 4, header_len - 4);
1426  buf[3] |= 0x20;
1427  buf[4] = stuffing_len - 1;
1428  if (stuffing_len >= 2) {
1429  buf[5] = 0x00;
1430  memset(buf + 6, 0xff, stuffing_len - 2);
1431  }
1432  }
1433  }
1434 
1435  if (is_dvb_subtitle && payload_size == len) {
1436  memcpy(buf + TS_PACKET_SIZE - len, payload, len - 1);
1437  buf[TS_PACKET_SIZE - 1] = 0xff; /* end_of_PES_data_field_marker: an 8-bit field with fixed contents 0xff for DVB subtitle */
1438  } else {
1439  memcpy(buf + TS_PACKET_SIZE - len, payload, len);
1440  }
1441 
1442  payload += len;
1443  payload_size -= len;
1444  write_packet(s, buf);
1445  }
1446  ts_st->prev_payload_key = key;
1447 }
1448 
1450 {
1451  if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001 && AV_RB24(pkt->data) != 0x000001) {
1452  if (!st->nb_frames) {
1453  av_log(s, AV_LOG_ERROR, "H.264 bitstream malformed, "
1454  "no startcode found, use the video bitstream filter 'h264_mp4toannexb' to fix it "
1455  "('-bsf:v h264_mp4toannexb' option with ffmpeg)\n");
1456  return AVERROR_INVALIDDATA;
1457  }
1458  av_log(s, AV_LOG_WARNING, "H.264 bitstream error, startcode missing, size %d", pkt->size);
1459  if (pkt->size)
1460  av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
1461  av_log(s, AV_LOG_WARNING, "\n");
1462  }
1463  return 0;
1464 }
1465 
1467 {
1468  if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001 && AV_RB24(pkt->data) != 0x000001) {
1469  if (!st->nb_frames) {
1470  av_log(s, AV_LOG_ERROR, "HEVC bitstream malformed, no startcode found\n");
1471  return AVERROR_PATCHWELCOME;
1472  }
1473  av_log(s, AV_LOG_WARNING, "HEVC bitstream error, startcode missing, size %d", pkt->size);
1474  if (pkt->size)
1475  av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
1476  av_log(s, AV_LOG_WARNING, "\n");
1477  }
1478  return 0;
1479 }
1480 
1481 /* Based on GStreamer's gst-plugins-base/ext/ogg/gstoggstream.c
1482  * Released under the LGPL v2.1+, written by
1483  * Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
1484  */
1486 {
1487  static const int durations[32] = {
1488  480, 960, 1920, 2880, /* Silk NB */
1489  480, 960, 1920, 2880, /* Silk MB */
1490  480, 960, 1920, 2880, /* Silk WB */
1491  480, 960, /* Hybrid SWB */
1492  480, 960, /* Hybrid FB */
1493  120, 240, 480, 960, /* CELT NB */
1494  120, 240, 480, 960, /* CELT NB */
1495  120, 240, 480, 960, /* CELT NB */
1496  120, 240, 480, 960, /* CELT NB */
1497  };
1498  int toc, frame_duration, nframes, duration;
1499 
1500  if (pkt->size < 1)
1501  return 0;
1502 
1503  toc = pkt->data[0];
1504 
1505  frame_duration = durations[toc >> 3];
1506  switch (toc & 3) {
1507  case 0:
1508  nframes = 1;
1509  break;
1510  case 1:
1511  nframes = 2;
1512  break;
1513  case 2:
1514  nframes = 2;
1515  break;
1516  case 3:
1517  if (pkt->size < 2)
1518  return 0;
1519  nframes = pkt->data[1] & 63;
1520  break;
1521  }
1522 
1523  duration = nframes * frame_duration;
1524  if (duration > 5760) {
1526  "Opus packet duration > 120 ms, invalid");
1527  return 0;
1528  }
1529 
1530  return duration;
1531 }
1532 
1534 {
1535  AVStream *st = s->streams[pkt->stream_index];
1536  int size = pkt->size;
1537  uint8_t *buf = pkt->data;
1538  uint8_t *data = NULL;
1539  MpegTSWrite *ts = s->priv_data;
1540  MpegTSWriteStream *ts_st = st->priv_data;
1541  const int64_t delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) * 2;
1542  const int64_t max_audio_delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) / 2;
1543  int64_t dts = pkt->dts, pts = pkt->pts;
1544  int opus_samples = 0;
1545  int side_data_size;
1546  uint8_t *side_data = NULL;
1547  int stream_id = -1;
1548 
1549  side_data = av_packet_get_side_data(pkt,
1551  &side_data_size);
1552  if (side_data)
1553  stream_id = side_data[0];
1554 
1555  if (ts->copyts < 1) {
1556  if (pts != AV_NOPTS_VALUE)
1557  pts += delay;
1558  if (dts != AV_NOPTS_VALUE)
1559  dts += delay;
1560  }
1561 
1562  if (ts_st->first_pts_check && pts == AV_NOPTS_VALUE) {
1563  av_log(s, AV_LOG_ERROR, "first pts value must be set\n");
1564  return AVERROR_INVALIDDATA;
1565  }
1566  ts_st->first_pts_check = 0;
1567 
1568  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
1569  const uint8_t *p = buf, *buf_end = p + size;
1570  uint32_t state = -1;
1571  int extradd = (pkt->flags & AV_PKT_FLAG_KEY) ? st->codecpar->extradata_size : 0;
1572  int ret = ff_check_h264_startcode(s, st, pkt);
1573  if (ret < 0)
1574  return ret;
1575 
1576  if (extradd && AV_RB24(st->codecpar->extradata) > 1)
1577  extradd = 0;
1578 
1579  do {
1580  p = avpriv_find_start_code(p, buf_end, &state);
1581  av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", state & 0x1f);
1582  if ((state & 0x1f) == 7)
1583  extradd = 0;
1584  } while (p < buf_end && (state & 0x1f) != 9 &&
1585  (state & 0x1f) != 5 && (state & 0x1f) != 1);
1586 
1587  if ((state & 0x1f) != 5)
1588  extradd = 0;
1589  if ((state & 0x1f) != 9) { // AUD NAL
1590  data = av_malloc(pkt->size + 6 + extradd);
1591  if (!data)
1592  return AVERROR(ENOMEM);
1593  memcpy(data + 6, st->codecpar->extradata, extradd);
1594  memcpy(data + 6 + extradd, pkt->data, pkt->size);
1595  AV_WB32(data, 0x00000001);
1596  data[4] = 0x09;
1597  data[5] = 0xf0; // any slice type (0xe) + rbsp stop one bit
1598  buf = data;
1599  size = pkt->size + 6 + extradd;
1600  }
1601  } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1602  if (pkt->size < 2) {
1603  av_log(s, AV_LOG_ERROR, "AAC packet too short\n");
1604  return AVERROR_INVALIDDATA;
1605  }
1606  if ((AV_RB16(pkt->data) & 0xfff0) != 0xfff0) {
1607  int ret;
1608  AVPacket pkt2;
1609 
1610  if (!ts_st->amux) {
1611  av_log(s, AV_LOG_ERROR, "AAC bitstream not in ADTS format "
1612  "and extradata missing\n");
1613  } else {
1614  av_init_packet(&pkt2);
1615  pkt2.data = pkt->data;
1616  pkt2.size = pkt->size;
1617  av_assert0(pkt->dts != AV_NOPTS_VALUE);
1618  pkt2.dts = av_rescale_q(pkt->dts, st->time_base, ts_st->amux->streams[0]->time_base);
1619 
1620  ret = avio_open_dyn_buf(&ts_st->amux->pb);
1621  if (ret < 0)
1622  return ret;
1623 
1624  ret = av_write_frame(ts_st->amux, &pkt2);
1625  if (ret < 0) {
1626  ffio_free_dyn_buf(&ts_st->amux->pb);
1627  return ret;
1628  }
1629  size = avio_close_dyn_buf(ts_st->amux->pb, &data);
1630  ts_st->amux->pb = NULL;
1631  buf = data;
1632  }
1633  }
1634  } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
1635  const uint8_t *p = buf, *buf_end = p + size;
1636  uint32_t state = -1;
1637  int extradd = (pkt->flags & AV_PKT_FLAG_KEY) ? st->codecpar->extradata_size : 0;
1638  int ret = check_hevc_startcode(s, st, pkt);
1639  if (ret < 0)
1640  return ret;
1641 
1642  if (extradd && AV_RB24(st->codecpar->extradata) > 1)
1643  extradd = 0;
1644 
1645  do {
1646  p = avpriv_find_start_code(p, buf_end, &state);
1647  av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", (state & 0x7e)>>1);
1648  if ((state & 0x7e) == 2*32)
1649  extradd = 0;
1650  } while (p < buf_end && (state & 0x7e) != 2*35 &&
1651  (state & 0x7e) >= 2*32);
1652 
1653  if ((state & 0x7e) < 2*16 || (state & 0x7e) >= 2*24)
1654  extradd = 0;
1655  if ((state & 0x7e) != 2*35) { // AUD NAL
1656  data = av_malloc(pkt->size + 7 + extradd);
1657  if (!data)
1658  return AVERROR(ENOMEM);
1659  memcpy(data + 7, st->codecpar->extradata, extradd);
1660  memcpy(data + 7 + extradd, pkt->data, pkt->size);
1661  AV_WB32(data, 0x00000001);
1662  data[4] = 2*35;
1663  data[5] = 1;
1664  data[6] = 0x50; // any slice type (0x4) + rbsp stop one bit
1665  buf = data;
1666  size = pkt->size + 7 + extradd;
1667  }
1668  } else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
1669  if (pkt->size < 2) {
1670  av_log(s, AV_LOG_ERROR, "Opus packet too short\n");
1671  return AVERROR_INVALIDDATA;
1672  }
1673 
1674  /* Add Opus control header */
1675  if ((AV_RB16(pkt->data) >> 5) != 0x3ff) {
1676  uint8_t *side_data;
1677  int side_data_size;
1678  int i, n;
1679  int ctrl_header_size;
1680  int trim_start = 0, trim_end = 0;
1681 
1682  opus_samples = opus_get_packet_samples(s, pkt);
1683 
1684  side_data = av_packet_get_side_data(pkt,
1686  &side_data_size);
1687 
1688  if (side_data && side_data_size >= 10) {
1689  trim_end = AV_RL32(side_data + 4) * 48000 / st->codecpar->sample_rate;
1690  }
1691 
1692  ctrl_header_size = pkt->size + 2 + pkt->size / 255 + 1;
1693  if (ts_st->opus_pending_trim_start)
1694  ctrl_header_size += 2;
1695  if (trim_end)
1696  ctrl_header_size += 2;
1697 
1698  data = av_malloc(ctrl_header_size);
1699  if (!data)
1700  return AVERROR(ENOMEM);
1701 
1702  data[0] = 0x7f;
1703  data[1] = 0xe0;
1704  if (ts_st->opus_pending_trim_start)
1705  data[1] |= 0x10;
1706  if (trim_end)
1707  data[1] |= 0x08;
1708 
1709  n = pkt->size;
1710  i = 2;
1711  do {
1712  data[i] = FFMIN(n, 255);
1713  n -= 255;
1714  i++;
1715  } while (n >= 0);
1716 
1717  av_assert0(2 + pkt->size / 255 + 1 == i);
1718 
1719  if (ts_st->opus_pending_trim_start) {
1720  trim_start = FFMIN(ts_st->opus_pending_trim_start, opus_samples);
1721  AV_WB16(data + i, trim_start);
1722  i += 2;
1723  ts_st->opus_pending_trim_start -= trim_start;
1724  }
1725  if (trim_end) {
1726  trim_end = FFMIN(trim_end, opus_samples - trim_start);
1727  AV_WB16(data + i, trim_end);
1728  i += 2;
1729  }
1730 
1731  memcpy(data + i, pkt->data, pkt->size);
1732  buf = data;
1733  size = ctrl_header_size;
1734  } else {
1735  /* TODO: Can we get TS formatted data here? If so we will
1736  * need to count the samples of that too! */
1737  av_log(s, AV_LOG_WARNING, "Got MPEG-TS formatted Opus data, unhandled");
1738  }
1739  }
1740 
1741  if (ts_st->payload_size && (ts_st->payload_size + size > ts->pes_payload_size ||
1742  (dts != AV_NOPTS_VALUE && ts_st->payload_dts != AV_NOPTS_VALUE &&
1743  dts - ts_st->payload_dts >= max_audio_delay) ||
1744  ts_st->opus_queued_samples + opus_samples >= 5760 /* 120ms */)) {
1745  mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
1746  ts_st->payload_pts, ts_st->payload_dts,
1747  ts_st->payload_flags & AV_PKT_FLAG_KEY, stream_id);
1748  ts_st->payload_size = 0;
1749  ts_st->opus_queued_samples = 0;
1750  }
1751 
1752  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || size > ts->pes_payload_size) {
1753  av_assert0(!ts_st->payload_size);
1754  // for video and subtitle, write a single pes packet
1755  mpegts_write_pes(s, st, buf, size, pts, dts,
1756  pkt->flags & AV_PKT_FLAG_KEY, stream_id);
1757  ts_st->opus_queued_samples = 0;
1758  av_free(data);
1759  return 0;
1760  }
1761 
1762  if (!ts_st->payload_size) {
1763  ts_st->payload_pts = pts;
1764  ts_st->payload_dts = dts;
1765  ts_st->payload_flags = pkt->flags;
1766  }
1767 
1768  memcpy(ts_st->payload + ts_st->payload_size, buf, size);
1769  ts_st->payload_size += size;
1770  ts_st->opus_queued_samples += opus_samples;
1771 
1772  av_free(data);
1773 
1774  return 0;
1775 }
1776 
1778 {
1779  MpegTSWrite *ts = s->priv_data;
1780  int i;
1781 
1782  /* flush current packets */
1783  for (i = 0; i < s->nb_streams; i++) {
1784  AVStream *st = s->streams[i];
1785  MpegTSWriteStream *ts_st = st->priv_data;
1786  if (ts_st->payload_size > 0) {
1787  mpegts_write_pes(s, st, ts_st->payload, ts_st->payload_size,
1788  ts_st->payload_pts, ts_st->payload_dts,
1789  ts_st->payload_flags & AV_PKT_FLAG_KEY, -1);
1790  ts_st->payload_size = 0;
1791  ts_st->opus_queued_samples = 0;
1792  }
1793  }
1794 
1795  if (ts->m2ts_mode) {
1796  int packets = (avio_tell(s->pb) / (TS_PACKET_SIZE + 4)) % 32;
1797  while (packets++ < 32)
1799  }
1800 }
1801 
1803 {
1804  if (!pkt) {
1805  mpegts_write_flush(s);
1806  return 1;
1807  } else {
1808  return mpegts_write_packet_internal(s, pkt);
1809  }
1810 }
1811 
1813 {
1814  if (s->pb)
1815  mpegts_write_flush(s);
1816 
1817  return 0;
1818 }
1819 
1821 {
1822  MpegTSWrite *ts = s->priv_data;
1823  MpegTSService *service;
1824  int i;
1825 
1826  for (i = 0; i < s->nb_streams; i++) {
1827  AVStream *st = s->streams[i];
1828  MpegTSWriteStream *ts_st = st->priv_data;
1829  if (ts_st) {
1830  av_freep(&ts_st->payload);
1831  if (ts_st->amux) {
1832  avformat_free_context(ts_st->amux);
1833  ts_st->amux = NULL;
1834  }
1835  }
1836  }
1837 
1838  for (i = 0; i < ts->nb_services; i++) {
1839  service = ts->services[i];
1840  av_freep(&service);
1841  }
1842  av_freep(&ts->services);
1843 }
1844 
1846 {
1847  int ret = 1;
1848  AVStream *st = s->streams[pkt->stream_index];
1849 
1850  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
1851  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
1852  (AV_RB24(pkt->data) != 0x000001 ||
1853  (st->codecpar->extradata_size > 0 &&
1854  st->codecpar->extradata[0] == 1)))
1855  ret = ff_stream_add_bitstream_filter(st, "h264_mp4toannexb", NULL);
1856  } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
1857  if (pkt->size >= 5 && AV_RB32(pkt->data) != 0x0000001 &&
1858  (AV_RB24(pkt->data) != 0x000001 ||
1859  (st->codecpar->extradata_size > 0 &&
1860  st->codecpar->extradata[0] == 1)))
1861  ret = ff_stream_add_bitstream_filter(st, "hevc_mp4toannexb", NULL);
1862  }
1863 
1864  return ret;
1865 }
1866 
1867 static const AVOption options[] = {
1868  { "mpegts_transport_stream_id", "Set transport_stream_id field.",
1869  offsetof(MpegTSWrite, transport_stream_id), AV_OPT_TYPE_INT,
1870  { .i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM },
1871  { "mpegts_original_network_id", "Set original_network_id field.",
1872  offsetof(MpegTSWrite, original_network_id), AV_OPT_TYPE_INT,
1873  { .i64 = DVB_PRIVATE_NETWORK_START }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM },
1874  { "mpegts_service_id", "Set service_id field.",
1875  offsetof(MpegTSWrite, service_id), AV_OPT_TYPE_INT,
1876  { .i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM },
1877  { "mpegts_service_type", "Set service_type field.",
1878  offsetof(MpegTSWrite, service_type), AV_OPT_TYPE_INT,
1879  { .i64 = 0x01 }, 0x01, 0xff, AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1880  { "digital_tv", "Digital Television.",
1881  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_DIGITAL_TV }, 0x01, 0xff,
1882  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1883  { "digital_radio", "Digital Radio.",
1884  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_DIGITAL_RADIO }, 0x01, 0xff,
1885  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1886  { "teletext", "Teletext.",
1887  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_TELETEXT }, 0x01, 0xff,
1888  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1889  { "advanced_codec_digital_radio", "Advanced Codec Digital Radio.",
1891  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1892  { "mpeg2_digital_hdtv", "MPEG2 Digital HDTV.",
1893  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_MPEG2_DIGITAL_HDTV }, 0x01, 0xff,
1894  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1895  { "advanced_codec_digital_sdtv", "Advanced Codec Digital SDTV.",
1897  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1898  { "advanced_codec_digital_hdtv", "Advanced Codec Digital HDTV.",
1900  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1901  { "hevc_digital_hdtv", "HEVC Digital Television Service.",
1902  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_SERVICE_TYPE_HEVC_DIGITAL_HDTV }, 0x01, 0xff,
1903  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_service_type" },
1904  { "mpegts_pmt_start_pid", "Set the first pid of the PMT.",
1905  offsetof(MpegTSWrite, pmt_start_pid), AV_OPT_TYPE_INT,
1906  { .i64 = 0x1000 }, FIRST_OTHER_PID, LAST_OTHER_PID, AV_OPT_FLAG_ENCODING_PARAM },
1907  { "mpegts_start_pid", "Set the first pid.",
1908  offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT,
1909  { .i64 = 0x0100 }, FIRST_OTHER_PID, LAST_OTHER_PID, AV_OPT_FLAG_ENCODING_PARAM },
1910  { "mpegts_m2ts_mode", "Enable m2ts mode.",
1911  offsetof(MpegTSWrite, m2ts_mode), AV_OPT_TYPE_BOOL,
1912  { .i64 = -1 }, -1, 1, AV_OPT_FLAG_ENCODING_PARAM },
1913  { "muxrate", NULL,
1914  offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT,
1915  { .i64 = 1 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1916  { "pes_payload_size", "Minimum PES packet payload in bytes",
1917  offsetof(MpegTSWrite, pes_payload_size), AV_OPT_TYPE_INT,
1918  { .i64 = DEFAULT_PES_PAYLOAD_SIZE }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1919  { "mpegts_flags", "MPEG-TS muxing flags",
1920  offsetof(MpegTSWrite, flags), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, 0, INT_MAX,
1921  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1922  { "resend_headers", "Reemit PAT/PMT before writing the next packet",
1923  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_REEMIT_PAT_PMT }, 0, INT_MAX,
1924  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1925  { "latm", "Use LATM packetization for AAC",
1926  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_AAC_LATM }, 0, INT_MAX,
1927  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1928  { "pat_pmt_at_frames", "Reemit PAT and PMT at each video frame",
1929  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_PAT_PMT_AT_FRAMES}, 0, INT_MAX,
1930  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1931  { "system_b", "Conform to System B (DVB) instead of System A (ATSC)",
1932  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_SYSTEM_B }, 0, INT_MAX,
1933  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1934  { "initial_discontinuity", "Mark initial packets as discontinuous",
1935  0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_DISCONT }, 0, INT_MAX,
1936  AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
1937  { "mpegts_copyts", "don't offset dts/pts",
1938  offsetof(MpegTSWrite, copyts), AV_OPT_TYPE_BOOL,
1939  { .i64 = -1 }, -1, 1, AV_OPT_FLAG_ENCODING_PARAM },
1940  { "tables_version", "set PAT, PMT and SDT version",
1941  offsetof(MpegTSWrite, tables_version), AV_OPT_TYPE_INT,
1942  { .i64 = 0 }, 0, 31, AV_OPT_FLAG_ENCODING_PARAM },
1943  { "omit_video_pes_length", "Omit the PES packet length for video packets",
1944  offsetof(MpegTSWrite, omit_video_pes_length), AV_OPT_TYPE_BOOL,
1945  { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
1946  { "pcr_period", "PCR retransmission time in milliseconds",
1947  offsetof(MpegTSWrite, pcr_period_ms), AV_OPT_TYPE_INT,
1948  { .i64 = -1 }, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1949  { "pat_period", "PAT/PMT retransmission time limit in seconds",
1950  offsetof(MpegTSWrite, pat_period_us), AV_OPT_TYPE_DURATION,
1951  { .i64 = PAT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1952  { "sdt_period", "SDT retransmission time limit in seconds",
1953  offsetof(MpegTSWrite, sdt_period_us), AV_OPT_TYPE_DURATION,
1954  { .i64 = SDT_RETRANS_TIME * 1000LL }, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
1955  { NULL },
1956 };
1957 
1958 static const AVClass mpegts_muxer_class = {
1959  .class_name = "MPEGTS muxer",
1960  .item_name = av_default_item_name,
1961  .option = options,
1962  .version = LIBAVUTIL_VERSION_INT,
1963 };
1964 
1966  .name = "mpegts",
1967  .long_name = NULL_IF_CONFIG_SMALL("MPEG-TS (MPEG-2 Transport Stream)"),
1968  .mime_type = "video/MP2T",
1969  .extensions = "ts,m2t,m2ts,mts",
1970  .priv_data_size = sizeof(MpegTSWrite),
1971  .audio_codec = AV_CODEC_ID_MP2,
1972  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1973  .init = mpegts_init,
1976  .deinit = mpegts_deinit,
1977  .check_bitstream = mpegts_check_bitstream,
1979  .priv_class = &mpegts_muxer_class,
1980 };
#define NULL
Definition: coverity.c:32
#define SDT_PID
Definition: mpegts.h:43
Bytestream IO Context.
Definition: avio.h:161
static struct @305 state
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
version
Definition: libkvazaar.c:292
#define PMT_TID
Definition: mpegts.h:71
#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:387
#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:1421
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:883
#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:4943
static void retransmit_si_info(AVFormatContext *s, int force_pat, int force_sdt, int64_t pcr)
Definition: mpegtsenc.c:1023
#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:848
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:4036
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:877
int size
Definition: avcodec.h:1534
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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:834
#define STREAM_TYPE_AUDIO_EAC3
Definition: mpegts.h:128
void * priv_data
Definition: avformat.h:891
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:836
const char * key
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:471
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1376
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1661
Format I/O context.
Definition: avformat.h:1353
#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:788
unsigned int nb_stream_indexes
Definition: avformat.h:1275
#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:281
#define LAST_OTHER_PID
Definition: mpegts.h:62
#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:883
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:4524
static int mpegts_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
Definition: mpegtsenc.c:1845
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:1421
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:1802
Public header for CRC hash function implementation.
static int encode_str8(uint8_t *buf, const char *str)
Definition: mpegtsenc.c:686
int initial_padding
Audio only.
Definition: avcodec.h:4165
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:1062
uint8_t * data
Definition: avcodec.h:1533
uint32_t tag
Definition: movenc.c:1534
#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:644
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:213
#define STREAM_TYPE_VIDEO_VC1
Definition: mpegts.h:122
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
static void extend_af(uint8_t *pkt, int size)
Definition: mpegtsenc.c:1136
unsigned int * stream_index
Definition: avformat.h:1274
#define MPEGTS_FLAG_AAC_LATM
Definition: mpegtsenc.c:100
#define av_log(a,...)
#define PAT_TID
Definition: mpegts.h:69
#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:1565
#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:1402
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:126
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:1156
#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:2051
#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:1593
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:1105
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:1144
char * url
input or output URL.
Definition: avformat.h:1449
unsigned int nb_programs
Definition: avformat.h:1532
#define STREAM_TYPE_VIDEO_DIRAC
Definition: mpegts.h:123
static void set_af_flag(uint8_t *pkt, int flag)
Definition: mpegtsenc.c:1120
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:578
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4032
static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
Definition: mpegtsenc.c:1077
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:1533
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:949
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1270
static int write_pcr_bits(uint8_t *buf, int64_t pcr)
Definition: mpegtsenc.c:1047
#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:1752
static void select_pcr_streams(AVFormatContext *s)
Definition: mpegtsenc.c:819
#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:1539
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:4054
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1409
#define STREAM_TYPE_AUDIO_AAC_LATM
Definition: mpegts.h:116
int ff_check_h264_startcode(AVFormatContext *s, const AVStream *st, const AVPacket *pkt)
Check presence of H264 startcode.
Definition: mpegtsenc.c:1449
static const AVOption options[]
Definition: mpegtsenc.c:1867
#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:516
#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
#define FIRST_OTHER_PID
Definition: mpegts.h:61
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:500
#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:1466
static MpegTSService * mpegts_add_service(AVFormatContext *s, int sid, const AVDictionary *metadata, AVProgram *program)
Definition: mpegtsenc.c:743
#define s(width, name)
Definition: cbs_vp9.c:257
AVOutputFormat ff_mpegts_muxer
Definition: mpegtsenc.c:1965
AVFormatContext * amux
Definition: mpegtsenc.c:236
AVDictionary * metadata
Definition: avformat.h:940
#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:222
#define STREAM_TYPE_VIDEO_MPEG4
Definition: mpeg.h:56
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1172
static void mpegts_deinit(AVFormatContext *s)
Definition: mpegtsenc.c:1820
ff_const59 struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1372
int pmt_start_pid
Definition: mpegtsenc.c:94
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1451
int service_type
Definition: mpegtsenc.c:92
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:835
void(* write_packet)(struct MpegTSSection *s, const uint8_t *packet)
Definition: mpegtsenc.c:50
Stream structure.
Definition: avformat.h:876
#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:118
#define av_bswap32
Definition: bswap.h:33
int frame_size
Definition: mxfenc.c:2140
#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:1395
#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
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:1485
int original_network_id
Definition: mpegtsenc.c:90
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2687
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:1343
byte swapping routines
static int mpegts_write_end(AVFormatContext *s)
Definition: mpegtsenc.c:1812
#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:4453
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:737
uint8_t * payload
Definition: mpegtsenc.c:235
AVDictionary * metadata
Definition: avformat.h:1276
static int64_t pts
static void mpegts_write_flush(AVFormatContext *s)
Definition: mpegtsenc.c:1777
#define flags(name, subs,...)
Definition: cbs_av1.c:564
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:4146
#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:556
static int64_t get_pcr(const MpegTSWrite *ts, AVIOContext *pb)
Definition: mpegtsenc.c:718
uint8_t name[256]
Definition: mpegtsenc.c:57
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:929
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:927
int den
Denominator.
Definition: rational.h:60
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:465
#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:5572
void * priv_data
Format private data.
Definition: avformat.h:1381
MpegTSSection pat
Definition: mpegtsenc.c:76
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:466
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:4050
int channels
Audio only.
Definition: avcodec.h:4142
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1532
int64_t pcr_period
Definition: mpegtsenc.c:238
static const AVClass mpegts_muxer_class
Definition: mpegtsenc.c:1958
#define av_freep(p)
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
#define av_malloc_array(a, b)
int opus_pending_trim_start
Definition: mpegtsenc.c:243
int stream_index
Definition: avcodec.h:1535
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:905
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
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: avcodec.h:1510
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:1526
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define STREAM_TYPE_AUDIO_TRUEHD
Definition: mpegts.h:127
AVProgram ** programs
Definition: avformat.h:1533
#define SDT_TID
Definition: mpegts.h:77
int tables_version
Definition: mpegtsenc.c:106
const char * name
Definition: opengl_enc.c:102