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