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