FFmpeg
mpegenc.c
Go to the documentation of this file.
1 /*
2  * MPEG-1/2 muxer
3  * Copyright (c) 2000, 2001, 2002 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 "config_components.h"
23 
24 #include <stdint.h>
25 
26 #include "libavutil/attributes.h"
27 #include "libavutil/fifo.h"
28 #include "libavutil/log.h"
29 #include "libavutil/mathematics.h"
30 #include "libavutil/opt.h"
31 
32 #include "libavcodec/put_bits.h"
33 
34 #include "avformat.h"
35 #include "avio_internal.h"
36 #include "internal.h"
37 #include "mpeg.h"
38 
39 #define MAX_PAYLOAD_SIZE 4096
40 
41 typedef struct PacketDesc {
42  int64_t pts;
43  int64_t dts;
44  int size;
46  struct PacketDesc *next;
47 } PacketDesc;
48 
49 typedef struct StreamInfo {
51  uint8_t id;
52  int max_buffer_size; /* in bytes */
54  PacketDesc *predecode_packet; /* start of packet queue */
55  PacketDesc *last_packet; /* end of packet queue */
58  uint8_t lpcm_header[3];
62  int64_t vobu_start_pts;
63 } StreamInfo;
64 
65 typedef struct MpegMuxContext {
66  const AVClass *class;
67  int packet_size; /* required packet size */
69  int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
72  int user_mux_rate; /* bitrate in units of bits/s */
73  int mux_rate; /* bitrate in units of 50 bytes/s */
74  /* stream info */
77  int is_mpeg2;
78  int is_vcd;
79  int is_svcd;
80  int is_dvd;
81  int64_t last_scr; /* current system clock */
82 
85 
86  int preload;
88 
93 
94 static int put_pack_header(AVFormatContext *ctx, uint8_t *buf,
95  int64_t timestamp)
96 {
98  PutBitContext pb;
99 
100  init_put_bits(&pb, buf, 128);
101 
103  if (s->is_mpeg2)
104  put_bits(&pb, 2, 0x1);
105  else
106  put_bits(&pb, 4, 0x2);
107  put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
108  put_bits(&pb, 1, 1);
109  put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
110  put_bits(&pb, 1, 1);
111  put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
112  put_bits(&pb, 1, 1);
113  if (s->is_mpeg2)
114  /* clock extension */
115  put_bits(&pb, 9, 0);
116  put_bits(&pb, 1, 1);
117  put_bits(&pb, 22, s->mux_rate);
118  put_bits(&pb, 1, 1);
119  if (s->is_mpeg2) {
120  put_bits(&pb, 1, 1);
121  put_bits(&pb, 5, 0x1f); /* reserved */
122  put_bits(&pb, 3, 0); /* stuffing length */
123  }
124  flush_put_bits(&pb);
125  return put_bits_ptr(&pb) - pb.buf;
126 }
127 
128 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,
129  int only_for_stream_id)
130 {
132  int size, i, private_stream_coded, id;
133  PutBitContext pb;
134 
135  init_put_bits(&pb, buf, 128);
136 
138  put_bits(&pb, 16, 0);
139  put_bits(&pb, 1, 1);
140 
141  /* maximum bit rate of the multiplexed stream */
142  put_bits(&pb, 22, s->mux_rate);
143  put_bits(&pb, 1, 1); /* marker */
144  if (s->is_vcd && only_for_stream_id == VIDEO_ID) {
145  /* This header applies only to the video stream
146  * (see VCD standard p. IV-7) */
147  put_bits(&pb, 6, 0);
148  } else
149  put_bits(&pb, 6, s->audio_bound);
150 
151  if (s->is_vcd) {
152  /* see VCD standard, p. IV-7 */
153  put_bits(&pb, 1, 0);
154  put_bits(&pb, 1, 1);
155  } else {
156  put_bits(&pb, 1, 0); /* variable bitrate */
157  put_bits(&pb, 1, 0); /* nonconstrained bitstream */
158  }
159 
160  if (s->is_vcd || s->is_dvd) {
161  /* see VCD standard p IV-7 */
162  put_bits(&pb, 1, 1); /* audio locked */
163  put_bits(&pb, 1, 1); /* video locked */
164  } else {
165  put_bits(&pb, 1, 0); /* audio locked */
166  put_bits(&pb, 1, 0); /* video locked */
167  }
168 
169  put_bits(&pb, 1, 1); /* marker */
170 
171  if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
172  /* This header applies only to the audio stream
173  * (see VCD standard p. IV-7) */
174  put_bits(&pb, 5, 0);
175  } else
176  put_bits(&pb, 5, s->video_bound);
177 
178  if (s->is_dvd) {
179  put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */
180  put_bits(&pb, 7, 0x7f); /* reserved byte */
181  } else
182  put_bits(&pb, 8, 0xff); /* reserved byte */
183 
184  /* DVD-Video Stream_bound entries
185  * id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
186  * id (0xB8) audio, maximum P-STD for any MPEG audio (0xC0 to 0xC7) streams. If there are none set to 4096 (32x128). (P-STD_buffer_bound_scale = 0)
187  * id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
188  * id (0xBF) private stream 2, NAV packs, set to 2x1024. */
189  if (s->is_dvd) {
190 
191  int P_STD_max_video = 0;
192  int P_STD_max_mpeg_audio = 0;
193  int P_STD_max_mpeg_PS1 = 0;
194 
195  for (i = 0; i < ctx->nb_streams; i++) {
196  StreamInfo *stream = ctx->streams[i]->priv_data;
197 
198  id = stream->id;
199  if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
200  P_STD_max_mpeg_PS1 = stream->max_buffer_size;
201  } else if (id >= 0xc0 && id <= 0xc7 &&
202  stream->max_buffer_size > P_STD_max_mpeg_audio) {
203  P_STD_max_mpeg_audio = stream->max_buffer_size;
204  } else if (id == 0xe0 &&
205  stream->max_buffer_size > P_STD_max_video) {
206  P_STD_max_video = stream->max_buffer_size;
207  }
208  }
209 
210  /* video */
211  put_bits(&pb, 8, 0xb9); /* stream ID */
212  put_bits(&pb, 2, 3);
213  put_bits(&pb, 1, 1);
214  put_bits(&pb, 13, P_STD_max_video / 1024);
215 
216  /* audio */
217  if (P_STD_max_mpeg_audio == 0)
218  P_STD_max_mpeg_audio = 4096;
219  put_bits(&pb, 8, 0xb8); /* stream ID */
220  put_bits(&pb, 2, 3);
221  put_bits(&pb, 1, 0);
222  put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
223 
224  /* private stream 1 */
225  put_bits(&pb, 8, 0xbd); /* stream ID */
226  put_bits(&pb, 2, 3);
227  put_bits(&pb, 1, 0);
228  put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
229 
230  /* private stream 2 */
231  put_bits(&pb, 8, 0xbf); /* stream ID */
232  put_bits(&pb, 2, 3);
233  put_bits(&pb, 1, 1);
234  put_bits(&pb, 13, 2);
235  } else {
236  /* audio stream info */
237  private_stream_coded = 0;
238  for (i = 0; i < ctx->nb_streams; i++) {
239  StreamInfo *stream = ctx->streams[i]->priv_data;
240 
241  /* For VCDs, only include the stream info for the stream
242  * that the pack which contains this system belongs to.
243  * (see VCD standard p. IV-7) */
244  if (!s->is_vcd || stream->id == only_for_stream_id ||
245  only_for_stream_id == 0) {
246  id = stream->id;
247  if (id < 0xc0) {
248  /* special case for private streams (AC-3 uses that) */
249  if (private_stream_coded)
250  continue;
251  private_stream_coded = 1;
252  id = 0xbd;
253  }
254  put_bits(&pb, 8, id); /* stream ID */
255  put_bits(&pb, 2, 3);
256  if (id < 0xe0) {
257  /* audio */
258  put_bits(&pb, 1, 0);
259  put_bits(&pb, 13, stream->max_buffer_size / 128);
260  } else {
261  /* video */
262  put_bits(&pb, 1, 1);
263  put_bits(&pb, 13, stream->max_buffer_size / 1024);
264  }
265  }
266  }
267  }
268 
269  flush_put_bits(&pb);
270  size = put_bits_ptr(&pb) - pb.buf;
271  /* patch packet size */
272  AV_WB16(buf + 4, size - 6);
273 
274  return size;
275 }
276 
278 {
279  int buf_index, i, private_stream_coded;
280  StreamInfo *stream;
282 
283  if (s->is_dvd)
284  return 18; // DVD-Video system headers are 18 bytes fixed length.
285 
286  buf_index = 12;
287  private_stream_coded = 0;
288  for (i = 0; i < ctx->nb_streams; i++) {
289  stream = ctx->streams[i]->priv_data;
290  if (stream->id < 0xc0) {
291  if (private_stream_coded)
292  continue;
293  private_stream_coded = 1;
294  }
295  buf_index += 3;
296  }
297  return buf_index;
298 }
299 
301 {
303  int bitrate, i, mpa_id, mpv_id, h264_id, mps_id, ac3_id, dts_id, lpcm_id, j;
304  AVStream *st;
305  StreamInfo *stream;
306  int audio_bitrate;
307  int video_bitrate;
308 
309  s->packet_number = 0;
310  s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
311  s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
312  s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
313  (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
314  (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
315  s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
316 
317  if (ctx->packet_size) {
318  if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
319  av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
320  ctx->packet_size);
321  return AVERROR(EINVAL);
322  }
323  s->packet_size = ctx->packet_size;
324  } else
325  s->packet_size = 2048;
326  if (ctx->max_delay < 0) /* Not set by the caller */
327  ctx->max_delay = AV_TIME_BASE*7/10;
328 
329  s->vcd_padding_bytes_written = 0;
330  s->vcd_padding_bitrate_num = 0;
331 
332  s->audio_bound = 0;
333  s->video_bound = 0;
334 
335  mpa_id = AUDIO_ID;
336  ac3_id = AC3_ID;
337  dts_id = DTS_ID;
338  mpv_id = VIDEO_ID;
339  h264_id = H264_ID;
340  mps_id = SUB_ID;
341  lpcm_id = LPCM_ID;
342 
343  for (i = 0; i < ctx->nb_streams; i++) {
344  AVCPBProperties *props;
345 
346  st = ctx->streams[i];
347  stream = av_mallocz(sizeof(StreamInfo));
348  if (!stream)
349  return AVERROR(ENOMEM);
350  st->priv_data = stream;
351 
352  avpriv_set_pts_info(st, 64, 1, 90000);
353 
354  switch (st->codecpar->codec_type) {
355  case AVMEDIA_TYPE_AUDIO:
356  if (!s->is_mpeg2 &&
357  (st->codecpar->codec_id == AV_CODEC_ID_AC3 ||
362  "%s in MPEG-1 system streams is not widely supported, "
363  "consider using the vob or the dvd muxer "
364  "to force a MPEG-2 program stream.\n",
366  if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
367  stream->id = ac3_id++;
368  } else if (st->codecpar->codec_id == AV_CODEC_ID_DTS) {
369  stream->id = dts_id++;
370  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
371  stream->id = lpcm_id++;
372  for (j = 0; j < 4; j++) {
373  if (lpcm_freq_tab[j] == st->codecpar->sample_rate)
374  break;
375  }
376  if (j == 4) {
377  int sr;
378  av_log(ctx, AV_LOG_ERROR, "Invalid sampling rate for PCM stream.\n");
379  av_log(ctx, AV_LOG_INFO, "Allowed sampling rates:");
380  for (sr = 0; sr < 4; sr++)
381  av_log(ctx, AV_LOG_INFO, " %d", lpcm_freq_tab[sr]);
382  av_log(ctx, AV_LOG_INFO, "\n");
383  return AVERROR(EINVAL);
384  }
385  if (st->codecpar->ch_layout.nb_channels > 8) {
386  av_log(ctx, AV_LOG_ERROR, "At most 8 channels allowed for LPCM streams.\n");
387  return AVERROR(EINVAL);
388  }
389  stream->lpcm_header[0] = 0x0c;
390  stream->lpcm_header[1] = (st->codecpar->ch_layout.nb_channels - 1) | (j << 4);
391  stream->lpcm_header[2] = 0x80;
392  stream->lpcm_align = st->codecpar->ch_layout.nb_channels * 2;
393  } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
394  int freq;
395 
396  switch (st->codecpar->sample_rate) {
397  case 48000: freq = 0; break;
398  case 96000: freq = 1; break;
399  case 44100: freq = 2; break;
400  case 32000: freq = 3; break;
401  default:
402  av_log(ctx, AV_LOG_ERROR, "Unsupported sample rate.\n");
403  return AVERROR(EINVAL);
404  }
405 
406  stream->lpcm_header[0] = 0x0c;
407  stream->lpcm_header[1] = (freq << 4) |
408  (((st->codecpar->bits_per_coded_sample - 16) / 4) << 6) |
409  st->codecpar->ch_layout.nb_channels - 1;
410  stream->lpcm_header[2] = 0x80;
411  stream->id = lpcm_id++;
413  } else if (st->codecpar->codec_id == AV_CODEC_ID_MLP ||
415  av_log(ctx, AV_LOG_ERROR, "Support for muxing audio codec %s not implemented.\n",
417  return AVERROR_PATCHWELCOME;
418  } else if (st->codecpar->codec_id != AV_CODEC_ID_MP1 &&
421  av_log(ctx, AV_LOG_ERROR, "Unsupported audio codec. Must be one of mp1, mp2, mp3, 16-bit pcm_dvd, pcm_s16be, ac3 or dts.\n");
422  return AVERROR(EINVAL);
423  } else {
424  stream->id = mpa_id++;
425  }
426 
427  /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
428  * Right now it is also used for everything else. */
429  stream->max_buffer_size = 4 * 1024;
430  s->audio_bound++;
431  break;
432  case AVMEDIA_TYPE_VIDEO:
433  if (st->codecpar->codec_id == AV_CODEC_ID_H264)
434  stream->id = h264_id++;
435  else
436  stream->id = mpv_id++;
437 
439  if (props && props->buffer_size)
440  stream->max_buffer_size = 6 * 1024 + props->buffer_size / 8;
441  else {
443  "VBV buffer size not set, using default size of 230KB\n"
444  "If you want the mpeg file to be compliant to some specification\n"
445  "Like DVD, VCD or others, make sure you set the correct buffer size\n");
446  // FIXME: this is probably too small as default
447  stream->max_buffer_size = 230 * 1024;
448  }
449  if (stream->max_buffer_size > 1024 * 8191) {
450  av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
451  stream->max_buffer_size = 1024 * 8191;
452  }
453  s->video_bound++;
454  break;
456  stream->id = mps_id++;
457  stream->max_buffer_size = 16 * 1024;
458  break;
459  default:
460  av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
462  return AVERROR(EINVAL);
463  }
464  stream->fifo = av_fifo_alloc2(16, 1, 0);
465  if (!stream->fifo)
466  return AVERROR(ENOMEM);
467  }
468  bitrate = 0;
469  audio_bitrate = 0;
470  video_bitrate = 0;
471  for (i = 0; i < ctx->nb_streams; i++) {
472  AVCPBProperties *props;
473  int codec_rate;
474  st = ctx->streams[i];
475  stream = (StreamInfo *)st->priv_data;
476 
478  if (props)
479  codec_rate = props->max_bitrate;
480  else
481  codec_rate = st->codecpar->bit_rate;
482 
483  if (!codec_rate)
484  codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
485 
486  bitrate += codec_rate;
487 
488  if ((stream->id & 0xe0) == AUDIO_ID)
489  audio_bitrate += codec_rate;
490  else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
491  video_bitrate += codec_rate;
492  }
493 
494  if (s->user_mux_rate) {
495  s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
496  } else {
497  /* we increase slightly the bitrate to take into account the
498  * headers. XXX: compute it exactly */
499  bitrate += bitrate / 20;
500  bitrate += 10000;
501  s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
502  if (s->mux_rate >= (1<<22)) {
503  av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
504  s->mux_rate = (1<<22) - 1;
505  }
506  }
507 
508  if (s->is_vcd) {
509  int64_t overhead_rate;
510 
511  /* The VCD standard mandates that the mux_rate field is 3528
512  * (see standard p. IV-6).
513  * The value is actually "wrong", i.e. if you calculate
514  * it using the normal formula and the 75 sectors per second transfer
515  * rate you get a different value because the real pack size is 2324,
516  * not 2352. But the standard explicitly specifies that the mux_rate
517  * field in the header must have this value. */
518  // s->mux_rate = 2352 * 75 / 50; /* = 3528 */
519 
520  /* The VCD standard states that the muxed stream must be
521  * exactly 75 packs / second (the data rate of a single speed cdrom).
522  * Since the video bitrate (probably 1150000 bits/sec) will be below
523  * the theoretical maximum we have to add some padding packets
524  * to make up for the lower data rate.
525  * (cf. VCD standard p. IV-6 ) */
526 
527  /* Add the header overhead to the data rate.
528  * 2279 data bytes per audio pack, 2294 data bytes per video pack */
529  overhead_rate = audio_bitrate * 2294LL * (2324 - 2279);
530  overhead_rate += video_bitrate * 2279LL * (2324 - 2294);
531 
532  /* Add padding so that the full bitrate is 2324*75 bytes/sec */
533  s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;
534 #define VCD_PADDING_BITRATE_DEN (2279 * 2294)
535  }
536 
537  if (s->is_vcd || s->is_mpeg2)
538  /* every packet */
539  s->pack_header_freq = 1;
540  else
541  /* every 2 seconds */
542  s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
543 
544  /* the above seems to make pack_header_freq zero sometimes */
545  if (s->pack_header_freq == 0)
546  s->pack_header_freq = 1;
547 
548  if (s->is_mpeg2)
549  /* every 200 packets. Need to look at the spec. */
550  s->system_header_freq = s->pack_header_freq * 40;
551  else if (s->is_vcd)
552  /* the standard mandates that there are only two system headers
553  * in the whole file: one in the first packet of each stream.
554  * (see standard p. IV-7 and IV-8) */
555  s->system_header_freq = 0x7fffffff;
556  else
557  s->system_header_freq = s->pack_header_freq * 5;
558 
559  for (i = 0; i < ctx->nb_streams; i++) {
560  stream = ctx->streams[i]->priv_data;
561  stream->packet_number = 0;
562  }
563  s->system_header_size = get_system_header_size(ctx);
564  s->last_scr = AV_NOPTS_VALUE;
565  return 0;
566 }
567 
568 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
569 {
570  avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
571  avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
572  avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
573 }
574 
575 /* return the number of padding bytes that should be inserted into
576  * the multiplexed stream. */
578 {
580  int pad_bytes = 0;
581 
582  if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
583  int64_t full_pad_bytes;
584 
585  // FIXME: this is wrong
586  full_pad_bytes =
587  av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);
588  pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
589 
590  if (pad_bytes < 0)
591  /* might happen if we have already padded to a later timestamp. This
592  * can occur if another stream has already advanced further. */
593  pad_bytes = 0;
594  }
595 
596  return pad_bytes;
597 }
598 
599 /* Write an MPEG padding packet header. */
601  int packet_bytes)
602 {
604 
606  avio_wb16(pb, packet_bytes - 6);
607  if (!s->is_mpeg2) {
608  avio_w8(pb, 0x0f);
609  packet_bytes -= 7;
610  } else
611  packet_bytes -= 6;
612 
613  ffio_fill(pb, 0xff, packet_bytes);
614 }
615 
616 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
617 {
618  int nb_frames = 0;
619  PacketDesc *pkt_desc = stream->premux_packet;
620 
621  while (len > 0) {
622  if (pkt_desc->size == pkt_desc->unwritten_size)
623  nb_frames++;
624  len -= pkt_desc->unwritten_size;
625  pkt_desc = pkt_desc->next;
626  }
627 
628  return nb_frames;
629 }
630 
631 static int fifo_avio_wrapper(void *opaque, void *buf, size_t *nb_elems)
632 {
633  avio_write(opaque, buf, *nb_elems);
634  return 0;
635 }
636 
637 /* flush the packet on stream stream_index */
638 static int flush_packet(AVFormatContext *ctx, int stream_index,
639  int64_t pts, int64_t dts, int64_t scr, int trailer_size)
640 {
642  StreamInfo *stream = ctx->streams[stream_index]->priv_data;
643  uint8_t *buf_ptr;
644  int size, payload_size, startcode, id, stuffing_size, header_len;
645  int packet_size;
646  uint8_t buffer[128];
647  int zero_trail_bytes = 0;
648  int pad_packet_bytes = 0;
649  int pes_flags;
650  /* "general" pack without data specific to one stream? */
651  int general_pack = 0;
652  int nb_frames;
653 
654  id = stream->id;
655 
656  av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
657 
658  buf_ptr = buffer;
659 
660  if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
661  /* output pack and systems header if needed */
662  size = put_pack_header(ctx, buf_ptr, scr);
663  buf_ptr += size;
664  s->last_scr = scr;
665 
666  if (s->is_vcd) {
667  /* there is exactly one system header for each stream in a VCD MPEG,
668  * One in the very first video packet and one in the very first
669  * audio packet (see VCD standard p. IV-7 and IV-8). */
670 
671  if (stream->packet_number == 0) {
672  size = put_system_header(ctx, buf_ptr, id);
673  buf_ptr += size;
674  }
675  } else if (s->is_dvd) {
676  if (stream->align_iframe || s->packet_number == 0) {
677  int PES_bytes_to_fill = s->packet_size - size - 10;
678 
679  if (pts != AV_NOPTS_VALUE) {
680  if (dts != pts)
681  PES_bytes_to_fill -= 5 + 5;
682  else
683  PES_bytes_to_fill -= 5;
684  }
685 
686  if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
687  size = put_system_header(ctx, buf_ptr, 0);
688  buf_ptr += size;
689  size = buf_ptr - buffer;
691 
693  avio_wb16(ctx->pb, 0x03d4); // length
694  avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
695  ffio_fill(ctx->pb, 0x00, 979);
696 
698  avio_wb16(ctx->pb, 0x03fa); // length
699  avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
700  ffio_fill(ctx->pb, 0x00, 1017);
701 
702  memset(buffer, 0, 128);
703  buf_ptr = buffer;
704  s->packet_number++;
705  stream->align_iframe = 0;
706  // FIXME: rounding and first few bytes of each packet
707  scr += s->packet_size * 90000LL /
708  (s->mux_rate * 50LL);
709  size = put_pack_header(ctx, buf_ptr, scr);
710  s->last_scr = scr;
711  buf_ptr += size;
712  /* GOP Start */
713  } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
714  pad_packet_bytes = PES_bytes_to_fill -
715  stream->bytes_to_iframe;
716  }
717  }
718  } else {
719  if ((s->packet_number % s->system_header_freq) == 0) {
720  size = put_system_header(ctx, buf_ptr, 0);
721  buf_ptr += size;
722  }
723  }
724  }
725  size = buf_ptr - buffer;
727 
728  packet_size = s->packet_size - size;
729 
730  if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
731  /* The VCD standard demands that 20 zero bytes follow
732  * each audio pack (see standard p. IV-8). */
733  zero_trail_bytes += 20;
734 
735  if ((s->is_vcd && stream->packet_number == 0) ||
736  (s->is_svcd && s->packet_number == 0)) {
737  /* for VCD the first pack of each stream contains only the pack header,
738  * the system header and lots of padding (see VCD standard p. IV-6).
739  * In the case of an audio pack, 20 zero bytes are also added at
740  * the end. */
741  /* For SVCD we fill the very first pack to increase compatibility with
742  * some DVD players. Not mandated by the standard. */
743  if (s->is_svcd)
744  /* the system header refers to both streams and no stream data */
745  general_pack = 1;
746  pad_packet_bytes = packet_size - zero_trail_bytes;
747  }
748 
749  packet_size -= pad_packet_bytes + zero_trail_bytes;
750 
751  if (packet_size > 0) {
752  size_t fifo_data;
753  /* packet header size */
754  packet_size -= 6;
755 
756  /* packet header */
757  if (s->is_mpeg2) {
758  header_len = 3;
759  if (stream->packet_number == 0)
760  header_len += 3; /* PES extension */
761  header_len += 1; /* obligatory stuffing byte */
762  } else {
763  header_len = 0;
764  }
765  if (pts != AV_NOPTS_VALUE) {
766  if (dts != pts)
767  header_len += 5 + 5;
768  else
769  header_len += 5;
770  } else {
771  if (!s->is_mpeg2)
772  header_len++;
773  }
774 
775  payload_size = packet_size - header_len;
776  if (id < 0xc0) {
777  startcode = PRIVATE_STREAM_1;
778  payload_size -= 1;
779  if (id >= 0x40) {
780  payload_size -= 3;
781  if (id >= 0xa0)
782  payload_size -= 3;
783  }
784  } else {
785  startcode = 0x100 + id;
786  }
787 
788  stuffing_size = payload_size - av_fifo_can_read(stream->fifo);
789 
790  // first byte does not fit -> reset pts/dts + stuffing
791  if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
792  int timestamp_len = 0;
793  if (dts != pts)
794  timestamp_len += 5;
795  if (pts != AV_NOPTS_VALUE)
796  timestamp_len += s->is_mpeg2 ? 5 : 4;
797  pts =
798  dts = AV_NOPTS_VALUE;
799  header_len -= timestamp_len;
800  if (s->is_dvd && stream->align_iframe) {
801  pad_packet_bytes += timestamp_len;
802  packet_size -= timestamp_len;
803  } else {
804  payload_size += timestamp_len;
805  }
806  stuffing_size += timestamp_len;
807  if (payload_size > trailer_size)
808  stuffing_size += payload_size - trailer_size;
809  }
810 
811  // can't use padding, so use stuffing
812  if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
813  packet_size += pad_packet_bytes;
814  payload_size += pad_packet_bytes; // undo the previous adjustment
815  if (stuffing_size < 0)
816  stuffing_size = pad_packet_bytes;
817  else
818  stuffing_size += pad_packet_bytes;
819  pad_packet_bytes = 0;
820  }
821 
822  if (stuffing_size < 0)
823  stuffing_size = 0;
824 
825  if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
826  if (payload_size < av_fifo_can_read(stream->fifo))
827  stuffing_size += payload_size % stream->lpcm_align;
828  }
829 
830  if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
831  pad_packet_bytes += stuffing_size;
832  packet_size -= stuffing_size;
833  payload_size -= stuffing_size;
834  stuffing_size = 0;
835  }
836 
837  nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
838 
839  avio_wb32(ctx->pb, startcode);
840 
841  avio_wb16(ctx->pb, packet_size);
842 
843  if (!s->is_mpeg2)
844  ffio_fill(ctx->pb, 0xff, stuffing_size);
845 
846  if (s->is_mpeg2) {
847  avio_w8(ctx->pb, 0x80); /* mpeg2 id */
848 
849  pes_flags = 0;
850 
851  if (pts != AV_NOPTS_VALUE) {
852  pes_flags |= 0x80;
853  if (dts != pts)
854  pes_flags |= 0x40;
855  }
856 
857  /* Both the MPEG-2 and the SVCD standards demand that the
858  * P-STD_buffer_size field be included in the first packet of
859  * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
860  * and MPEG-2 standard 2.7.7) */
861  if (stream->packet_number == 0)
862  pes_flags |= 0x01;
863 
864  avio_w8(ctx->pb, pes_flags); /* flags */
865  avio_w8(ctx->pb, header_len - 3 + stuffing_size);
866 
867  if (pes_flags & 0x80) /* write pts */
868  put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
869  if (pes_flags & 0x40) /* write dts */
870  put_timestamp(ctx->pb, 0x01, dts);
871 
872  if (pes_flags & 0x01) { /* write pes extension */
873  avio_w8(ctx->pb, 0x10); /* flags */
874 
875  /* P-STD buffer info */
876  if ((id & 0xe0) == AUDIO_ID)
877  avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
878  else
879  avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
880  }
881  } else {
882  if (pts != AV_NOPTS_VALUE) {
883  if (dts != pts) {
884  put_timestamp(ctx->pb, 0x03, pts);
885  put_timestamp(ctx->pb, 0x01, dts);
886  } else {
887  put_timestamp(ctx->pb, 0x02, pts);
888  }
889  } else {
890  avio_w8(ctx->pb, 0x0f);
891  }
892  }
893 
894  if (s->is_mpeg2) {
895  /* special stuffing byte that is always written
896  * to prevent accidental generation of start codes. */
897  avio_w8(ctx->pb, 0xff);
898 
899  ffio_fill(ctx->pb, 0xff, stuffing_size);
900  }
901 
902  if (startcode == PRIVATE_STREAM_1) {
903  avio_w8(ctx->pb, id);
904  if (id >= 0xa0) {
905  /* LPCM (XXX: check nb_frames) */
906  avio_w8(ctx->pb, 7);
907  avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
908  avio_w8(ctx->pb, stream->lpcm_header[0]);
909  avio_w8(ctx->pb, stream->lpcm_header[1]);
910  avio_w8(ctx->pb, stream->lpcm_header[2]);
911  } else if (id >= 0x40) {
912  /* AC-3 */
913  avio_w8(ctx->pb, nb_frames);
914  avio_wb16(ctx->pb, trailer_size + 1);
915  }
916  }
917 
918  /* output data */
919  fifo_data = payload_size - stuffing_size;
920  av_assert0(fifo_data <= av_fifo_can_read(stream->fifo));
921  av_fifo_read_to_cb(stream->fifo, fifo_avio_wrapper, ctx->pb, &fifo_data);
922  stream->bytes_to_iframe -= fifo_data;
923  } else {
924  payload_size =
925  stuffing_size = 0;
926  }
927 
928  if (pad_packet_bytes > 0)
929  put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
930 
931  ffio_fill(ctx->pb, 0x00, zero_trail_bytes);
932 
934 
935  s->packet_number++;
936 
937  /* only increase the stream packet number if this pack actually contains
938  * something that is specific to this stream! I.e. a dedicated header
939  * or some data. */
940  if (!general_pack)
941  stream->packet_number++;
942 
943  return payload_size - stuffing_size;
944 }
945 
947 {
948  /* There are two ways to do this padding: writing a sector/pack
949  * of 0 values, or writing an MPEG padding pack. Both seem to
950  * work with most decoders, BUT the VCD standard only allows a 0-sector
951  * (see standard p. IV-4, IV-5).
952  * So a 0-sector it is... */
953 
955 
956  ffio_fill(ctx->pb, 0, s->packet_size);
957 
958  s->vcd_padding_bytes_written += s->packet_size;
959 
961 
962  /* increasing the packet number is correct. The SCR of the following packs
963  * is calculated from the packet_number and it has to include the padding
964  * sector (it represents the sector index, not the MPEG pack index)
965  * (see VCD standard p. IV-6) */
966  s->packet_number++;
967 }
968 
969 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
970 {
971  int i;
972 
973  for (i = 0; i < ctx->nb_streams; i++) {
974  AVStream *st = ctx->streams[i];
975  StreamInfo *stream = st->priv_data;
976  PacketDesc *pkt_desc;
977 
978  while ((pkt_desc = stream->predecode_packet) &&
979  scr > pkt_desc->dts) { // FIXME: > vs >=
980  if (stream->buffer_index < pkt_desc->size ||
981  stream->predecode_packet == stream->premux_packet) {
983  "buffer underflow st=%d bufi=%d size=%d\n",
984  i, stream->buffer_index, pkt_desc->size);
985  break;
986  }
987  stream->buffer_index -= pkt_desc->size;
988  stream->predecode_packet = pkt_desc->next;
989  if (!stream->predecode_packet)
990  stream->last_packet = NULL;
991  av_freep(&pkt_desc);
992  }
993  }
994 
995  return 0;
996 }
997 
999 {
1001  AVStream *st;
1002  StreamInfo *stream;
1003  int i, avail_space = 0, es_size, trailer_size;
1004  int best_i = -1;
1005  int best_score = INT_MIN;
1006  int ignore_constraints = 0;
1007  int ignore_delay = 0;
1008  int64_t scr = s->last_scr;
1009  PacketDesc *timestamp_packet;
1010  const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1011 
1012 retry:
1013  for (i = 0; i < ctx->nb_streams; i++) {
1014  AVStream *st = ctx->streams[i];
1015  StreamInfo *stream = st->priv_data;
1016  const size_t avail_data = av_fifo_can_read(stream->fifo);
1017  const int space = stream->max_buffer_size - stream->buffer_index;
1018  int rel_space = 1024LL * space / stream->max_buffer_size;
1019  PacketDesc *next_pkt = stream->premux_packet;
1020 
1021  /* for subtitle, a single PES packet must be generated,
1022  * so we flush after every single subtitle packet */
1023  if (s->packet_size > avail_data && !flush
1025  return 0;
1026  if (avail_data == 0)
1027  continue;
1028  av_assert0(avail_data > 0);
1029 
1030  if (space < s->packet_size && !ignore_constraints)
1031  continue;
1032 
1033  if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
1034  continue;
1035  if ( stream->predecode_packet
1036  && stream->predecode_packet->size > stream->buffer_index)
1037  rel_space += 1<<28;
1038  if (rel_space > best_score) {
1039  best_score = rel_space;
1040  best_i = i;
1041  avail_space = space;
1042  }
1043  }
1044 
1045  if (best_i < 0) {
1046  int64_t best_dts = INT64_MAX;
1047  int has_premux = 0;
1048 
1049  for (i = 0; i < ctx->nb_streams; i++) {
1050  AVStream *st = ctx->streams[i];
1051  StreamInfo *stream = st->priv_data;
1052  PacketDesc *pkt_desc = stream->predecode_packet;
1053  if (pkt_desc && pkt_desc->dts < best_dts)
1054  best_dts = pkt_desc->dts;
1055  has_premux |= !!stream->premux_packet;
1056  }
1057 
1058  if (best_dts < INT64_MAX) {
1059  av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
1060  scr / 90000.0, best_dts / 90000.0);
1061 
1062  if (scr >= best_dts + 1 && !ignore_constraints) {
1064  "packet too large, ignoring buffer limits to mux it\n");
1065  ignore_constraints = 1;
1066  }
1067  scr = FFMAX(best_dts + 1, scr);
1068  if (remove_decoded_packets(ctx, scr) < 0)
1069  return -1;
1070  } else if (has_premux && flush) {
1072  "delay too large, ignoring ...\n");
1073  ignore_delay = 1;
1074  ignore_constraints = 1;
1075  } else
1076  return 0;
1077 
1078  goto retry;
1079  }
1080 
1081  av_assert0(best_i >= 0);
1082 
1083  st = ctx->streams[best_i];
1084  stream = st->priv_data;
1085 
1086  av_assert0(av_fifo_can_read(stream->fifo) > 0);
1087 
1088  av_assert0(avail_space >= s->packet_size || ignore_constraints);
1089 
1090  timestamp_packet = stream->premux_packet;
1091  if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1092  trailer_size = 0;
1093  } else {
1094  trailer_size = timestamp_packet->unwritten_size;
1095  timestamp_packet = timestamp_packet->next;
1096  }
1097 
1098  if (timestamp_packet) {
1099  av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
1100  timestamp_packet->dts / 90000.0,
1101  timestamp_packet->pts / 90000.0,
1102  scr / 90000.0, best_i);
1103  es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1104  timestamp_packet->dts, scr, trailer_size);
1105  } else {
1106  av_assert0(av_fifo_can_read(stream->fifo) == trailer_size);
1107  es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1108  trailer_size);
1109  }
1110 
1111  if (s->is_vcd) {
1112  /* Write one or more padding sectors, if necessary, to reach
1113  * the constant overall bitrate. */
1114  int vcd_pad_bytes;
1115 
1116  // FIXME: pts cannot be correct here
1117  while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1119  // FIXME: rounding and first few bytes of each packet
1120  s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1121  }
1122  }
1123 
1124  stream->buffer_index += es_size;
1125  // FIXME: rounding and first few bytes of each packet
1126  s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1127 
1128  while (stream->premux_packet &&
1129  stream->premux_packet->unwritten_size <= es_size) {
1130  es_size -= stream->premux_packet->unwritten_size;
1131  stream->premux_packet = stream->premux_packet->next;
1132  }
1133  if (es_size) {
1134  av_assert0(stream->premux_packet);
1135  stream->premux_packet->unwritten_size -= es_size;
1136  }
1137 
1138  if (remove_decoded_packets(ctx, s->last_scr) < 0)
1139  return -1;
1140 
1141  return 1;
1142 }
1143 
1145 {
1146  int stream_index = pkt->stream_index;
1147  int size = pkt->size;
1148  const uint8_t *buf = pkt->data;
1150  AVStream *st = ctx->streams[stream_index];
1151  StreamInfo *stream = st->priv_data;
1152  int64_t pts, dts;
1153  PacketDesc *pkt_desc;
1154  int preload, ret;
1155  size_t can_write;
1156  const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1157  (pkt->flags & AV_PKT_FLAG_KEY);
1158 
1159  preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1160 
1161  pts = pkt->pts;
1162  dts = pkt->dts;
1163 
1164  if (s->last_scr == AV_NOPTS_VALUE) {
1165  if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1166  if (dts != AV_NOPTS_VALUE)
1167  s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1168  s->last_scr = 0;
1169  } else {
1170  s->last_scr = dts - preload;
1171  s->preload = 0;
1172  }
1173  preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1174  av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1175  }
1176 
1177  if (dts != AV_NOPTS_VALUE) dts += preload;
1178  if (pts != AV_NOPTS_VALUE) pts += preload;
1179 
1180  av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1181  dts / 90000.0, pts / 90000.0, pkt->flags,
1183 
1184  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_DVD) {
1185  if (size < 3) {
1186  av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n", size);
1187  return AVERROR(EINVAL);
1188  }
1189 
1190  /* Skip first 3 bytes of packet data, which comprise PCM header
1191  and will be written fresh by this muxer. */
1192  buf += 3;
1193  size -= 3;
1194  }
1195 
1196  /* Enlarge the FIFO before adding a new PacketDesc
1197  * in order to avoid inconsistencies on failure. */
1198  can_write = av_fifo_can_write(stream->fifo);
1199  if (can_write < size) {
1200  ret = av_fifo_grow2(stream->fifo, size - can_write);
1201  if (ret < 0)
1202  return ret;
1203  }
1204  pkt_desc = av_mallocz(sizeof(PacketDesc));
1205  if (!pkt_desc)
1206  return AVERROR(ENOMEM);
1207  if (!stream->predecode_packet) {
1208  stream->predecode_packet = pkt_desc;
1209  } else
1210  stream->last_packet->next = pkt_desc;
1211  stream->last_packet = pkt_desc;
1212  if (!stream->premux_packet)
1213  stream->premux_packet = pkt_desc;
1214  pkt_desc->pts = pts;
1215  pkt_desc->dts = dts;
1216  pkt_desc->unwritten_size =
1217  pkt_desc->size = size;
1218 
1219  if (s->is_dvd) {
1220  // min VOBU length 0.4 seconds (mpucoder)
1221  if (is_iframe &&
1222  (s->packet_number == 0 || pts != AV_NOPTS_VALUE &&
1223  (pts - stream->vobu_start_pts >= 36000))) {
1224  stream->bytes_to_iframe = av_fifo_can_read(stream->fifo);
1225  stream->align_iframe = 1;
1226  stream->vobu_start_pts = pts;
1227  }
1228  }
1229 
1230  av_fifo_write(stream->fifo, buf, size);
1231 
1232  for (;;) {
1233  int ret = output_packet(ctx, 0);
1234  if (ret <= 0)
1235  return ret;
1236  }
1237 }
1238 
1240 {
1241  StreamInfo *stream;
1242  int i;
1243 
1244  for (;;) {
1245  int ret = output_packet(ctx, 1);
1246  if (ret < 0)
1247  return ret;
1248  else if (ret == 0)
1249  break;
1250  }
1251 
1252  /* End header according to MPEG-1 systems standard. We do not write
1253  * it as it is usually not needed by decoders and because it
1254  * complicates MPEG stream concatenation. */
1255  // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1256 
1257  for (i = 0; i < ctx->nb_streams; i++) {
1258  stream = ctx->streams[i]->priv_data;
1259 
1260  av_assert0(av_fifo_can_read(stream->fifo) == 0);
1261  }
1262  return 0;
1263 }
1264 
1266 {
1267  for (int i = 0; i < ctx->nb_streams; i++) {
1268  StreamInfo *stream = ctx->streams[i]->priv_data;
1269  if (!stream)
1270  continue;
1271  for (PacketDesc *pkt = stream->predecode_packet; pkt; ) {
1272  PacketDesc *tmp = pkt->next;
1273  av_free(pkt);
1274  pkt = tmp;
1275  }
1276  av_fifo_freep2(&stream->fifo);
1277  }
1278 }
1279 
1280 #define OFFSET(x) offsetof(MpegMuxContext, x)
1281 #define E AV_OPT_FLAG_ENCODING_PARAM
1282 static const AVOption options[] = {
1283  { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1284  { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1285  { NULL },
1286 };
1287 
1288 static const AVClass mpeg_class = {
1289  .class_name = "mpeg/(s)vcd/vob/dvd muxer",
1290  .item_name = av_default_item_name,
1291  .version = LIBAVUTIL_VERSION_INT,
1292  .option = options,
1293 };
1294 
1295 #if CONFIG_MPEG1SYSTEM_MUXER
1297  .name = "mpeg",
1298  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1299  .mime_type = "video/mpeg",
1300  .extensions = "mpg,mpeg",
1301  .priv_data_size = sizeof(MpegMuxContext),
1302  .audio_codec = AV_CODEC_ID_MP2,
1303  .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1308  .priv_class = &mpeg_class,
1309 };
1310 #endif
1311 
1312 #if CONFIG_MPEG1VCD_MUXER
1314  .name = "vcd",
1315  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1316  .mime_type = "video/mpeg",
1317  .priv_data_size = sizeof(MpegMuxContext),
1318  .audio_codec = AV_CODEC_ID_MP2,
1319  .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1324  .priv_class = &mpeg_class,
1325 };
1326 #endif
1327 
1328 #if CONFIG_MPEG2VOB_MUXER
1330  .name = "vob",
1331  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1332  .mime_type = "video/mpeg",
1333  .extensions = "vob",
1334  .priv_data_size = sizeof(MpegMuxContext),
1335  .audio_codec = AV_CODEC_ID_MP2,
1336  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1341  .priv_class = &mpeg_class,
1342 };
1343 #endif
1344 
1345 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1346 #if CONFIG_MPEG2SVCD_MUXER
1348  .name = "svcd",
1349  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1350  .mime_type = "video/mpeg",
1351  .extensions = "vob",
1352  .priv_data_size = sizeof(MpegMuxContext),
1353  .audio_codec = AV_CODEC_ID_MP2,
1354  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1359  .priv_class = &mpeg_class,
1360 };
1361 #endif
1362 
1363 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1364 #if CONFIG_MPEG2DVD_MUXER
1366  .name = "dvd",
1367  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1368  .mime_type = "video/mpeg",
1369  .extensions = "dvd",
1370  .priv_data_size = sizeof(MpegMuxContext),
1371  .audio_codec = AV_CODEC_ID_MP2,
1372  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1377  .priv_class = &mpeg_class,
1378 };
1379 #endif
PacketDesc::pts
int64_t pts
Definition: mpegenc.c:42
StreamInfo::vobu_start_pts
int64_t vobu_start_pts
Definition: mpegenc.c:62
StreamInfo::last_packet
PacketDesc * last_packet
Definition: mpegenc.c:55
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
StreamInfo::lpcm_align
int lpcm_align
Definition: mpegenc.c:59
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:432
SYSTEM_HEADER_START_CODE
#define SYSTEM_HEADER_START_CODE
Definition: mpeg.h:29
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
StreamInfo::align_iframe
int align_iframe
Definition: mpegenc.c:61
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:291
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
space
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated space
Definition: undefined.txt:4
MpegMuxContext::last_scr
int64_t last_scr
Definition: mpegenc.c:81
get_system_header_size
static int get_system_header_size(AVFormatContext *ctx)
Definition: mpegenc.c:277
VCD_PADDING_BITRATE_DEN
#define VCD_PADDING_BITRATE_DEN
AVStream::priv_data
void * priv_data
Definition: avformat.h:964
ff_mpeg1vcd_muxer
const AVOutputFormat ff_mpeg1vcd_muxer
MpegMuxContext::preload
int preload
Definition: mpegenc.c:86
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
mpeg_mux_init
static av_cold int mpeg_mux_init(AVFormatContext *ctx)
Definition: mpegenc.c:300
remove_decoded_packets
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
Definition: mpegenc.c:969
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1281
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:49
AVPacket::data
uint8_t * data
Definition: packet.h:374
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
AVOption
AVOption.
Definition: opt.h:251
flush_packet
static int flush_packet(AVFormatContext *ctx, int stream_index, int64_t pts, int64_t dts, int64_t scr, int trailer_size)
Definition: mpegenc.c:638
AUDIO_ID
#define AUDIO_ID
Definition: mpeg.h:41
StreamInfo::lpcm_header
uint8_t lpcm_header[3]
Definition: mpegenc.c:58
mathematics.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
get_nb_frames
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
Definition: mpegenc.c:616
PacketDesc::next
struct PacketDesc * next
Definition: mpegenc.c:46
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
MpegMuxContext::system_header_freq
int system_header_freq
Definition: mpegenc.c:70
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:473
StreamInfo::packet_number
int packet_number
Definition: mpegenc.c:57
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
MpegMuxContext
Definition: mpegenc.c:65
avio_write_marker
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:490
fifo.h
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:697
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:321
MpegMuxContext::is_dvd
int is_dvd
Definition: mpegenc.c:80
output_packet
static int output_packet(AVFormatContext *ctx, int flush)
Definition: mpegenc.c:998
ff_mpeg2svcd_muxer
const AVOutputFormat ff_mpeg2svcd_muxer
ff_mpeg1system_muxer
const AVOutputFormat ff_mpeg1system_muxer
MpegMuxContext::audio_bound
int audio_bound
Definition: mpegenc.c:75
pts
static int64_t pts
Definition: transcode_aac.c:654
PacketDesc
Definition: mpegenc.c:41
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:430
StreamInfo::max_buffer_size
int max_buffer_size
Definition: mpegenc.c:52
StreamInfo::id
uint8_t id
Definition: mpegenc.c:51
get_vcd_padding_size
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
Definition: mpegenc.c:577
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
StreamInfo::predecode_packet
PacketDesc * predecode_packet
Definition: mpegenc.c:54
s
#define s(width, name)
Definition: cbs_vp9.c:256
MpegMuxContext::is_mpeg2
int is_mpeg2
Definition: mpegenc.c:77
H264_ID
#define H264_ID
Definition: mpeg.h:43
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:429
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
StreamInfo::fifo
AVFifo * fifo
Definition: mpegenc.c:50
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
lpcm_freq_tab
static const int lpcm_freq_tab[4]
Definition: mpeg.h:63
MpegMuxContext::mux_rate
int mux_rate
Definition: mpegenc.c:73
av_fifo_can_write
size_t av_fifo_can_write(const AVFifo *f)
Definition: fifo.c:94
MpegMuxContext::user_mux_rate
int user_mux_rate
Definition: mpegenc.c:72
AV_CODEC_ID_PCM_DVD
@ AV_CODEC_ID_PCM_DVD
Definition: codec_id.h:339
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:104
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
PutBitContext
Definition: put_bits.h:50
MpegMuxContext::is_svcd
int is_svcd
Definition: mpegenc.c:79
PacketDesc::size
int size
Definition: mpegenc.c:44
MpegMuxContext::pack_header_freq
int pack_header_freq
Definition: mpegenc.c:69
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:53
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:606
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:100
AC3_ID
#define AC3_ID
Definition: mpeg.h:44
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1255
MpegMuxContext::system_header_size
int system_header_size
Definition: mpegenc.c:71
LPCM_ID
#define LPCM_ID
Definition: mpeg.h:46
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:210
StreamInfo::bytes_to_iframe
int bytes_to_iframe
Definition: mpegenc.c:60
put_padding_packet
static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb, int packet_bytes)
Definition: mpegenc.c:600
ffio_fill
void ffio_fill(AVIOContext *s, int b, int64_t count)
Definition: aviobuf.c:218
PACK_START_CODE
#define PACK_START_CODE
Definition: mpeg.h:28
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
put_timestamp
static void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
Definition: mpegenc.c:568
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:177
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:51
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1269
AVIOContext
Bytestream IO Context.
Definition: avio.h:162
StreamInfo
Definition: mpegenc.c:49
AVPacket::size
int size
Definition: packet.h:375
AVFifo
Definition: fifo.c:35
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:324
PRIVATE_STREAM_1
#define PRIVATE_STREAM_1
Definition: mpeg.h:37
put_vcd_padding_sector
static void put_vcd_padding_sector(AVFormatContext *ctx)
Definition: mpegenc.c:946
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:433
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
mpeg_class
static const AVClass mpeg_class
Definition: mpegenc.c:1288
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:232
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:394
fifo_avio_wrapper
static int fifo_avio_wrapper(void *opaque, void *buf, size_t *nb_elems)
Definition: mpegenc.c:631
mpeg.h
attributes.h
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
bitrate
int64_t bitrate
Definition: h264_levels.c:131
StreamInfo::buffer_index
int buffer_index
Definition: mpegenc.c:53
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
av_fifo_read_to_cb
int av_fifo_read_to_cb(AVFifo *f, AVFifoCB write_cb, void *opaque, size_t *nb_elems)
Feed data from a FIFO into a user-provided callback.
Definition: fifo.c:247
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:447
E
#define E
Definition: mpegenc.c:1281
PRIVATE_STREAM_2
#define PRIVATE_STREAM_2
Definition: mpeg.h:39
StreamInfo::premux_packet
PacketDesc * premux_packet
Definition: mpegenc.c:56
log.h
AVOutputFormat
Definition: avformat.h:509
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
avio_internal.h
mpeg_mux_end
static int mpeg_mux_end(AVFormatContext *ctx)
Definition: mpegenc.c:1239
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:109
AVFormatContext::max_delay
int max_delay
Definition: avformat.h:1325
DTS_ID
#define DTS_ID
Definition: mpeg.h:45
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:146
len
int len
Definition: vorbis_enc_data.h:426
PacketDesc::dts
int64_t dts
Definition: mpegenc.c:43
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
MpegMuxContext::vcd_padding_bytes_written
int64_t vcd_padding_bytes_written
Definition: mpegenc.c:84
MpegMuxContext::is_vcd
int is_vcd
Definition: mpegenc.c:78
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
AVFormatContext::oformat
const struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1232
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:125
avformat.h
av_stream_get_side_data
uint8_t * av_stream_get_side_data(const AVStream *st, enum AVPacketSideDataType type, size_t *size)
Get side information from stream.
Definition: avformat.c:140
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
VIDEO_ID
#define VIDEO_ID
Definition: mpeg.h:42
ff_mpeg2vob_muxer
const AVOutputFormat ff_mpeg2vob_muxer
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
MpegMuxContext::video_bound
int video_bound
Definition: mpegenc.c:76
put_bits_ptr
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:370
PADDING_STREAM
#define PADDING_STREAM
Definition: mpeg.h:38
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
OFFSET
#define OFFSET(x)
Definition: mpegenc.c:1280
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
SUB_ID
#define SUB_ID
Definition: mpeg.h:47
AVPacket::stream_index
int stream_index
Definition: packet.h:376
AVFormatContext::packet_size
unsigned int packet_size
Definition: avformat.h:1324
MpegMuxContext::packet_size
int packet_size
Definition: mpegenc.c:67
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:103
put_system_header
static int put_system_header(AVFormatContext *ctx, uint8_t *buf, int only_for_stream_id)
Definition: mpegenc.c:128
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
MpegMuxContext::vcd_padding_bitrate_num
int64_t vcd_padding_bitrate_num
Definition: mpegenc.c:83
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:472
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:90
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
MpegMuxContext::packet_number
int packet_number
Definition: mpegenc.c:68
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
int
int
Definition: ffmpeg_filter.c:155
put_bits.h
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:52
options
static const AVOption options[]
Definition: mpegenc.c:1282
write_packet
static int write_packet(OutputFile *of, OutputStream *ost, AVPacket *pkt)
Definition: ffmpeg_mux.c:90
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: codec_id.h:471
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1241
mpeg_mux_deinit
static void mpeg_mux_deinit(AVFormatContext *ctx)
Definition: mpegenc.c:1265
mpeg_mux_write_packet
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
Definition: mpegenc.c:1144
ff_mpeg2dvd_muxer
const AVOutputFormat ff_mpeg2dvd_muxer
AV_CODEC_ID_MLP
@ AV_CODEC_ID_MLP
Definition: codec_id.h:458
PacketDesc::unwritten_size
int unwritten_size
Definition: mpegenc.c:45
put_pack_header
static int put_pack_header(AVFormatContext *ctx, uint8_t *buf, int64_t timestamp)
Definition: mpegenc.c:94
av_fifo_grow2
int av_fifo_grow2(AVFifo *f, size_t inc)
Enlarge an AVFifo.
Definition: fifo.c:99
AVIO_DATA_MARKER_FLUSH_POINT
@ AVIO_DATA_MARKER_FLUSH_POINT
A point in the output bytestream where the underlying AVIOContext might flush the buffer depending on...
Definition: avio.h:147