FFmpeg
 All Data Structures 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 "libavutil/fifo.h"
23 #include "libavutil/log.h"
24 #include "libavutil/mathematics.h"
25 #include "libavutil/opt.h"
26 #include "libavcodec/put_bits.h"
27 #include "avformat.h"
28 #include "internal.h"
29 #include "mpeg.h"
30 
31 #define MAX_PAYLOAD_SIZE 4096
32 
33 #undef NDEBUG
34 #include <assert.h>
35 
36 typedef struct PacketDesc {
37  int64_t pts;
38  int64_t dts;
39  int size;
41  int flags;
42  struct PacketDesc *next;
43 } PacketDesc;
44 
45 typedef struct {
48  int max_buffer_size; /* in bytes */
54  uint8_t lpcm_header[3];
58  int64_t vobu_start_pts;
59 } StreamInfo;
60 
61 typedef struct {
62  const AVClass *class;
63  int packet_size; /* required packet size */
65  int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
68  int user_mux_rate; /* bitrate in units of bits/s */
69  int mux_rate; /* bitrate in units of 50 bytes/s */
70  /* stream info */
73  int is_mpeg2;
74  int is_vcd;
75  int is_svcd;
76  int is_dvd;
77  int64_t last_scr; /* current system clock */
78 
79  double vcd_padding_bitrate; //FIXME floats
81 
82  int preload;
84 
89 
91  uint8_t *buf, int64_t timestamp)
92 {
93  MpegMuxContext *s = ctx->priv_data;
94  PutBitContext pb;
95 
96  init_put_bits(&pb, buf, 128);
97 
99  if (s->is_mpeg2) {
100  put_bits(&pb, 2, 0x1);
101  } else {
102  put_bits(&pb, 4, 0x2);
103  }
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  }
114  put_bits(&pb, 1, 1);
115  put_bits(&pb, 22, s->mux_rate);
116  put_bits(&pb, 1, 1);
117  if (s->is_mpeg2) {
118  put_bits(&pb, 1, 1);
119  put_bits(&pb, 5, 0x1f); /* reserved */
120  put_bits(&pb, 3, 0); /* stuffing length */
121  }
122  flush_put_bits(&pb);
123  return put_bits_ptr(&pb) - pb.buf;
124 }
125 
126 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,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  put_bits(&pb, 22, s->mux_rate); /* maximum bit rate of the multiplexed stream */
139  put_bits(&pb, 1, 1); /* marker */
140  if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
141  /* This header applies only to the video stream (see VCD standard p. IV-7)*/
142  put_bits(&pb, 6, 0);
143  } else
144  put_bits(&pb, 6, s->audio_bound);
145 
146  if (s->is_vcd) {
147  /* see VCD standard, p. IV-7*/
148  put_bits(&pb, 1, 0);
149  put_bits(&pb, 1, 1);
150  } else {
151  put_bits(&pb, 1, 0); /* variable bitrate*/
152  put_bits(&pb, 1, 0); /* non constrainted bit stream */
153  }
154 
155  if (s->is_vcd || s->is_dvd) {
156  /* see VCD standard p IV-7 */
157  put_bits(&pb, 1, 1); /* audio locked */
158  put_bits(&pb, 1, 1); /* video locked */
159  } else {
160  put_bits(&pb, 1, 0); /* audio locked */
161  put_bits(&pb, 1, 0); /* video locked */
162  }
163 
164  put_bits(&pb, 1, 1); /* marker */
165 
166  if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
167  /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
168  put_bits(&pb, 5, 0);
169  } else
170  put_bits(&pb, 5, s->video_bound);
171 
172  if (s->is_dvd) {
173  put_bits(&pb, 1, 0); /* packet_rate_restriction_flag */
174  put_bits(&pb, 7, 0x7f); /* reserved byte */
175  } else
176  put_bits(&pb, 8, 0xff); /* reserved byte */
177 
178  /* DVD-Video Stream_bound entries
179  id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
180  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)
181  id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
182  id (0xBF) private stream 2, NAV packs, set to 2x1024. */
183  if (s->is_dvd) {
184 
185  int P_STD_max_video = 0;
186  int P_STD_max_mpeg_audio = 0;
187  int P_STD_max_mpeg_PS1 = 0;
188 
189  for(i=0;i<ctx->nb_streams;i++) {
190  StreamInfo *stream = ctx->streams[i]->priv_data;
191 
192  id = stream->id;
193  if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
194  P_STD_max_mpeg_PS1 = stream->max_buffer_size;
195  } else if (id >= 0xc0 && id <= 0xc7 && stream->max_buffer_size > P_STD_max_mpeg_audio) {
196  P_STD_max_mpeg_audio = stream->max_buffer_size;
197  } else if (id == 0xe0 && stream->max_buffer_size > P_STD_max_video) {
198  P_STD_max_video = stream->max_buffer_size;
199  }
200  }
201 
202  /* video */
203  put_bits(&pb, 8, 0xb9); /* stream ID */
204  put_bits(&pb, 2, 3);
205  put_bits(&pb, 1, 1);
206  put_bits(&pb, 13, P_STD_max_video / 1024);
207 
208  /* audio */
209  if (P_STD_max_mpeg_audio == 0)
210  P_STD_max_mpeg_audio = 4096;
211  put_bits(&pb, 8, 0xb8); /* stream ID */
212  put_bits(&pb, 2, 3);
213  put_bits(&pb, 1, 0);
214  put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);
215 
216  /* private stream 1 */
217  put_bits(&pb, 8, 0xbd); /* stream ID */
218  put_bits(&pb, 2, 3);
219  put_bits(&pb, 1, 0);
220  put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);
221 
222  /* private stream 2 */
223  put_bits(&pb, 8, 0xbf); /* stream ID */
224  put_bits(&pb, 2, 3);
225  put_bits(&pb, 1, 1);
226  put_bits(&pb, 13, 2);
227  }
228  else {
229  /* audio stream info */
230  private_stream_coded = 0;
231  for(i=0;i<ctx->nb_streams;i++) {
232  StreamInfo *stream = ctx->streams[i]->priv_data;
233 
234 
235  /* For VCDs, only include the stream info for the stream
236  that the pack which contains this system belongs to.
237  (see VCD standard p. IV-7) */
238  if ( !s->is_vcd || stream->id==only_for_stream_id
239  || only_for_stream_id==0) {
240 
241  id = stream->id;
242  if (id < 0xc0) {
243  /* special case for private streams (AC-3 uses that) */
244  if (private_stream_coded)
245  continue;
246  private_stream_coded = 1;
247  id = 0xbd;
248  }
249  put_bits(&pb, 8, id); /* stream ID */
250  put_bits(&pb, 2, 3);
251  if (id < 0xe0) {
252  /* audio */
253  put_bits(&pb, 1, 0);
254  put_bits(&pb, 13, stream->max_buffer_size / 128);
255  } else {
256  /* video */
257  put_bits(&pb, 1, 1);
258  put_bits(&pb, 13, stream->max_buffer_size / 1024);
259  }
260  }
261  }
262  }
263 
264  flush_put_bits(&pb);
265  size = put_bits_ptr(&pb) - pb.buf;
266  /* patch packet size */
267  buf[4] = (size - 6) >> 8;
268  buf[5] = (size - 6) & 0xff;
269 
270  return size;
271 }
272 
274 {
275  int buf_index, i, private_stream_coded;
276  StreamInfo *stream;
277  MpegMuxContext *s = ctx->priv_data;
278 
279  if (s->is_dvd)
280  return 18; // DVD-Video system headers are 18 bytes fixed length.
281 
282  buf_index = 12;
283  private_stream_coded = 0;
284  for(i=0;i<ctx->nb_streams;i++) {
285  stream = ctx->streams[i]->priv_data;
286  if (stream->id < 0xc0) {
287  if (private_stream_coded)
288  continue;
289  private_stream_coded = 1;
290  }
291  buf_index += 3;
292  }
293  return buf_index;
294 }
295 
297 {
298  MpegMuxContext *s = ctx->priv_data;
299  int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
300  AVStream *st;
301  StreamInfo *stream;
302  int audio_bitrate;
303  int video_bitrate;
304 
305  s->packet_number = 0;
306  s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
307  s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
308  s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
309  (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
310  (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
311  s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
312 
313  if(ctx->packet_size) {
314  if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
315  av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
316  ctx->packet_size);
317  goto fail;
318  }
319  s->packet_size = ctx->packet_size;
320  } else
321  s->packet_size = 2048;
322  if (ctx->max_delay < 0) /* Not set by the caller */
323  ctx->max_delay = 0;
324 
326  s->vcd_padding_bitrate=0;
327 
328  s->audio_bound = 0;
329  s->video_bound = 0;
330  mpa_id = AUDIO_ID;
331  ac3_id = AC3_ID;
332  dts_id = DTS_ID;
333  mpv_id = VIDEO_ID;
334  mps_id = SUB_ID;
335  lpcm_id = LPCM_ID;
336  for(i=0;i<ctx->nb_streams;i++) {
337  st = ctx->streams[i];
338  stream = av_mallocz(sizeof(StreamInfo));
339  if (!stream)
340  goto fail;
341  st->priv_data = stream;
342 
343  avpriv_set_pts_info(st, 64, 1, 90000);
344 
345  switch(st->codec->codec_type) {
346  case AVMEDIA_TYPE_AUDIO:
347  if (st->codec->codec_id == AV_CODEC_ID_AC3) {
348  stream->id = ac3_id++;
349  } else if (st->codec->codec_id == AV_CODEC_ID_DTS) {
350  stream->id = dts_id++;
351  } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
352  stream->id = lpcm_id++;
353  for(j = 0; j < 4; j++) {
354  if (lpcm_freq_tab[j] == st->codec->sample_rate)
355  break;
356  }
357  if (j == 4)
358  goto fail;
359  if (st->codec->channels > 8)
360  return -1;
361  stream->lpcm_header[0] = 0x0c;
362  stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
363  stream->lpcm_header[2] = 0x80;
364  stream->lpcm_align = st->codec->channels * 2;
365  } else {
366  stream->id = mpa_id++;
367  }
368 
369  /* This value HAS to be used for VCD (see VCD standard, p. IV-7).
370  Right now it is also used for everything else.*/
371  stream->max_buffer_size = 4 * 1024;
372  s->audio_bound++;
373  break;
374  case AVMEDIA_TYPE_VIDEO:
375  stream->id = mpv_id++;
376  if (st->codec->rc_buffer_size)
377  stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
378  else {
379  av_log(ctx, AV_LOG_WARNING, "VBV buffer size not set, muxing may fail\n");
380  stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
381  }
382  s->video_bound++;
383  break;
385  stream->id = mps_id++;
386  stream->max_buffer_size = 16 * 1024;
387  break;
388  default:
389  return -1;
390  }
391  stream->fifo= av_fifo_alloc(16);
392  if (!stream->fifo)
393  goto fail;
394  }
395  bitrate = 0;
396  audio_bitrate = 0;
397  video_bitrate = 0;
398  for(i=0;i<ctx->nb_streams;i++) {
399  int codec_rate;
400  st = ctx->streams[i];
401  stream = (StreamInfo*) st->priv_data;
402 
403  if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
404  codec_rate= st->codec->rc_max_rate;
405  else
406  codec_rate= st->codec->bit_rate;
407 
408  if(!codec_rate)
409  codec_rate= (1<<21)*8*50/ctx->nb_streams;
410 
411  bitrate += codec_rate;
412 
413  if ((stream->id & 0xe0) == AUDIO_ID)
414  audio_bitrate += codec_rate;
415  else if (stream->id==VIDEO_ID)
416  video_bitrate += codec_rate;
417  }
418 
419  if (s->user_mux_rate) {
420  s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
421  } else {
422  /* we increase slightly the bitrate to take into account the
423  headers. XXX: compute it exactly */
424  bitrate += bitrate / 20;
425  bitrate += 10000;
426  s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
427  }
428 
429  if (s->is_vcd) {
430  double overhead_rate;
431 
432  /* The VCD standard mandates that the mux_rate field is 3528
433  (see standard p. IV-6).
434  The value is actually "wrong", i.e. if you calculate
435  it using the normal formula and the 75 sectors per second transfer
436  rate you get a different value because the real pack size is 2324,
437  not 2352. But the standard explicitly specifies that the mux_rate
438  field in the header must have this value.*/
439 // s->mux_rate=2352 * 75 / 50; /* = 3528*/
440 
441  /* The VCD standard states that the muxed stream must be
442  exactly 75 packs / second (the data rate of a single speed cdrom).
443  Since the video bitrate (probably 1150000 bits/sec) will be below
444  the theoretical maximum we have to add some padding packets
445  to make up for the lower data rate.
446  (cf. VCD standard p. IV-6 )*/
447 
448  /* Add the header overhead to the data rate.
449  2279 data bytes per audio pack, 2294 data bytes per video pack*/
450  overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
451  overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
452  overhead_rate *= 8;
453 
454  /* Add padding so that the full bitrate is 2324*75 bytes/sec */
455  s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
456  }
457 
458  if (s->is_vcd || s->is_mpeg2)
459  /* every packet */
460  s->pack_header_freq = 1;
461  else
462  /* every 2 seconds */
463  s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
464 
465  /* the above seems to make pack_header_freq zero sometimes */
466  if (s->pack_header_freq == 0)
467  s->pack_header_freq = 1;
468 
469  if (s->is_mpeg2)
470  /* every 200 packets. Need to look at the spec. */
472  else if (s->is_vcd)
473  /* the standard mandates that there are only two system headers
474  in the whole file: one in the first packet of each stream.
475  (see standard p. IV-7 and IV-8) */
476  s->system_header_freq = 0x7fffffff;
477  else
479 
480  for(i=0;i<ctx->nb_streams;i++) {
481  stream = ctx->streams[i]->priv_data;
482  stream->packet_number = 0;
483  }
486  return 0;
487  fail:
488  for(i=0;i<ctx->nb_streams;i++) {
489  av_free(ctx->streams[i]->priv_data);
490  }
491  return AVERROR(ENOMEM);
492 }
493 
494 static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
495 {
496  avio_w8(pb,
497  (id << 4) |
498  (((timestamp >> 30) & 0x07) << 1) |
499  1);
500  avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
501  avio_wb16(pb, (uint16_t)((((timestamp ) & 0x7fff) << 1) | 1));
502 }
503 
504 
505 /* return the number of padding bytes that should be inserted into
506  the multiplexed stream.*/
507 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
508 {
509  MpegMuxContext *s = ctx->priv_data;
510  int pad_bytes = 0;
511 
512  if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
513  {
514  int64_t full_pad_bytes;
515 
516  full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0); //FIXME this is wrong
517  pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
518 
519  if (pad_bytes<0)
520  /* might happen if we have already padded to a later timestamp. This
521  can occur if another stream has already advanced further.*/
522  pad_bytes=0;
523  }
524 
525  return pad_bytes;
526 }
527 
528 
529 /* Write an MPEG padding packet header. */
530 static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,int packet_bytes)
531 {
532  MpegMuxContext *s = ctx->priv_data;
533  int i;
534 
536  avio_wb16(pb, packet_bytes - 6);
537  if (!s->is_mpeg2) {
538  avio_w8(pb, 0x0f);
539  packet_bytes -= 7;
540  } else
541  packet_bytes -= 6;
542 
543  for(i=0;i<packet_bytes;i++)
544  avio_w8(pb, 0xff);
545 }
546 
547 static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len){
548  int nb_frames=0;
549  PacketDesc *pkt_desc= stream->premux_packet;
550 
551  while(len>0){
552  if(pkt_desc->size == pkt_desc->unwritten_size)
553  nb_frames++;
554  len -= pkt_desc->unwritten_size;
555  pkt_desc= pkt_desc->next;
556  }
557 
558  return nb_frames;
559 }
560 
561 /* flush the packet on stream stream_index */
562 static int flush_packet(AVFormatContext *ctx, int stream_index,
563  int64_t pts, int64_t dts, int64_t scr, int trailer_size)
564 {
565  MpegMuxContext *s = ctx->priv_data;
566  StreamInfo *stream = ctx->streams[stream_index]->priv_data;
567  uint8_t *buf_ptr;
568  int size, payload_size, startcode, id, stuffing_size, i, header_len;
569  int packet_size;
570  uint8_t buffer[128];
571  int zero_trail_bytes = 0;
572  int pad_packet_bytes = 0;
573  int pes_flags;
574  int general_pack = 0; /*"general" pack without data specific to one stream?*/
575  int nb_frames;
576 
577  id = stream->id;
578 
579  av_dlog(ctx, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
580 
581  buf_ptr = buffer;
582 
583  if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
584  /* output pack and systems header if needed */
585  size = put_pack_header(ctx, buf_ptr, scr);
586  buf_ptr += size;
587  s->last_scr= scr;
588 
589  if (s->is_vcd) {
590  /* there is exactly one system header for each stream in a VCD MPEG,
591  One in the very first video packet and one in the very first
592  audio packet (see VCD standard p. IV-7 and IV-8).*/
593 
594  if (stream->packet_number==0) {
595  size = put_system_header(ctx, buf_ptr, id);
596  buf_ptr += size;
597  }
598  } else if (s->is_dvd) {
599  if (stream->align_iframe || s->packet_number == 0){
600  int PES_bytes_to_fill = s->packet_size - size - 10;
601 
602  if (pts != AV_NOPTS_VALUE) {
603  if (dts != pts)
604  PES_bytes_to_fill -= 5 + 5;
605  else
606  PES_bytes_to_fill -= 5;
607  }
608 
609  if (stream->bytes_to_iframe == 0 || s->packet_number == 0) {
610  size = put_system_header(ctx, buf_ptr, 0);
611  buf_ptr += size;
612  size = buf_ptr - buffer;
613  avio_write(ctx->pb, buffer, size);
614 
616  avio_wb16(ctx->pb, 0x03d4); // length
617  avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
618  for (i = 0; i < 979; i++)
619  avio_w8(ctx->pb, 0x00);
620 
622  avio_wb16(ctx->pb, 0x03fa); // length
623  avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
624  for (i = 0; i < 1017; i++)
625  avio_w8(ctx->pb, 0x00);
626 
627  memset(buffer, 0, 128);
628  buf_ptr = buffer;
629  s->packet_number++;
630  stream->align_iframe = 0;
631  scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
632  size = put_pack_header(ctx, buf_ptr, scr);
633  s->last_scr= scr;
634  buf_ptr += size;
635  /* GOP Start */
636  } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
637  pad_packet_bytes = PES_bytes_to_fill - stream->bytes_to_iframe;
638  }
639  }
640  } else {
641  if ((s->packet_number % s->system_header_freq) == 0) {
642  size = put_system_header(ctx, buf_ptr, 0);
643  buf_ptr += size;
644  }
645  }
646  }
647  size = buf_ptr - buffer;
648  avio_write(ctx->pb, buffer, size);
649 
650  packet_size = s->packet_size - size;
651 
652  if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
653  /* The VCD standard demands that 20 zero bytes follow
654  each audio pack (see standard p. IV-8).*/
655  zero_trail_bytes += 20;
656 
657  if ((s->is_vcd && stream->packet_number==0)
658  || (s->is_svcd && s->packet_number==0)) {
659  /* for VCD the first pack of each stream contains only the pack header,
660  the system header and lots of padding (see VCD standard p. IV-6).
661  In the case of an audio pack, 20 zero bytes are also added at
662  the end.*/
663  /* For SVCD we fill the very first pack to increase compatibility with
664  some DVD players. Not mandated by the standard.*/
665  if (s->is_svcd)
666  general_pack = 1; /* the system header refers to both streams and no stream data*/
667  pad_packet_bytes = packet_size - zero_trail_bytes;
668  }
669 
670  packet_size -= pad_packet_bytes + zero_trail_bytes;
671 
672  if (packet_size > 0) {
673 
674  /* packet header size */
675  packet_size -= 6;
676 
677  /* packet header */
678  if (s->is_mpeg2) {
679  header_len = 3;
680  if (stream->packet_number==0)
681  header_len += 3; /* PES extension */
682  header_len += 1; /* obligatory stuffing byte */
683  } else {
684  header_len = 0;
685  }
686  if (pts != AV_NOPTS_VALUE) {
687  if (dts != pts)
688  header_len += 5 + 5;
689  else
690  header_len += 5;
691  } else {
692  if (!s->is_mpeg2)
693  header_len++;
694  }
695 
696  payload_size = packet_size - header_len;
697  if (id < 0xc0) {
698  startcode = PRIVATE_STREAM_1;
699  payload_size -= 1;
700  if (id >= 0x40) {
701  payload_size -= 3;
702  if (id >= 0xa0)
703  payload_size -= 3;
704  }
705  } else {
706  startcode = 0x100 + id;
707  }
708 
709  stuffing_size = payload_size - av_fifo_size(stream->fifo);
710 
711  // first byte does not fit -> reset pts/dts + stuffing
712  if(payload_size <= trailer_size && pts != AV_NOPTS_VALUE){
713  int timestamp_len=0;
714  if(dts != pts)
715  timestamp_len += 5;
716  if(pts != AV_NOPTS_VALUE)
717  timestamp_len += s->is_mpeg2 ? 5 : 4;
718  pts=dts= AV_NOPTS_VALUE;
719  header_len -= timestamp_len;
720  if (s->is_dvd && stream->align_iframe) {
721  pad_packet_bytes += timestamp_len;
722  packet_size -= timestamp_len;
723  } else {
724  payload_size += timestamp_len;
725  }
726  stuffing_size += timestamp_len;
727  if(payload_size > trailer_size)
728  stuffing_size += payload_size - trailer_size;
729  }
730 
731  if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) { // can't use padding, so use stuffing
732  packet_size += pad_packet_bytes;
733  payload_size += pad_packet_bytes; // undo the previous adjustment
734  if (stuffing_size < 0) {
735  stuffing_size = pad_packet_bytes;
736  } else {
737  stuffing_size += pad_packet_bytes;
738  }
739  pad_packet_bytes = 0;
740  }
741 
742  if (stuffing_size < 0)
743  stuffing_size = 0;
744 
745  if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
746  if (payload_size < av_fifo_size(stream->fifo))
747  stuffing_size += payload_size % stream->lpcm_align;
748  }
749 
750  if (stuffing_size > 16) { /*<=16 for MPEG-1, <=32 for MPEG-2*/
751  pad_packet_bytes += stuffing_size;
752  packet_size -= stuffing_size;
753  payload_size -= stuffing_size;
754  stuffing_size = 0;
755  }
756 
757  nb_frames= get_nb_frames(ctx, stream, payload_size - stuffing_size);
758 
759  avio_wb32(ctx->pb, startcode);
760 
761  avio_wb16(ctx->pb, packet_size);
762 
763  if (!s->is_mpeg2)
764  for(i=0;i<stuffing_size;i++)
765  avio_w8(ctx->pb, 0xff);
766 
767  if (s->is_mpeg2) {
768  avio_w8(ctx->pb, 0x80); /* mpeg2 id */
769 
770  pes_flags=0;
771 
772  if (pts != AV_NOPTS_VALUE) {
773  pes_flags |= 0x80;
774  if (dts != pts)
775  pes_flags |= 0x40;
776  }
777 
778  /* Both the MPEG-2 and the SVCD standards demand that the
779  P-STD_buffer_size field be included in the first packet of
780  every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
781  and MPEG-2 standard 2.7.7) */
782  if (stream->packet_number == 0)
783  pes_flags |= 0x01;
784 
785  avio_w8(ctx->pb, pes_flags); /* flags */
786  avio_w8(ctx->pb, header_len - 3 + stuffing_size);
787 
788  if (pes_flags & 0x80) /*write pts*/
789  put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
790  if (pes_flags & 0x40) /*write dts*/
791  put_timestamp(ctx->pb, 0x01, dts);
792 
793  if (pes_flags & 0x01) { /*write pes extension*/
794  avio_w8(ctx->pb, 0x10); /* flags */
795 
796  /* P-STD buffer info */
797  if ((id & 0xe0) == AUDIO_ID)
798  avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size/ 128);
799  else
800  avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size/1024);
801  }
802 
803  } else {
804  if (pts != AV_NOPTS_VALUE) {
805  if (dts != pts) {
806  put_timestamp(ctx->pb, 0x03, pts);
807  put_timestamp(ctx->pb, 0x01, dts);
808  } else {
809  put_timestamp(ctx->pb, 0x02, pts);
810  }
811  } else {
812  avio_w8(ctx->pb, 0x0f);
813  }
814  }
815 
816  if (s->is_mpeg2) {
817  /* special stuffing byte that is always written
818  to prevent accidental generation of start codes. */
819  avio_w8(ctx->pb, 0xff);
820 
821  for(i=0;i<stuffing_size;i++)
822  avio_w8(ctx->pb, 0xff);
823  }
824 
825  if (startcode == PRIVATE_STREAM_1) {
826  avio_w8(ctx->pb, id);
827  if (id >= 0xa0) {
828  /* LPCM (XXX: check nb_frames) */
829  avio_w8(ctx->pb, 7);
830  avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
831  avio_w8(ctx->pb, stream->lpcm_header[0]);
832  avio_w8(ctx->pb, stream->lpcm_header[1]);
833  avio_w8(ctx->pb, stream->lpcm_header[2]);
834  } else if (id >= 0x40) {
835  /* AC-3 */
836  avio_w8(ctx->pb, nb_frames);
837  avio_wb16(ctx->pb, trailer_size+1);
838  }
839  }
840 
841  /* output data */
842  assert(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
843  av_fifo_generic_read(stream->fifo, ctx->pb, payload_size - stuffing_size, (void*)avio_write);
844  stream->bytes_to_iframe -= payload_size - stuffing_size;
845  }else{
846  payload_size=
847  stuffing_size= 0;
848  }
849 
850  if (pad_packet_bytes > 0)
851  put_padding_packet(ctx,ctx->pb, pad_packet_bytes);
852 
853  for(i=0;i<zero_trail_bytes;i++)
854  avio_w8(ctx->pb, 0x00);
855 
856  avio_flush(ctx->pb);
857 
858  s->packet_number++;
859 
860  /* only increase the stream packet number if this pack actually contains
861  something that is specific to this stream! I.e. a dedicated header
862  or some data.*/
863  if (!general_pack)
864  stream->packet_number++;
865 
866  return payload_size - stuffing_size;
867 }
868 
870 {
871  /* There are two ways to do this padding: writing a sector/pack
872  of 0 values, or writing an MPEG padding pack. Both seem to
873  work with most decoders, BUT the VCD standard only allows a 0-sector
874  (see standard p. IV-4, IV-5).
875  So a 0-sector it is...*/
876 
877  MpegMuxContext *s = ctx->priv_data;
878  int i;
879 
880  for(i=0;i<s->packet_size;i++)
881  avio_w8(ctx->pb, 0);
882 
884 
885  avio_flush(ctx->pb);
886 
887  /* increasing the packet number is correct. The SCR of the following packs
888  is calculated from the packet_number and it has to include the padding
889  sector (it represents the sector index, not the MPEG pack index)
890  (see VCD standard p. IV-6)*/
891  s->packet_number++;
892 }
893 
894 static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr){
895 // MpegMuxContext *s = ctx->priv_data;
896  int i;
897 
898  for(i=0; i<ctx->nb_streams; i++){
899  AVStream *st = ctx->streams[i];
900  StreamInfo *stream = st->priv_data;
901  PacketDesc *pkt_desc;
902 
903  while((pkt_desc= stream->predecode_packet)
904  && scr > pkt_desc->dts){ //FIXME > vs >=
905  if(stream->buffer_index < pkt_desc->size ||
906  stream->predecode_packet == stream->premux_packet){
907  av_log(ctx, AV_LOG_ERROR,
908  "buffer underflow i=%d bufi=%d size=%d\n",
909  i, stream->buffer_index, pkt_desc->size);
910  break;
911  }
912  stream->buffer_index -= pkt_desc->size;
913 
914  stream->predecode_packet= pkt_desc->next;
915  av_freep(&pkt_desc);
916  }
917  }
918 
919  return 0;
920 }
921 
922 static int output_packet(AVFormatContext *ctx, int flush){
923  MpegMuxContext *s = ctx->priv_data;
924  AVStream *st;
925  StreamInfo *stream;
926  int i, avail_space=0, es_size, trailer_size;
927  int best_i= -1;
928  int best_score= INT_MIN;
929  int ignore_constraints=0;
930  int64_t scr= s->last_scr;
931  PacketDesc *timestamp_packet;
932  const int64_t max_delay= av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
933 
934 retry:
935  for(i=0; i<ctx->nb_streams; i++){
936  AVStream *st = ctx->streams[i];
937  StreamInfo *stream = st->priv_data;
938  const int avail_data= av_fifo_size(stream->fifo);
939  const int space= stream->max_buffer_size - stream->buffer_index;
940  int rel_space= 1024LL*space / stream->max_buffer_size;
941  PacketDesc *next_pkt= stream->premux_packet;
942 
943  /* for subtitle, a single PES packet must be generated,
944  so we flush after every single subtitle packet */
945  if(s->packet_size > avail_data && !flush
947  return 0;
948  if(avail_data==0)
949  continue;
950  assert(avail_data>0);
951 
952  if(space < s->packet_size && !ignore_constraints)
953  continue;
954 
955  if(next_pkt && next_pkt->dts - scr > max_delay)
956  continue;
957 
958  if(rel_space > best_score){
959  best_score= rel_space;
960  best_i = i;
961  avail_space= space;
962  }
963  }
964 
965  if(best_i < 0){
966  int64_t best_dts= INT64_MAX;
967 
968  for(i=0; i<ctx->nb_streams; i++){
969  AVStream *st = ctx->streams[i];
970  StreamInfo *stream = st->priv_data;
971  PacketDesc *pkt_desc= stream->predecode_packet;
972  if(pkt_desc && pkt_desc->dts < best_dts)
973  best_dts= pkt_desc->dts;
974  }
975 
976  av_dlog(ctx, "bumping scr, scr:%f, dts:%f\n",
977  scr / 90000.0, best_dts / 90000.0);
978  if(best_dts == INT64_MAX)
979  return 0;
980 
981  if(scr >= best_dts+1 && !ignore_constraints){
982  av_log(ctx, AV_LOG_ERROR, "packet too large, ignoring buffer limits to mux it\n");
983  ignore_constraints= 1;
984  }
985  scr= FFMAX(best_dts+1, scr);
986  if(remove_decoded_packets(ctx, scr) < 0)
987  return -1;
988  goto retry;
989  }
990 
991  assert(best_i >= 0);
992 
993  st = ctx->streams[best_i];
994  stream = st->priv_data;
995 
996  assert(av_fifo_size(stream->fifo) > 0);
997 
998  assert(avail_space >= s->packet_size || ignore_constraints);
999 
1000  timestamp_packet= stream->premux_packet;
1001  if(timestamp_packet->unwritten_size == timestamp_packet->size){
1002  trailer_size= 0;
1003  }else{
1004  trailer_size= timestamp_packet->unwritten_size;
1005  timestamp_packet= timestamp_packet->next;
1006  }
1007 
1008  if(timestamp_packet){
1009  av_dlog(ctx, "dts:%f pts:%f scr:%f stream:%d\n",
1010  timestamp_packet->dts / 90000.0,
1011  timestamp_packet->pts / 90000.0,
1012  scr / 90000.0, best_i);
1013  es_size= flush_packet(ctx, best_i, timestamp_packet->pts, timestamp_packet->dts, scr, trailer_size);
1014  }else{
1015  assert(av_fifo_size(stream->fifo) == trailer_size);
1016  es_size= flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr, trailer_size);
1017  }
1018 
1019  if (s->is_vcd) {
1020  /* Write one or more padding sectors, if necessary, to reach
1021  the constant overall bitrate.*/
1022  int vcd_pad_bytes;
1023 
1024  while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->premux_packet->pts) ) >= s->packet_size){ //FIXME pts cannot be correct here
1026  s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1027  }
1028  }
1029 
1030  stream->buffer_index += es_size;
1031  s->last_scr += s->packet_size*90000LL / (s->mux_rate*50LL); //FIXME rounding and first few bytes of each packet
1032 
1033  while(stream->premux_packet && stream->premux_packet->unwritten_size <= es_size){
1034  es_size -= stream->premux_packet->unwritten_size;
1035  stream->premux_packet= stream->premux_packet->next;
1036  }
1037  if(es_size)
1038  stream->premux_packet->unwritten_size -= es_size;
1039 
1040  if(remove_decoded_packets(ctx, s->last_scr) < 0)
1041  return -1;
1042 
1043  return 1;
1044 }
1045 
1047 {
1048  MpegMuxContext *s = ctx->priv_data;
1049  int stream_index= pkt->stream_index;
1050  int size= pkt->size;
1051  uint8_t *buf= pkt->data;
1052  AVStream *st = ctx->streams[stream_index];
1053  StreamInfo *stream = st->priv_data;
1054  int64_t pts, dts;
1055  PacketDesc *pkt_desc;
1056  int preload;
1057  const int is_iframe = st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (pkt->flags & AV_PKT_FLAG_KEY);
1058 
1059  preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1060 
1061  pts= pkt->pts;
1062  dts= pkt->dts;
1063 
1064  if (s->last_scr == AV_NOPTS_VALUE) {
1065  if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
1066  if (dts != AV_NOPTS_VALUE)
1067  s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1068  s->last_scr = 0;
1069  } else {
1070  s->last_scr = dts - preload;
1071  s->preload = 0;
1072  }
1073  preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
1074  av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
1075  }
1076 
1077  if (dts != AV_NOPTS_VALUE) dts += preload;
1078  if (pts != AV_NOPTS_VALUE) pts += preload;
1079 
1080  av_dlog(ctx, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
1081  dts / 90000.0, pts / 90000.0, pkt->flags,
1082  pkt->stream_index, pts != AV_NOPTS_VALUE);
1083  if (!stream->premux_packet)
1084  stream->next_packet = &stream->premux_packet;
1085  *stream->next_packet=
1086  pkt_desc= av_mallocz(sizeof(PacketDesc));
1087  pkt_desc->pts= pts;
1088  pkt_desc->dts= dts;
1089  pkt_desc->unwritten_size=
1090  pkt_desc->size= size;
1091  if(!stream->predecode_packet)
1092  stream->predecode_packet= pkt_desc;
1093  stream->next_packet= &pkt_desc->next;
1094 
1095  if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1096  return -1;
1097 
1098  if (s->is_dvd){
1099  if (is_iframe && (s->packet_number == 0 || (pts - stream->vobu_start_pts >= 36000))) { // min VOBU length 0.4 seconds (mpucoder)
1100  stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1101  stream->align_iframe = 1;
1102  stream->vobu_start_pts = pts;
1103  }
1104  }
1105 
1106  av_fifo_generic_write(stream->fifo, buf, size, NULL);
1107 
1108  for(;;){
1109  int ret= output_packet(ctx, 0);
1110  if(ret<=0)
1111  return ret;
1112  }
1113 }
1114 
1116 {
1117 // MpegMuxContext *s = ctx->priv_data;
1118  StreamInfo *stream;
1119  int i;
1120 
1121  for(;;){
1122  int ret= output_packet(ctx, 1);
1123  if(ret<0)
1124  return ret;
1125  else if(ret==0)
1126  break;
1127  }
1128 
1129  /* End header according to MPEG1 systems standard. We do not write
1130  it as it is usually not needed by decoders and because it
1131  complicates MPEG stream concatenation. */
1132  //avio_wb32(ctx->pb, ISO_11172_END_CODE);
1133  //avio_flush(ctx->pb);
1134 
1135  for(i=0;i<ctx->nb_streams;i++) {
1136  stream = ctx->streams[i]->priv_data;
1137 
1138  assert(av_fifo_size(stream->fifo) == 0);
1139  av_fifo_free(stream->fifo);
1140  }
1141  return 0;
1142 }
1143 
1144 #define OFFSET(x) offsetof(MpegMuxContext, x)
1145 #define E AV_OPT_FLAG_ENCODING_PARAM
1146 static const AVOption options[] = {
1147  { "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },
1148  { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, {.i64 = 500000}, 0, INT_MAX, E},
1149  { NULL },
1150 };
1151 
1152 #define MPEGENC_CLASS(flavor)\
1153 static const AVClass flavor ## _class = {\
1154  .class_name = #flavor " muxer",\
1155  .item_name = av_default_item_name,\
1156  .version = LIBAVUTIL_VERSION_INT,\
1157  .option = options,\
1158 };
1159 
1160 #if CONFIG_MPEG1SYSTEM_MUXER
1161 MPEGENC_CLASS(mpeg)
1162 AVOutputFormat ff_mpeg1system_muxer = {
1163  .name = "mpeg",
1164  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1165  .mime_type = "video/mpeg",
1166  .extensions = "mpg,mpeg",
1167  .priv_data_size = sizeof(MpegMuxContext),
1168  .audio_codec = AV_CODEC_ID_MP2,
1169  .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1173  .priv_class = &mpeg_class,
1174 };
1175 #endif
1176 #if CONFIG_MPEG1VCD_MUXER
1177 MPEGENC_CLASS(vcd)
1178 AVOutputFormat ff_mpeg1vcd_muxer = {
1179  .name = "vcd",
1180  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1181  .mime_type = "video/mpeg",
1182  .priv_data_size = sizeof(MpegMuxContext),
1183  .audio_codec = AV_CODEC_ID_MP2,
1184  .video_codec = AV_CODEC_ID_MPEG1VIDEO,
1188  .priv_class = &vcd_class,
1189 };
1190 #endif
1191 #if CONFIG_MPEG2VOB_MUXER
1192 MPEGENC_CLASS(vob)
1193 AVOutputFormat ff_mpeg2vob_muxer = {
1194  .name = "vob",
1195  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1196  .mime_type = "video/mpeg",
1197  .extensions = "vob",
1198  .priv_data_size = sizeof(MpegMuxContext),
1199  .audio_codec = AV_CODEC_ID_MP2,
1200  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1204  .priv_class = &vob_class,
1205 };
1206 #endif
1207 
1208 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1209 #if CONFIG_MPEG2SVCD_MUXER
1210 MPEGENC_CLASS(svcd)
1211 AVOutputFormat ff_mpeg2svcd_muxer = {
1212  .name = "svcd",
1213  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1214  .mime_type = "video/mpeg",
1215  .extensions = "vob",
1216  .priv_data_size = sizeof(MpegMuxContext),
1217  .audio_codec = AV_CODEC_ID_MP2,
1218  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1222  .priv_class = &svcd_class,
1223 };
1224 #endif
1225 
1226 /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1227 #if CONFIG_MPEG2DVD_MUXER
1228 MPEGENC_CLASS(dvd)
1229 AVOutputFormat ff_mpeg2dvd_muxer = {
1230  .name = "dvd",
1231  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1232  .mime_type = "video/mpeg",
1233  .extensions = "dvd",
1234  .priv_data_size = sizeof(MpegMuxContext),
1235  .audio_codec = AV_CODEC_ID_MP2,
1236  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1240  .priv_class = &dvd_class,
1241 };
1242 #endif