FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 */
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 {
411  stream->id = mpa_id++;
412  }
413 
414  /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
415  * Right now it is also used for everything else. */
416  stream->max_buffer_size = 4 * 1024;
417  s->audio_bound++;
418  break;
419  case AVMEDIA_TYPE_VIDEO:
420  if (st->codecpar->codec_id == AV_CODEC_ID_H264)
421  stream->id = h264_id++;
422  else
423  stream->id = mpv_id++;
424 
426  if (props && props->buffer_size)
427  stream->max_buffer_size = 6 * 1024 + props->buffer_size / 8;
428  else {
429  av_log(ctx, AV_LOG_WARNING,
430  "VBV buffer size not set, using default size of 230KB\n"
431  "If you want the mpeg file to be compliant to some specification\n"
432  "Like DVD, VCD or others, make sure you set the correct buffer size\n");
433  // FIXME: this is probably too small as default
434  stream->max_buffer_size = 230 * 1024;
435  }
436  if (stream->max_buffer_size > 1024 * 8191) {
437  av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
438  stream->max_buffer_size = 1024 * 8191;
439  }
440  s->video_bound++;
441  break;
443  stream->id = mps_id++;
444  stream->max_buffer_size = 16 * 1024;
445  break;
446  default:
447  av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
449  return AVERROR(EINVAL);
450  }
451  stream->fifo = av_fifo_alloc(16);
452  if (!stream->fifo)
453  goto fail;
454  }
455  bitrate = 0;
456  audio_bitrate = 0;
457  video_bitrate = 0;
458  for (i = 0; i < ctx->nb_streams; i++) {
459  AVCPBProperties *props;
460  int codec_rate;
461  st = ctx->streams[i];
462  stream = (StreamInfo *)st->priv_data;
463 
465  if (props)
466  codec_rate = props->max_bitrate;
467  else
468  codec_rate = st->codecpar->bit_rate;
469 
470  if (!codec_rate)
471  codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
472 
473  bitrate += codec_rate;
474 
475  if ((stream->id & 0xe0) == AUDIO_ID)
476  audio_bitrate += codec_rate;
477  else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
478  video_bitrate += codec_rate;
479  }
480 
481  if (s->user_mux_rate) {
482  s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
483  } else {
484  /* we increase slightly the bitrate to take into account the
485  * headers. XXX: compute it exactly */
486  bitrate += bitrate / 20;
487  bitrate += 10000;
488  s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
489  if (s->mux_rate >= (1<<22)) {
490  av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
491  s->mux_rate = (1<<22) - 1;
492  }
493  }
494 
495  if (s->is_vcd) {
496  int64_t overhead_rate;
497 
498  /* The VCD standard mandates that the mux_rate field is 3528
499  * (see standard p. IV-6).
500  * The value is actually "wrong", i.e. if you calculate
501  * it using the normal formula and the 75 sectors per second transfer
502  * rate you get a different value because the real pack size is 2324,
503  * not 2352. But the standard explicitly specifies that the mux_rate
504  * field in the header must have this value. */
505  // s->mux_rate = 2352 * 75 / 50; /* = 3528 */
506 
507  /* The VCD standard states that the muxed stream must be
508  * exactly 75 packs / second (the data rate of a single speed cdrom).
509  * Since the video bitrate (probably 1150000 bits/sec) will be below
510  * the theoretical maximum we have to add some padding packets
511  * to make up for the lower data rate.
512  * (cf. VCD standard p. IV-6 ) */
513 
514  /* Add the header overhead to the data rate.
515  * 2279 data bytes per audio pack, 2294 data bytes per video pack */
516  overhead_rate = audio_bitrate * 2294LL * (2324 - 2279);
517  overhead_rate += video_bitrate * 2279LL * (2324 - 2294);
518 
519  /* Add padding so that the full bitrate is 2324*75 bytes/sec */
520  s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;
521 #define VCD_PADDING_BITRATE_DEN (2279 * 2294)
522  }
523 
524  if (s->is_vcd || s->is_mpeg2)
525  /* every packet */
526  s->pack_header_freq = 1;
527  else
528  /* every 2 seconds */
529  s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
530 
531  /* the above seems to make pack_header_freq zero sometimes */
532  if (s->pack_header_freq == 0)
533  s->pack_header_freq = 1;
534 
535  if (s->is_mpeg2)
536  /* every 200 packets. Need to look at the spec. */
538  else if (s->is_vcd)
539  /* the standard mandates that there are only two system headers
540  * in the whole file: one in the first packet of each stream.
541  * (see standard p. IV-7 and IV-8) */
542  s->system_header_freq = 0x7fffffff;
543  else
545 
546  for (i = 0; i < ctx->nb_streams; i++) {
547  stream = ctx->streams[i]->priv_data;
548  stream->packet_number = 0;
549  }
552  return 0;
553 
554 fail:
555  for (i = 0; i < ctx->nb_streams; i++)
556  av_freep(&ctx->streams[i]->priv_data);
557  return AVERROR(ENOMEM);
558 }
559 
560 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
561 {
562  avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
563  avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
564  avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
565 }
566 
567 /* return the number of padding bytes that should be inserted into
568  * the multiplexed stream. */
570 {
571  MpegMuxContext *s = ctx->priv_data;
572  int pad_bytes = 0;
573 
574  if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
575  int64_t full_pad_bytes;
576 
577  // FIXME: this is wrong
578  full_pad_bytes =
580  pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
581 
582  if (pad_bytes < 0)
583  /* might happen if we have already padded to a later timestamp. This
584  * can occur if another stream has already advanced further. */
585  pad_bytes = 0;
586  }
587 
588  return pad_bytes;
589 }
590 
591 /* Write an MPEG padding packet header. */
593  int packet_bytes)
594 {
595  MpegMuxContext *s = ctx->priv_data;
596  int i;
597 
599  avio_wb16(pb, packet_bytes - 6);
600  if (!s->is_mpeg2) {
601  avio_w8(pb, 0x0f);
602  packet_bytes -= 7;
603  } else
604  packet_bytes -= 6;
605 
606  for (i = 0; i < packet_bytes; i++)
607  avio_w8(pb, 0xff);
608 }
609 
610 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
611 {
612  int nb_frames = 0;
613  PacketDesc *pkt_desc = stream->premux_packet;
614 
615  while (len > 0) {
616  if (pkt_desc->size == pkt_desc->unwritten_size)
617  nb_frames++;
618  len -= pkt_desc->unwritten_size;
619  pkt_desc = pkt_desc->next;
620  }
621 
622  return nb_frames;
623 }
624 
625 /* flush the packet on stream stream_index */
626 static int flush_packet(AVFormatContext *ctx, int stream_index,
627  int64_t pts, int64_t dts, int64_t scr, int trailer_size)
628 {
629  MpegMuxContext *s = ctx->priv_data;
630  StreamInfo *stream = ctx->streams[stream_index]->priv_data;
631  uint8_t *buf_ptr;
632  int size, payload_size, startcode, id, stuffing_size, i, header_len;
633  int packet_size;
634  uint8_t buffer[128];
635  int zero_trail_bytes = 0;
636  int pad_packet_bytes = 0;
637  int pes_flags;
638  /* "general" pack without data specific to one stream? */
639  int general_pack = 0;
640  int nb_frames;
641 
642  id = stream->id;
643 
644  av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
645 
646  buf_ptr = buffer;
647 
648  if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
649  /* output pack and systems header if needed */
650  size = put_pack_header(ctx, buf_ptr, scr);
651  buf_ptr += size;
652  s->last_scr = scr;
653 
654  if (s->is_vcd) {
655  /* there is exactly one system header for each stream in a VCD MPEG,
656  * One in the very first video packet and one in the very first
657  * audio packet (see VCD standard p. IV-7 and IV-8). */
658 
659  if (stream->packet_number == 0) {
660  size = put_system_header(ctx, buf_ptr, id);
661  buf_ptr += size;
662  }
663  } else if (s->is_dvd) {
664  if (stream->align_iframe || s->packet_number == 0) {
665  int PES_bytes_to_fill = s->packet_size - size - 10;
666 
667  if (pts != AV_NOPTS_VALUE) {
668  if (dts != pts)
669  PES_bytes_to_fill -= 5 + 5;
670  else
671  PES_bytes_to_fill -= 5;
672  }
673 
674  if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
675  size = put_system_header(ctx, buf_ptr, 0);
676  buf_ptr += size;
677  size = buf_ptr - buffer;
678  avio_write(ctx->pb, buffer, size);
679 
681  avio_wb16(ctx->pb, 0x03d4); // length
682  avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
683  for (i = 0; i < 979; i++)
684  avio_w8(ctx->pb, 0x00);
685 
687  avio_wb16(ctx->pb, 0x03fa); // length
688  avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
689  for (i = 0; i < 1017; i++)
690  avio_w8(ctx->pb, 0x00);
691 
692  memset(buffer, 0, 128);
693  buf_ptr = buffer;
694  s->packet_number++;
695  stream->align_iframe = 0;
696  // FIXME: rounding and first few bytes of each packet
697  scr += s->packet_size * 90000LL /
698  (s->mux_rate * 50LL);
699  size = put_pack_header(ctx, buf_ptr, scr);
700  s->last_scr = scr;
701  buf_ptr += size;
702  /* GOP Start */
703  } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
704  pad_packet_bytes = PES_bytes_to_fill -
705  stream->bytes_to_iframe;
706  }
707  }
708  } else {
709  if ((s->packet_number % s->system_header_freq) == 0) {
710  size = put_system_header(ctx, buf_ptr, 0);
711  buf_ptr += size;
712  }
713  }
714  }
715  size = buf_ptr - buffer;
716  avio_write(ctx->pb, buffer, size);
717 
718  packet_size = s->packet_size - size;
719 
720  if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
721  /* The VCD standard demands that 20 zero bytes follow
722  * each audio pack (see standard p. IV-8). */
723  zero_trail_bytes += 20;
724 
725  if ((s->is_vcd && stream->packet_number == 0) ||
726  (s->is_svcd && s->packet_number == 0)) {
727  /* for VCD the first pack of each stream contains only the pack header,
728  * the system header and lots of padding (see VCD standard p. IV-6).
729  * In the case of an audio pack, 20 zero bytes are also added at
730  * the end. */
731  /* For SVCD we fill the very first pack to increase compatibility with
732  * some DVD players. Not mandated by the standard. */
733  if (s->is_svcd)
734  /* the system header refers to both streams and no stream data */
735  general_pack = 1;
736  pad_packet_bytes = packet_size - zero_trail_bytes;
737  }
738 
739  packet_size -= pad_packet_bytes + zero_trail_bytes;
740 
741  if (packet_size > 0) {
742  /* packet header size */
743  packet_size -= 6;
744 
745  /* packet header */
746  if (s->is_mpeg2) {
747  header_len = 3;
748  if (stream->packet_number == 0)
749  header_len += 3; /* PES extension */
750  header_len += 1; /* obligatory stuffing byte */
751  } else {
752  header_len = 0;
753  }
754  if (pts != AV_NOPTS_VALUE) {
755  if (dts != pts)
756  header_len += 5 + 5;
757  else
758  header_len += 5;
759  } else {
760  if (!s->is_mpeg2)
761  header_len++;
762  }
763 
764  payload_size = packet_size - header_len;
765  if (id < 0xc0) {
766  startcode = PRIVATE_STREAM_1;
767  payload_size -= 1;
768  if (id >= 0x40) {
769  payload_size -= 3;
770  if (id >= 0xa0)
771  payload_size -= 3;
772  }
773  } else {
774  startcode = 0x100 + id;
775  }
776 
777  stuffing_size = payload_size - av_fifo_size(stream->fifo);
778 
779  // first byte does not fit -> reset pts/dts + stuffing
780  if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
781  int timestamp_len = 0;
782  if (dts != pts)
783  timestamp_len += 5;
784  if (pts != AV_NOPTS_VALUE)
785  timestamp_len += s->is_mpeg2 ? 5 : 4;
786  pts =
787  dts = AV_NOPTS_VALUE;
788  header_len -= timestamp_len;
789  if (s->is_dvd && stream->align_iframe) {
790  pad_packet_bytes += timestamp_len;
791  packet_size -= timestamp_len;
792  } else {
793  payload_size += timestamp_len;
794  }
795  stuffing_size += timestamp_len;
796  if (payload_size > trailer_size)
797  stuffing_size += payload_size - trailer_size;
798  }
799 
800  // can't use padding, so use stuffing
801  if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
802  packet_size += pad_packet_bytes;
803  payload_size += pad_packet_bytes; // undo the previous adjustment
804  if (stuffing_size < 0)
805  stuffing_size = pad_packet_bytes;
806  else
807  stuffing_size += pad_packet_bytes;
808  pad_packet_bytes = 0;
809  }
810 
811  if (stuffing_size < 0)
812  stuffing_size = 0;
813 
814  if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
815  if (payload_size < av_fifo_size(stream->fifo))
816  stuffing_size += payload_size % stream->lpcm_align;
817  }
818 
819  if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
820  pad_packet_bytes += stuffing_size;
821  packet_size -= stuffing_size;
822  payload_size -= stuffing_size;
823  stuffing_size = 0;
824  }
825 
826  nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
827 
828  avio_wb32(ctx->pb, startcode);
829 
830  avio_wb16(ctx->pb, packet_size);
831 
832  if (!s->is_mpeg2)
833  for (i = 0; i < stuffing_size; i++)
834  avio_w8(ctx->pb, 0xff);
835 
836  if (s->is_mpeg2) {
837  avio_w8(ctx->pb, 0x80); /* mpeg2 id */
838 
839  pes_flags = 0;
840 
841  if (pts != AV_NOPTS_VALUE) {
842  pes_flags |= 0x80;
843  if (dts != pts)
844  pes_flags |= 0x40;
845  }
846 
847  /* Both the MPEG-2 and the SVCD standards demand that the
848  * P-STD_buffer_size field be included in the first packet of
849  * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
850  * and MPEG-2 standard 2.7.7) */
851  if (stream->packet_number == 0)
852  pes_flags |= 0x01;
853 
854  avio_w8(ctx->pb, pes_flags); /* flags */
855  avio_w8(ctx->pb, header_len - 3 + stuffing_size);
856 
857  if (pes_flags & 0x80) /* write pts */
858  put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
859  if (pes_flags & 0x40) /* write dts */
860  put_timestamp(ctx->pb, 0x01, dts);
861 
862  if (pes_flags & 0x01) { /* write pes extension */
863  avio_w8(ctx->pb, 0x10); /* flags */
864 
865  /* P-STD buffer info */
866  if ((id & 0xe0) == AUDIO_ID)
867  avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
868  else
869  avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
870  }
871  } else {
872  if (pts != AV_NOPTS_VALUE) {
873  if (dts != pts) {
874  put_timestamp(ctx->pb, 0x03, pts);
875  put_timestamp(ctx->pb, 0x01, dts);
876  } else {
877  put_timestamp(ctx->pb, 0x02, pts);
878  }
879  } else {
880  avio_w8(ctx->pb, 0x0f);
881  }
882  }
883 
884  if (s->is_mpeg2) {
885  /* special stuffing byte that is always written
886  * to prevent accidental generation of start codes. */
887  avio_w8(ctx->pb, 0xff);
888 
889  for (i = 0; i < stuffing_size; i++)
890  avio_w8(ctx->pb, 0xff);
891  }
892 
893  if (startcode == PRIVATE_STREAM_1) {
894  avio_w8(ctx->pb, id);
895  if (id >= 0xa0) {
896  /* LPCM (XXX: check nb_frames) */
897  avio_w8(ctx->pb, 7);
898  avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
899  avio_w8(ctx->pb, stream->lpcm_header[0]);
900  avio_w8(ctx->pb, stream->lpcm_header[1]);
901  avio_w8(ctx->pb, stream->lpcm_header[2]);
902  } else if (id >= 0x40) {
903  /* AC-3 */
904  avio_w8(ctx->pb, nb_frames);
905  avio_wb16(ctx->pb, trailer_size + 1);
906  }
907  }
908 
909  /* output data */
910  av_assert0(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
911  av_fifo_generic_read(stream->fifo, ctx->pb,
912  payload_size - stuffing_size,
913  (void (*)(void*, void*, int))avio_write);
914  stream->bytes_to_iframe -= payload_size - stuffing_size;
915  } else {
916  payload_size =
917  stuffing_size = 0;
918  }
919 
920  if (pad_packet_bytes > 0)
921  put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
922 
923  for (i = 0; i < zero_trail_bytes; i++)
924  avio_w8(ctx->pb, 0x00);
925 
926  avio_flush(ctx->pb);
927 
928  s->packet_number++;
929 
930  /* only increase the stream packet number if this pack actually contains
931  * something that is specific to this stream! I.e. a dedicated header
932  * or some data. */
933  if (!general_pack)
934  stream->packet_number++;
935 
936  return payload_size - stuffing_size;
937 }
938 
940 {
941  /* There are two ways to do this padding: writing a sector/pack
942  * of 0 values, or writing an MPEG padding pack. Both seem to
943  * work with most decoders, BUT the VCD standard only allows a 0-sector
944  * (see standard p. IV-4, IV-5).
945  * So a 0-sector it is... */
946 
947  MpegMuxContext *s = ctx->priv_data;
948  int i;
949 
950  for (i = 0; i < s->packet_size; i++)
951  avio_w8(ctx->pb, 0);
952 
954 
955  avio_flush(ctx->pb);
956 
957  /* increasing the packet number is correct. The SCR of the following packs
958  * is calculated from the packet_number and it has to include the padding
959  * sector (it represents the sector index, not the MPEG pack index)
960  * (see VCD standard p. IV-6) */
961  s->packet_number++;
962 }
963 
964 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
965 {
966  int i;
967 
968  for (i = 0; i < ctx->nb_streams; i++) {
969  AVStream *st = ctx->streams[i];
970  StreamInfo *stream = st->priv_data;
971  PacketDesc *pkt_desc;
972 
973  while ((pkt_desc = stream->predecode_packet) &&
974  scr > pkt_desc->dts) { // FIXME: > vs >=
975  if (stream->buffer_index < pkt_desc->size ||
976  stream->predecode_packet == stream->premux_packet) {
977  av_log(ctx, AV_LOG_ERROR,
978  "buffer underflow st=%d bufi=%d size=%d\n",
979  i, stream->buffer_index, pkt_desc->size);
980  break;
981  }
982  stream->buffer_index -= pkt_desc->size;
983  stream->predecode_packet = pkt_desc->next;
984  av_freep(&pkt_desc);
985  }
986  }
987 
988  return 0;
989 }
990 
992 {
993  MpegMuxContext *s = ctx->priv_data;
994  AVStream *st;
995  StreamInfo *stream;
996  int i, avail_space = 0, es_size, trailer_size;
997  int best_i = -1;
998  int best_score = INT_MIN;
999  int ignore_constraints = 0;
1000  int ignore_delay = 0;
1001  int64_t scr = s->last_scr;
1002  PacketDesc *timestamp_packet;
1003  const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
1004 
1005 retry:
1006  for (i = 0; i < ctx->nb_streams; i++) {
1007  AVStream *st = ctx->streams[i];
1008  StreamInfo *stream = st->priv_data;
1009  const int avail_data = av_fifo_size(stream->fifo);
1010  const int space = stream->max_buffer_size - stream->buffer_index;
1011  int rel_space = 1024LL * space / stream->max_buffer_size;
1012  PacketDesc *next_pkt = stream->premux_packet;
1013 
1014  /* for subtitle, a single PES packet must be generated,
1015  * so we flush after every single subtitle packet */
1016  if (s->packet_size > avail_data && !flush
1018  return 0;
1019  if (avail_data == 0)
1020  continue;
1021  av_assert0(avail_data > 0);
1022 
1023  if (space < s->packet_size && !ignore_constraints)
1024  continue;
1025 
1026  if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
1027  continue;
1028  if ( stream->predecode_packet
1029  && stream->predecode_packet->size > stream->buffer_index)
1030  rel_space += 1<<28;
1031  if (rel_space > best_score) {
1032  best_score = rel_space;
1033  best_i = i;
1034  avail_space = space;
1035  }
1036  }
1037 
1038  if (best_i < 0) {
1039  int64_t best_dts = INT64_MAX;
1040  int has_premux = 0;
1041 
1042  for (i = 0; i < ctx->nb_streams; i++) {
1043  AVStream *st = ctx->streams[i];
1044  StreamInfo *stream = st->priv_data;
1045  PacketDesc *pkt_desc = stream->predecode_packet;
1046  if (pkt_desc && pkt_desc->dts < best_dts)
1047  best_dts = pkt_desc->dts;
1048  has_premux |= !!stream->premux_packet;
1049  }
1050 
1051  if (best_dts < INT64_MAX) {
1052  av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
1053  scr / 90000.0, best_dts / 90000.0);
1054 
1055  if (scr >= best_dts + 1 && !ignore_constraints) {
1056  av_log(ctx, AV_LOG_ERROR,
1057  "packet too large, ignoring buffer limits to mux it\n");
1058  ignore_constraints = 1;
1059  }
1060  scr = FFMAX(best_dts + 1, scr);
1061  if (remove_decoded_packets(ctx, scr) < 0)
1062  return -1;
1063  } else if (has_premux && flush) {
1064  av_log(ctx, AV_LOG_ERROR,
1065  "delay too large, ignoring ...\n");
1066  ignore_delay = 1;
1067  ignore_constraints = 1;
1068  } else
1069  return 0;
1070 
1071  goto retry;
1072  }
1073 
1074  av_assert0(best_i >= 0);
1075 
1076  st = ctx->streams[best_i];
1077  stream = st->priv_data;
1078 
1079  av_assert0(av_fifo_size(stream->fifo) > 0);
1080 
1081  av_assert0(avail_space >= s->packet_size || ignore_constraints);
1082 
1083  timestamp_packet = stream->premux_packet;
1084  if (timestamp_packet->unwritten_size == timestamp_packet->size) {
1085  trailer_size = 0;
1086  } else {
1087  trailer_size = timestamp_packet->unwritten_size;
1088  timestamp_packet = timestamp_packet->next;
1089  }
1090 
1091  if (timestamp_packet) {
1092  av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
1093  timestamp_packet->dts / 90000.0,
1094  timestamp_packet->pts / 90000.0,
1095  scr / 90000.0, best_i);
1096  es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
1097  timestamp_packet->dts, scr, trailer_size);
1098  } else {
1099  av_assert0(av_fifo_size(stream->fifo) == trailer_size);
1100  es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
1101  trailer_size);
1102  }
1103 
1104  if (s->is_vcd) {
1105  /* Write one or more padding sectors, if necessary, to reach
1106  * the constant overall bitrate. */
1107  int vcd_pad_bytes;
1108 
1109  // FIXME: pts cannot be correct here
1110  while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1112  // FIXME: rounding and first few bytes of each packet
1113  s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1114  }
1115  }
1116 
1117  stream->buffer_index += es_size;
1118  // FIXME: rounding and first few bytes of each packet
1119  s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1120 
1121  while (stream->premux_packet &&
1122  stream->premux_packet->unwritten_size <= es_size) {
1123  es_size -= stream->premux_packet->unwritten_size;
1124  stream->premux_packet = stream->premux_packet->next;
1125  }
1126  if (es_size) {
1127  av_assert0(stream->premux_packet);
1128  stream->premux_packet->unwritten_size -= es_size;
1129  }
1130 
1131  if (remove_decoded_packets(ctx, s->last_scr) < 0)
1132  return -1;
1133 
1134  return 1;
1135 }
1136 
1138 {
1139  int stream_index = pkt->stream_index;
1140  int size = pkt->size;
1141  uint8_t *buf = pkt->data;
1142  MpegMuxContext *s = ctx->priv_data;
1143  AVStream *st = ctx->streams[stream_index];
1144  StreamInfo *stream = st->priv_data;
1145  int64_t pts, dts;
1146  PacketDesc *pkt_desc;
1147  int preload;
1148  const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1149  (pkt->flags & AV_PKT_FLAG_KEY);
1150 
1151  preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1152 
1153  pts = pkt->pts;
1154  dts = pkt->dts;
1155 
1156  if (s->last_scr == AV_NOPTS_VALUE) {
1157  if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1158  if (dts != AV_NOPTS_VALUE)
1159  s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1160  s->last_scr = 0;
1161  } else {
1162  s->last_scr = dts - preload;
1163  s->preload = 0;
1164  }
1165  preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1166  av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1167  }
1168 
1169  if (dts != AV_NOPTS_VALUE) dts += preload;
1170  if (pts != AV_NOPTS_VALUE) pts += preload;
1171 
1172  av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1173  dts / 90000.0, pts / 90000.0, pkt->flags,
1174  pkt->stream_index, pts != AV_NOPTS_VALUE);
1175  if (!stream->premux_packet)
1176  stream->next_packet = &stream->premux_packet;
1177  *stream->next_packet =
1178  pkt_desc = av_mallocz(sizeof(PacketDesc));
1179  if (!pkt_desc)
1180  return AVERROR(ENOMEM);
1181  pkt_desc->pts = pts;
1182  pkt_desc->dts = dts;
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  pkt_desc->unwritten_size =
1197  pkt_desc->size = size;
1198  if (!stream->predecode_packet)
1199  stream->predecode_packet = pkt_desc;
1200  stream->next_packet = &pkt_desc->next;
1201 
1202  if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1203  return -1;
1204 
1205  if (s->is_dvd) {
1206  // min VOBU length 0.4 seconds (mpucoder)
1207  if (is_iframe &&
1208  (s->packet_number == 0 ||
1209  (pts - stream->vobu_start_pts >= 36000))) {
1210  stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1211  stream->align_iframe = 1;
1212  stream->vobu_start_pts = pts;
1213  }
1214  }
1215 
1216  av_fifo_generic_write(stream->fifo, buf, size, NULL);
1217 
1218  for (;;) {
1219  int ret = output_packet(ctx, 0);
1220  if (ret <= 0)
1221  return ret;
1222  }
1223 }
1224 
1226 {
1227  StreamInfo *stream;
1228  int i;
1229 
1230  for (;;) {
1231  int ret = output_packet(ctx, 1);
1232  if (ret < 0)
1233  return ret;
1234  else if (ret == 0)
1235  break;
1236  }
1237 
1238  /* End header according to MPEG-1 systems standard. We do not write
1239  * it as it is usually not needed by decoders and because it
1240  * complicates MPEG stream concatenation. */
1241  // avio_wb32(ctx->pb, ISO_11172_END_CODE);
1242  // avio_flush(ctx->pb);
1243 
1244  for (i = 0; i < ctx->nb_streams; i++) {
1245  stream = ctx->streams[i]->priv_data;
1246 
1247  av_assert0(av_fifo_size(stream->fifo) == 0);
1248  av_fifo_freep(&stream->fifo);
1249  }
1250  return 0;
1251 }
1252 
1253 #define OFFSET(x) offsetof(MpegMuxContext, x)
1254 #define E AV_OPT_FLAG_ENCODING_PARAM
1255 static const AVOption options[] = {
1256  { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1257  { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1258  { NULL },
1259 };
1260 
1261 #define MPEGENC_CLASS(flavor) \
1262 static const AVClass flavor ## _class = { \
1263  .class_name = #flavor " muxer", \
1264  .item_name = av_default_item_name, \
1265  .version = LIBAVUTIL_VERSION_INT, \
1266  .option = options, \
1267 };
1268 
1269 #if CONFIG_MPEG1SYSTEM_MUXER
1270 MPEGENC_CLASS(mpeg)
1272  .name = "mpeg",
1273  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1274  .mime_type = "video/mpeg",
1275  .extensions = "mpg,mpeg",
1276  .priv_data_size = sizeof(MpegMuxContext),
1277  .audio_codec = AV_CODEC_ID_MP2,
1278  .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1282  .priv_class = &mpeg_class,
1283 };
1284 #endif
1285 
1286 #if CONFIG_MPEG1VCD_MUXER
1287 MPEGENC_CLASS(vcd)
1288 AVOutputFormat ff_mpeg1vcd_muxer = {
1289  .name = "vcd",
1290  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1291  .mime_type = "video/mpeg",
1292  .priv_data_size = sizeof(MpegMuxContext),
1293  .audio_codec = AV_CODEC_ID_MP2,
1294  .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1298  .priv_class = &vcd_class,
1299 };
1300 #endif
1301 
1302 #if CONFIG_MPEG2VOB_MUXER
1303 MPEGENC_CLASS(vob)
1304 AVOutputFormat ff_mpeg2vob_muxer = {
1305  .name = "vob",
1306  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1307  .mime_type = "video/mpeg",
1308  .extensions = "vob",
1309  .priv_data_size = sizeof(MpegMuxContext),
1310  .audio_codec = AV_CODEC_ID_MP2,
1311  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1315  .priv_class = &vob_class,
1316 };
1317 #endif
1318 
1319 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1320 #if CONFIG_MPEG2SVCD_MUXER
1321 MPEGENC_CLASS(svcd)
1322 AVOutputFormat ff_mpeg2svcd_muxer = {
1323  .name = "svcd",
1324  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1325  .mime_type = "video/mpeg",
1326  .extensions = "vob",
1327  .priv_data_size = sizeof(MpegMuxContext),
1328  .audio_codec = AV_CODEC_ID_MP2,
1329  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1333  .priv_class = &svcd_class,
1334 };
1335 #endif
1336 
1337 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1338 #if CONFIG_MPEG2DVD_MUXER
1339 MPEGENC_CLASS(dvd)
1340 AVOutputFormat ff_mpeg2dvd_muxer = {
1341  .name = "dvd",
1342  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1343  .mime_type = "video/mpeg",
1344  .extensions = "dvd",
1345  .priv_data_size = sizeof(MpegMuxContext),
1346  .audio_codec = AV_CODEC_ID_MP2,
1347  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1351  .priv_class = &dvd_class,
1352 };
1353 #endif
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:689
unsigned int packet_size
Definition: avformat.h:1475
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:1255
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:964
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:4882
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:1123
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:610
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3931
int size
Definition: avcodec.h:1467
#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:889
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:1351
static int output_packet(AVFormatContext *ctx, int flush)
Definition: mpegenc.c:991
static int flush_packet(AVFormatContext *ctx, int stream_index, int64_t pts, int64_t dts, int64_t scr, int trailer_size)
Definition: mpegenc.c:626
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:5476
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
#define SYSTEM_HEADER_START_CODE
Definition: mpeg.h:29
uint8_t * data
Definition: avcodec.h:1466
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:1150
ptrdiff_t size
Definition: opengl_enc.c:101
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:569
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1370
int size
Definition: mpegenc.c:41
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3960
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1498
#define MPEGENC_CLASS(flavor)
Definition: mpegenc.c:1261
#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 AVERROR(e)
Definition: error.h:43
#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
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3927
#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:118
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1472
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
static void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
Definition: mpegenc.c:560
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:507
AVFormatContext * ctx
Definition: movenc.c:48
#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:592
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:1139
Stream structure.
Definition: avformat.h:874
#define H264_ID
Definition: mpeg.h:43
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1117
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
static void put_vcd_padding_sector(AVFormatContext *ctx)
Definition: mpegenc.c:939
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:1225
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
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:690
Describe the class of an AVClass context structure.
Definition: log.h:67
#define E
Definition: mpegenc.c:1254
#define AC3_ID
Definition: mpeg.h:44
AVOutputFormat ff_mpeg2dvd_muxer
int mux_rate
Definition: mpegenc.c:70
#define OFFSET(x)
Definition: mpegenc.c:1253
int user_mux_rate
Definition: mpegenc.c:69
PacketDesc * premux_packet
Definition: mpegenc.c:52
static int64_t pts
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:4041
int64_t bitrate
Definition: h264_levels.c:89
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
if(ret< 0)
Definition: vf_mcdeint.c:279
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:1379
This side data corresponds to the AVCPBProperties struct.
Definition: avcodec.h:1278
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:3973
int channels
Audio only.
Definition: avcodec.h:4037
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
Definition: mpegenc.c:1137
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1465
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:1021
int stream_index
Definition: avcodec.h:1468
enum AVCodecID id
This structure stores compressed data.
Definition: avcodec.h:1443
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1459
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define VCD_PADDING_BITRATE_DEN
GLuint buffer
Definition: opengl_enc.c:102
AVOutputFormat ff_mpeg2vob_muxer
bitstream writer API