libavformat/mpegenc.c

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