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