mpegenc.c 44.6 KB
Newer Older
1
/*
2
 * MPEG-1/2 muxer
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

22 23
#include <stdint.h>

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 35 36 37 38 39 40 41 42 43 44 45
#include "mpeg.h"

#define MAX_PAYLOAD_SIZE 4096

typedef struct PacketDesc {
    int64_t pts;
    int64_t dts;
    int size;
    int unwritten_size;
    struct PacketDesc *next;
} PacketDesc;

46
typedef struct StreamInfo {
47
    AVFifoBuffer *fifo;
48 49 50 51 52 53 54 55 56 57 58 59 60 61
    uint8_t id;
    int max_buffer_size; /* in bytes */
    int buffer_index;
    PacketDesc *predecode_packet;
    PacketDesc *premux_packet;
    PacketDesc **next_packet;
    int packet_number;
    uint8_t lpcm_header[3];
    int lpcm_align;
    int bytes_to_iframe;
    int align_iframe;
    int64_t vobu_start_pts;
} StreamInfo;

62
typedef struct MpegMuxContext {
63
    const AVClass *class;
64 65 66 67 68
    int packet_size; /* required packet size */
    int packet_number;
    int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
    int system_header_freq;
    int system_header_size;
69
    int user_mux_rate; /* bitrate in units of bits/s */
70 71 72 73 74 75 76 77 78 79
    int mux_rate; /* bitrate in units of 50 bytes/s */
    /* stream info */
    int audio_bound;
    int video_bound;
    int is_mpeg2;
    int is_vcd;
    int is_svcd;
    int is_dvd;
    int64_t last_scr; /* current system clock */

80
    int64_t vcd_padding_bitrate_num;
81 82
    int64_t vcd_padding_bytes_written;

83
    int preload;
84 85
} MpegMuxContext;

86 87 88 89
extern AVOutputFormat ff_mpeg1vcd_muxer;
extern AVOutputFormat ff_mpeg2dvd_muxer;
extern AVOutputFormat ff_mpeg2svcd_muxer;
extern AVOutputFormat ff_mpeg2vob_muxer;
90

91 92
static int put_pack_header(AVFormatContext *ctx, uint8_t *buf,
                           int64_t timestamp)
93 94 95 96 97 98
{
    MpegMuxContext *s = ctx->priv_data;
    PutBitContext pb;

    init_put_bits(&pb, buf, 128);

99
    put_bits32(&pb, PACK_START_CODE);
100
    if (s->is_mpeg2)
101
        put_bits(&pb, 2, 0x1);
102
    else
103
        put_bits(&pb, 4, 0x2);
104 105
    put_bits(&pb,  3, (uint32_t)((timestamp >> 30) & 0x07));
    put_bits(&pb,  1, 1);
106
    put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
107 108 109 110
    put_bits(&pb,  1, 1);
    put_bits(&pb, 15, (uint32_t)((timestamp)       & 0x7fff));
    put_bits(&pb,  1, 1);
    if (s->is_mpeg2)
111 112 113 114 115 116 117 118 119 120 121
        /* clock extension */
        put_bits(&pb, 9, 0);
    put_bits(&pb, 1, 1);
    put_bits(&pb, 22, s->mux_rate);
    put_bits(&pb, 1, 1);
    if (s->is_mpeg2) {
        put_bits(&pb, 1, 1);
        put_bits(&pb, 5, 0x1f); /* reserved */
        put_bits(&pb, 3, 0); /* stuffing length */
    }
    flush_put_bits(&pb);
122
    return put_bits_ptr(&pb) - pb.buf;
123 124
}

125 126
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,
                             int only_for_stream_id)
127 128 129 130 131 132 133
{
    MpegMuxContext *s = ctx->priv_data;
    int size, i, private_stream_coded, id;
    PutBitContext pb;

    init_put_bits(&pb, buf, 128);

134
    put_bits32(&pb, SYSTEM_HEADER_START_CODE);
135 136 137
    put_bits(&pb, 16, 0);
    put_bits(&pb, 1, 1);

138 139
    /* maximum bit rate of the multiplexed stream */
    put_bits(&pb, 22, s->mux_rate);
140
    put_bits(&pb, 1, 1); /* marker */
141 142 143
    if (s->is_vcd && only_for_stream_id == VIDEO_ID) {
        /* This header applies only to the video stream
         * (see VCD standard p. IV-7) */
144 145 146 147 148
        put_bits(&pb, 6, 0);
    } else
        put_bits(&pb, 6, s->audio_bound);

    if (s->is_vcd) {
149
        /* see VCD standard, p. IV-7 */
150 151 152
        put_bits(&pb, 1, 0);
        put_bits(&pb, 1, 1);
    } else {
153
        put_bits(&pb, 1, 0); /* variable bitrate */
154
        put_bits(&pb, 1, 0); /* nonconstrained bitstream */
155 156 157 158 159 160 161 162 163 164 165 166 167
    }

    if (s->is_vcd || s->is_dvd) {
        /* see VCD standard p IV-7 */
        put_bits(&pb, 1, 1); /* audio locked */
        put_bits(&pb, 1, 1); /* video locked */
    } else {
        put_bits(&pb, 1, 0); /* audio locked */
        put_bits(&pb, 1, 0); /* video locked */
    }

    put_bits(&pb, 1, 1); /* marker */

168
    if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
169 170
        /* This header applies only to the audio stream
         * (see VCD standard p. IV-7) */
171 172 173 174 175 176 177 178 179 180 181
        put_bits(&pb, 5, 0);
    } else
        put_bits(&pb, 5, s->video_bound);

    if (s->is_dvd) {
        put_bits(&pb, 1, 0);    /* packet_rate_restriction_flag */
        put_bits(&pb, 7, 0x7f); /* reserved byte */
    } else
        put_bits(&pb, 8, 0xff); /* reserved byte */

    /* DVD-Video Stream_bound entries
182 183 184 185
     * id (0xB9) video, maximum P-STD for stream 0xE0. (P-STD_buffer_bound_scale = 1)
     * 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)
     * id (0xBD) private stream 1 (audio other than MPEG and subpictures). (P-STD_buffer_bound_scale = 1)
     * id (0xBF) private stream 2, NAV packs, set to 2x1024. */
186 187 188 189 190 191
    if (s->is_dvd) {

        int P_STD_max_video = 0;
        int P_STD_max_mpeg_audio = 0;
        int P_STD_max_mpeg_PS1 = 0;

192
        for (i = 0; i < ctx->nb_streams; i++) {
193 194 195 196 197
            StreamInfo *stream = ctx->streams[i]->priv_data;

            id = stream->id;
            if (id == 0xbd && stream->max_buffer_size > P_STD_max_mpeg_PS1) {
                P_STD_max_mpeg_PS1 = stream->max_buffer_size;
198 199
            } else if (id >= 0xc0 && id <= 0xc7 &&
                       stream->max_buffer_size > P_STD_max_mpeg_audio) {
200
                P_STD_max_mpeg_audio = stream->max_buffer_size;
201 202
            } else if (id == 0xe0 &&
                       stream->max_buffer_size > P_STD_max_video) {
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
                P_STD_max_video = stream->max_buffer_size;
            }
        }

        /* video */
        put_bits(&pb, 8, 0xb9); /* stream ID */
        put_bits(&pb, 2, 3);
        put_bits(&pb, 1, 1);
        put_bits(&pb, 13, P_STD_max_video / 1024);

        /* audio */
        if (P_STD_max_mpeg_audio == 0)
            P_STD_max_mpeg_audio = 4096;
        put_bits(&pb, 8, 0xb8); /* stream ID */
        put_bits(&pb, 2, 3);
        put_bits(&pb, 1, 0);
        put_bits(&pb, 13, P_STD_max_mpeg_audio / 128);

        /* private stream 1 */
        put_bits(&pb, 8, 0xbd); /* stream ID */
        put_bits(&pb, 2, 3);
        put_bits(&pb, 1, 0);
        put_bits(&pb, 13, P_STD_max_mpeg_PS1 / 128);

        /* private stream 2 */
        put_bits(&pb, 8, 0xbf); /* stream ID */
        put_bits(&pb, 2, 3);
        put_bits(&pb, 1, 1);
        put_bits(&pb, 13, 2);
232
    } else {
233 234
        /* audio stream info */
        private_stream_coded = 0;
235
        for (i = 0; i < ctx->nb_streams; i++) {
236 237 238
            StreamInfo *stream = ctx->streams[i]->priv_data;

            /* For VCDs, only include the stream info for the stream
239 240 241 242
             * that the pack which contains this system belongs to.
             * (see VCD standard p. IV-7) */
            if (!s->is_vcd || stream->id == only_for_stream_id ||
                only_for_stream_id == 0) {
243 244
                id = stream->id;
                if (id < 0xc0) {
245
                    /* special case for private streams (AC-3 uses that) */
246 247 248 249 250
                    if (private_stream_coded)
                        continue;
                    private_stream_coded = 1;
                    id = 0xbd;
                }
251
                put_bits(&pb, 8, id);         /* stream ID */
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
                put_bits(&pb, 2, 3);
                if (id < 0xe0) {
                    /* audio */
                    put_bits(&pb, 1, 0);
                    put_bits(&pb, 13, stream->max_buffer_size / 128);
                } else {
                    /* video */
                    put_bits(&pb, 1, 1);
                    put_bits(&pb, 13, stream->max_buffer_size / 1024);
                }
            }
        }
    }

    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 272 273 274 275 276 277 278 279 280

    return size;
}

static int get_system_header_size(AVFormatContext *ctx)
{
    int buf_index, i, private_stream_coded;
    StreamInfo *stream;
    MpegMuxContext *s = ctx->priv_data;

    if (s->is_dvd)
281
        return 18; // DVD-Video system headers are 18 bytes fixed length.
282 283 284

    buf_index = 12;
    private_stream_coded = 0;
285
    for (i = 0; i < ctx->nb_streams; i++) {
286 287 288 289 290 291 292 293 294 295 296
        stream = ctx->streams[i]->priv_data;
        if (stream->id < 0xc0) {
            if (private_stream_coded)
                continue;
            private_stream_coded = 1;
        }
        buf_index += 3;
    }
    return buf_index;
}

297
static av_cold int mpeg_mux_init(AVFormatContext *ctx)
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 302 303 304 305 306
    AVStream *st;
    StreamInfo *stream;
    int audio_bitrate;
    int video_bitrate;

    s->packet_number = 0;
307 308
    s->is_vcd   =  (CONFIG_MPEG1VCD_MUXER  && ctx->oformat == &ff_mpeg1vcd_muxer);
    s->is_svcd  =  (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
309 310 311
    s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER  && ctx->oformat == &ff_mpeg2vob_muxer) ||
                   (CONFIG_MPEG2DVD_MUXER  && ctx->oformat == &ff_mpeg2dvd_muxer) ||
                   (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 316 317 318 319
        if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
            av_log(ctx, AV_LOG_ERROR, "Invalid packet size %d\n",
                   ctx->packet_size);
            goto fail;
        }
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 326

    s->vcd_padding_bytes_written = 0;
327
    s->vcd_padding_bitrate_num   = 0;
328 329 330

    s->audio_bound = 0;
    s->video_bound = 0;
331 332 333 334 335

    mpa_id  = AUDIO_ID;
    ac3_id  = AC3_ID;
    dts_id  = DTS_ID;
    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 342
        AVCPBProperties *props;

343
        st     = ctx->streams[i];
344 345 346 347 348
        stream = av_mallocz(sizeof(StreamInfo));
        if (!stream)
            goto fail;
        st->priv_data = stream;

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 355 356
                (st->codecpar->codec_id == AV_CODEC_ID_AC3 ||
                 st->codecpar->codec_id == AV_CODEC_ID_DTS ||
                 st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE))
357 358 359 360
                 av_log(ctx, AV_LOG_WARNING,
                        "%s in MPEG-1 system streams is not widely supported, "
                        "consider using the vob or the dvd muxer "
                        "to force a MPEG-2 program stream.\n",
361
                        avcodec_get_name(st->codecpar->codec_id));
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 371 372 373
                        break;
                }
                if (j == 4)
                    goto fail;
374
                if (st->codecpar->channels > 8)
375 376
                    return -1;
                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 381 382 383 384
            } else {
                stream->id = mpa_id++;
            }

            /* 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 387 388
            stream->max_buffer_size = 4 * 1024;
            s->audio_bound++;
            break;
389
        case AVMEDIA_TYPE_VIDEO:
390
            if (st->codecpar->codec_id == AV_CODEC_ID_H264)
391 392 393
                stream->id = h264_id++;
            else
                stream->id = mpv_id++;
394 395 396 397

            props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
            if (props && props->buffer_size)
                stream->max_buffer_size = 6 * 1024 + props->buffer_size / 8;
398
            else {
399
                av_log(ctx, AV_LOG_WARNING,
400 401 402
                       "VBV buffer size not set, using default size of 130KB\n"
                       "If you want the mpeg file to be compliant to some specification\n"
                       "Like DVD, VCD or others, make sure you set the correct buffer size\n");
403 404
                // FIXME: this is probably too small as default
                stream->max_buffer_size = 230 * 1024;
405
            }
406 407 408 409
            if (stream->max_buffer_size > 1024 * 8191) {
                av_log(ctx, AV_LOG_WARNING, "buffer size %d, too large\n", stream->max_buffer_size);
                stream->max_buffer_size = 1024 * 8191;
            }
410 411
            s->video_bound++;
            break;
412
        case AVMEDIA_TYPE_SUBTITLE:
413
            stream->id              = mps_id++;
414 415 416
            stream->max_buffer_size = 16 * 1024;
            break;
        default:
417
            av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
418
                   av_get_media_type_string(st->codecpar->codec_type), i);
419
            return AVERROR(EINVAL);
420
        }
421
        stream->fifo = av_fifo_alloc(16);
422 423
        if (!stream->fifo)
            goto fail;
424
    }
425
    bitrate       = 0;
426 427
    audio_bitrate = 0;
    video_bitrate = 0;
428
    for (i = 0; i < ctx->nb_streams; i++) {
429
        AVCPBProperties *props;
430
        int codec_rate;
431 432
        st     = ctx->streams[i];
        stream = (StreamInfo *)st->priv_data;
433

434 435 436
        props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
        if (props)
            codec_rate = props->max_bitrate;
437
        else
438
            codec_rate = st->codecpar->bit_rate;
439

440 441
        if (!codec_rate)
            codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
442 443 444

        bitrate += codec_rate;

445
        if ((stream->id & 0xe0) == AUDIO_ID)
446
            audio_bitrate += codec_rate;
447
        else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
448 449 450
            video_bitrate += codec_rate;
    }

451 452 453
    if (s->user_mux_rate) {
        s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
    } else {
454
        /* we increase slightly the bitrate to take into account the
455 456 457
         * headers. XXX: compute it exactly */
        bitrate    += bitrate / 20;
        bitrate    += 10000;
458
        s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
459 460 461 462
        if (s->mux_rate >= (1<<22)) {
            av_log(ctx, AV_LOG_WARNING, "mux rate %d is too large\n", s->mux_rate);
            s->mux_rate = (1<<22) - 1;
        }
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 470 471 472 473 474 475
         * (see standard p. IV-6).
         * The value is actually "wrong", i.e. if you calculate
         * it using the normal formula and the 75 sectors per second transfer
         * rate you get a different value because the real pack size is 2324,
         * not 2352. But the standard explicitly specifies that the mux_rate
         * field in the header must have this value. */
        // s->mux_rate = 2352 * 75 / 50;    /* = 3528 */
476 477

        /* The VCD standard states that the muxed stream must be
478 479 480 481 482
         * exactly 75 packs / second (the data rate of a single speed cdrom).
         * Since the video bitrate (probably 1150000 bits/sec) will be below
         * the theoretical maximum we have to add some padding packets
         * to make up for the lower data rate.
         * (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 487
        overhead_rate  = audio_bitrate * 2294LL * (2324 - 2279);
        overhead_rate += video_bitrate * 2279LL * (2324 - 2294);
488 489

        /* Add padding so that the full bitrate is 2324*75 bytes/sec */
490 491
        s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;
#define VCD_PADDING_BITRATE_DEN (2279 * 2294)
492 493 494 495 496 497 498 499 500 501 502
    }

    if (s->is_vcd || s->is_mpeg2)
        /* every packet */
        s->pack_header_freq = 1;
    else
        /* every 2 seconds */
        s->pack_header_freq = 2 * bitrate / s->packet_size / 8;

    /* the above seems to make pack_header_freq zero sometimes */
    if (s->pack_header_freq == 0)
503
        s->pack_header_freq = 1;
504 505 506 507 508 509

    if (s->is_mpeg2)
        /* every 200 packets. Need to look at the spec.  */
        s->system_header_freq = s->pack_header_freq * 40;
    else if (s->is_vcd)
        /* the standard mandates that there are only two system headers
510 511
         * in the whole file: one in the first packet of each stream.
         * (see standard p. IV-7 and IV-8) */
512 513 514 515
        s->system_header_freq = 0x7fffffff;
    else
        s->system_header_freq = s->pack_header_freq * 5;

516 517
    for (i = 0; i < ctx->nb_streams; i++) {
        stream                = ctx->streams[i]->priv_data;
518 519 520
        stream->packet_number = 0;
    }
    s->system_header_size = get_system_header_size(ctx);
521
    s->last_scr           = AV_NOPTS_VALUE;
522
    return 0;
523 524 525

fail:
    for (i = 0; i < ctx->nb_streams; i++)
526
        av_freep(&ctx->streams[i]->priv_data);
527 528 529
    return AVERROR(ENOMEM);
}

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. */
539 540 541 542 543
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
{
    MpegMuxContext *s = ctx->priv_data;
    int pad_bytes = 0;

544
    if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
545 546
        int64_t full_pad_bytes;

547 548
        // FIXME: this is wrong
        full_pad_bytes =
549
            av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);
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 555
             * can occur if another stream has already advanced further. */
            pad_bytes = 0;
556 557 558 559 560 561
    }

    return pad_bytes;
}

/* Write an MPEG padding packet header. */
562 563
static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
                               int packet_bytes)
564 565 566 567
{
    MpegMuxContext *s = ctx->priv_data;
    int i;

568 569
    avio_wb32(pb, PADDING_STREAM);
    avio_wb16(pb, packet_bytes - 6);
570
    if (!s->is_mpeg2) {
571
        avio_w8(pb, 0x0f);
572 573 574 575
        packet_bytes -= 7;
    } else
        packet_bytes -= 6;

576
    for (i = 0; i < packet_bytes; i++)
577
        avio_w8(pb, 0xff);
578 579
}

580 581 582 583
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
{
    int nb_frames        = 0;
    PacketDesc *pkt_desc = stream->premux_packet;
584

585 586
    while (len > 0) {
        if (pkt_desc->size == pkt_desc->unwritten_size)
587
            nb_frames++;
588 589
        len     -= pkt_desc->unwritten_size;
        pkt_desc = pkt_desc->next;
590 591 592 593 594 595 596
    }

    return nb_frames;
}

/* flush the packet on stream stream_index */
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 601 602 603 604 605 606 607
    StreamInfo *stream = ctx->streams[stream_index]->priv_data;
    uint8_t *buf_ptr;
    int size, payload_size, startcode, id, stuffing_size, i, header_len;
    int packet_size;
    uint8_t buffer[128];
    int zero_trail_bytes = 0;
    int pad_packet_bytes = 0;
    int pes_flags;
608 609
    /* "general" pack without data specific to one stream? */
    int general_pack = 0;
610 611 612 613
    int nb_frames;

    id = stream->id;

614
    av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
615 616 617 618 619

    buf_ptr = buffer;

    if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
        /* output pack and systems header if needed */
620 621 622
        size        = put_pack_header(ctx, buf_ptr, scr);
        buf_ptr    += size;
        s->last_scr = scr;
623 624 625

        if (s->is_vcd) {
            /* there is exactly one system header for each stream in a VCD MPEG,
626 627
             * One in the very first video packet and one in the very first
             * audio packet (see VCD standard p. IV-7 and IV-8). */
628

629 630
            if (stream->packet_number == 0) {
                size     = put_system_header(ctx, buf_ptr, id);
631 632 633
                buf_ptr += size;
            }
        } else if (s->is_dvd) {
634
            if (stream->align_iframe || s->packet_number == 0) {
635 636 637 638 639 640 641 642 643 644
                int PES_bytes_to_fill = s->packet_size - size - 10;

                if (pts != AV_NOPTS_VALUE) {
                    if (dts != pts)
                        PES_bytes_to_fill -= 5 + 5;
                    else
                        PES_bytes_to_fill -= 5;
                }

                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

650
                    avio_wb32(ctx->pb, PRIVATE_STREAM_2);
651 652
                    avio_wb16(ctx->pb, 0x03d4);     // length
                    avio_w8(ctx->pb, 0x00);         // substream ID, 00=PCI
653
                    for (i = 0; i < 979; i++)
654
                        avio_w8(ctx->pb, 0x00);
655

656
                    avio_wb32(ctx->pb, PRIVATE_STREAM_2);
657 658
                    avio_wb16(ctx->pb, 0x03fa);     // length
                    avio_w8(ctx->pb, 0x01);         // substream ID, 01=DSI
659
                    for (i = 0; i < 1017; i++)
660
                        avio_w8(ctx->pb, 0x00);
661 662 663 664 665

                    memset(buffer, 0, 128);
                    buf_ptr = buffer;
                    s->packet_number++;
                    stream->align_iframe = 0;
666 667 668 669 670 671
                    // FIXME: rounding and first few bytes of each packet
                    scr        += s->packet_size * 90000LL /
                                  (s->mux_rate * 50LL);
                    size        = put_pack_header(ctx, buf_ptr, scr);
                    s->last_scr = scr;
                    buf_ptr    += size;
672 673
                    /* GOP Start */
                } else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
674 675
                    pad_packet_bytes = PES_bytes_to_fill -
                                       stream->bytes_to_iframe;
676 677 678 679
                }
            }
        } else {
            if ((s->packet_number % s->system_header_freq) == 0) {
680
                size     = put_system_header(ctx, buf_ptr, 0);
681 682 683 684 685
                buf_ptr += size;
            }
        }
    }
    size = buf_ptr - buffer;
686
    avio_write(ctx->pb, buffer, size);
687 688 689

    packet_size = s->packet_size - size;

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 694
        zero_trail_bytes += 20;

695 696
    if ((s->is_vcd && stream->packet_number == 0) ||
        (s->is_svcd && s->packet_number == 0)) {
697
        /* for VCD the first pack of each stream contains only the pack header,
698 699 700
         * the system header and lots of padding (see VCD standard p. IV-6).
         * In the case of an audio pack, 20 zero bytes are also added at
         * 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 705
            /* the system header refers to both streams and no stream data */
            general_pack = 1;
706 707 708 709 710 711 712 713 714 715 716 717
        pad_packet_bytes = packet_size - zero_trail_bytes;
    }

    packet_size -= pad_packet_bytes + zero_trail_bytes;

    if (packet_size > 0) {
        /* packet header size */
        packet_size -= 6;

        /* packet header */
        if (s->is_mpeg2) {
            header_len = 3;
718
            if (stream->packet_number == 0)
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
                header_len += 3; /* PES extension */
            header_len += 1; /* obligatory stuffing byte */
        } else {
            header_len = 0;
        }
        if (pts != AV_NOPTS_VALUE) {
            if (dts != pts)
                header_len += 5 + 5;
            else
                header_len += 5;
        } else {
            if (!s->is_mpeg2)
                header_len++;
        }

        payload_size = packet_size - header_len;
        if (id < 0xc0) {
736
            startcode     = PRIVATE_STREAM_1;
737 738 739 740 741 742 743 744 745 746
            payload_size -= 1;
            if (id >= 0x40) {
                payload_size -= 3;
                if (id >= 0xa0)
                    payload_size -= 3;
            }
        } else {
            startcode = 0x100 + id;
        }

747
        stuffing_size = payload_size - av_fifo_size(stream->fifo);
748 749

        // first byte does not fit -> reset pts/dts + stuffing
750 751 752
        if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
            int timestamp_len = 0;
            if (dts != pts)
753
                timestamp_len += 5;
754
            if (pts != AV_NOPTS_VALUE)
755
                timestamp_len += s->is_mpeg2 ? 5 : 4;
756 757
            pts         =
            dts         = AV_NOPTS_VALUE;
758 759 760
            header_len -= timestamp_len;
            if (s->is_dvd && stream->align_iframe) {
                pad_packet_bytes += timestamp_len;
761
                packet_size      -= timestamp_len;
762 763 764 765
            } else {
                payload_size += timestamp_len;
            }
            stuffing_size += timestamp_len;
766
            if (payload_size > trailer_size)
767 768 769
                stuffing_size += payload_size - trailer_size;
        }

770 771 772
        // can't use padding, so use stuffing
        if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
            packet_size  += pad_packet_bytes;
773
            payload_size += pad_packet_bytes; // undo the previous adjustment
774 775 776
            if (stuffing_size < 0)
                stuffing_size = pad_packet_bytes;
            else
777 778 779 780 781 782
                stuffing_size += pad_packet_bytes;
            pad_packet_bytes = 0;
        }

        if (stuffing_size < 0)
            stuffing_size = 0;
783 784 785 786 787 788

        if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
            if (payload_size < av_fifo_size(stream->fifo))
                stuffing_size += payload_size % stream->lpcm_align;
        }

789
        if (stuffing_size > 16) {   /* <=16 for MPEG-1, <=32 for MPEG-2 */
790
            pad_packet_bytes += stuffing_size;
Michael Niedermayer's avatar
Michael Niedermayer committed
791 792
            packet_size      -= stuffing_size;
            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 812 813 814 815 816 817

            if (pts != AV_NOPTS_VALUE) {
                pes_flags |= 0x80;
                if (dts != pts)
                    pes_flags |= 0x40;
            }

            /* Both the MPEG-2 and the SVCD standards demand that the
818 819 820
             * P-STD_buffer_size field be included in the first packet of
             * every stream. (see SVCD standard p. 26 V.2.3.1 and V.2.3.2
             * and MPEG-2 standard 2.7.7) */
821 822 823
            if (stream->packet_number == 0)
                pes_flags |= 0x01;

824 825
            avio_w8(ctx->pb, pes_flags); /* flags */
            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 842 843
            }
        } else {
            if (pts != AV_NOPTS_VALUE) {
                if (dts != pts) {
844 845
                    put_timestamp(ctx->pb, 0x03, pts);
                    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 855
            }
        }

        if (s->is_mpeg2) {
            /* 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 866
            if (id >= 0xa0) {
                /* LPCM (XXX: check nb_frames) */
867 868 869 870 871
                avio_w8(ctx->pb, 7);
                avio_wb16(ctx->pb, 4); /* skip 3 header bytes */
                avio_w8(ctx->pb, stream->lpcm_header[0]);
                avio_w8(ctx->pb, stream->lpcm_header[1]);
                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 883
                             payload_size - stuffing_size,
                             (void (*)(void*, void*, int))avio_write);
884
        stream->bytes_to_iframe -= payload_size - stuffing_size;
885 886 887
    } else {
        payload_size  =
        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 899 900

    s->packet_number++;

    /* only increase the stream packet number if this pack actually contains
901 902
     * something that is specific to this stream! I.e. a dedicated header
     * or some data. */
903 904 905 906 907 908 909 910 911
    if (!general_pack)
        stream->packet_number++;

    return payload_size - stuffing_size;
}

static void put_vcd_padding_sector(AVFormatContext *ctx)
{
    /* There are two ways to do this padding: writing a sector/pack
912 913 914 915
     * of 0 values, or writing an MPEG padding pack. Both seem to
     * work with most decoders, BUT the VCD standard only allows a 0-sector
     * (see standard p. IV-4, IV-5).
     * So a 0-sector it is... */
916 917 918 919

    MpegMuxContext *s = ctx->priv_data;
    int i;

920
    for (i = 0; i < s->packet_size; i++)
921
        avio_w8(ctx->pb, 0);
922 923 924

    s->vcd_padding_bytes_written += s->packet_size;

925
    avio_flush(ctx->pb);
926 927

    /* increasing the packet number is correct. The SCR of the following packs
928 929 930
     * is calculated from the packet_number and it has to include the padding
     * sector (it represents the sector index, not the MPEG pack index)
     * (see VCD standard p. IV-6) */
931 932 933
    s->packet_number++;
}

934 935
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
{
936 937
    int i;

938
    for (i = 0; i < ctx->nb_streams; i++) {
939 940 941 942
        AVStream *st = ctx->streams[i];
        StreamInfo *stream = st->priv_data;
        PacketDesc *pkt_desc;

943 944 945 946
        while ((pkt_desc = stream->predecode_packet) &&
               scr > pkt_desc->dts) { // FIXME: > vs >=
            if (stream->buffer_index < pkt_desc->size ||
                stream->predecode_packet == stream->premux_packet) {
947
                av_log(ctx, AV_LOG_ERROR,
948
                       "buffer underflow st=%d bufi=%d size=%d\n",
949 950 951
                       i, stream->buffer_index, pkt_desc->size);
                break;
            }
952 953
            stream->buffer_index    -= pkt_desc->size;
            stream->predecode_packet = pkt_desc->next;
954 955 956 957 958 959 960
            av_freep(&pkt_desc);
        }
    }

    return 0;
}

961 962
static int output_packet(AVFormatContext *ctx, int flush)
{
963 964 965
    MpegMuxContext *s = ctx->priv_data;
    AVStream *st;
    StreamInfo *stream;
966 967 968 969
    int i, avail_space = 0, es_size, trailer_size;
    int best_i = -1;
    int best_score = INT_MIN;
    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 978
        AVStream *st = ctx->streams[i];
        StreamInfo *stream = st->priv_data;
979 980
        const int avail_data = av_fifo_size(stream->fifo);
        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 986
         * so we flush after every single subtitle packet */
        if (s->packet_size > avail_data && !flush
987
            && st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
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 995
            continue;

996
        if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
997
            continue;
998 999 1000
        if (   stream->predecode_packet
            && stream->predecode_packet->size > stream->buffer_index)
            rel_space += 1<<28;
1001 1002 1003 1004
        if (rel_space > best_score) {
            best_score  = rel_space;
            best_i      = i;
            avail_space = space;
1005 1006 1007
        }
    }

1008 1009
    if (best_i < 0) {
        int64_t best_dts = INT64_MAX;
1010
        int has_premux = 0;
1011

1012
        for (i = 0; i < ctx->nb_streams; i++) {
1013 1014
            AVStream *st = ctx->streams[i];
            StreamInfo *stream = st->priv_data;
1015 1016 1017
            PacketDesc *pkt_desc = stream->predecode_packet;
            if (pkt_desc && pkt_desc->dts < best_dts)
                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 1026 1027 1028 1029 1030 1031 1032 1033
            if (scr >= best_dts + 1 && !ignore_constraints) {
                av_log(ctx, AV_LOG_ERROR,
                    "packet too large, ignoring buffer limits to mux it\n");
                ignore_constraints = 1;
            }
            scr = FFMAX(best_dts + 1, scr);
            if (remove_decoded_packets(ctx, scr) < 0)
                return -1;
        } else if (has_premux && flush) {
1034
            av_log(ctx, AV_LOG_ERROR,
1035 1036
                  "delay too large, ignoring ...\n");
            ignore_delay = 1;
1037
            ignore_constraints = 1;
1038 1039 1040
        } else
            return 0;

1041 1042 1043
        goto retry;
    }

1044
    av_assert0(best_i >= 0);
1045

1046
    st     = ctx->streams[best_i];
1047 1048
    stream = st->priv_data;

1049
    av_assert0(av_fifo_size(stream->fifo) > 0);
1050

1051
    av_assert0(avail_space >= s->packet_size || ignore_constraints);
1052

1053 1054 1055 1056 1057 1058
    timestamp_packet = stream->premux_packet;
    if (timestamp_packet->unwritten_size == timestamp_packet->size) {
        trailer_size = 0;
    } else {
        trailer_size     = timestamp_packet->unwritten_size;
        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 1064 1065
                timestamp_packet->dts / 90000.0,
                timestamp_packet->pts / 90000.0,
                scr / 90000.0, best_i);
1066 1067 1068
        es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
                               timestamp_packet->dts, scr, trailer_size);
    } else {
1069
        av_assert0(av_fifo_size(stream->fifo) == trailer_size);
1070 1071
        es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
                               trailer_size);
1072 1073 1074 1075
    }

    if (s->is_vcd) {
        /* Write one or more padding sectors, if necessary, to reach
1076
         * the constant overall bitrate. */
1077 1078
        int vcd_pad_bytes;

1079 1080
        // FIXME: pts cannot be correct here
        while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
1081
            put_vcd_padding_sector(ctx);
1082 1083
            // FIXME: rounding and first few bytes of each packet
            s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1084 1085 1086 1087
        }
    }

    stream->buffer_index += es_size;
1088 1089
    // FIXME: rounding and first few bytes of each packet
    s->last_scr          += s->packet_size * 90000LL / (s->mux_rate * 50LL);
1090

1091 1092 1093 1094
    while (stream->premux_packet &&
           stream->premux_packet->unwritten_size <= es_size) {
        es_size              -= stream->premux_packet->unwritten_size;
        stream->premux_packet = stream->premux_packet->next;
1095
    }
1096 1097
    if (es_size) {
        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 1103 1104 1105 1106 1107 1108
        return -1;

    return 1;
}

static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
{
1109 1110 1111
    int stream_index = pkt->stream_index;
    int size         = pkt->size;
    uint8_t *buf     = pkt->data;
1112
    MpegMuxContext *s = ctx->priv_data;
1113
    AVStream *st      = ctx->streams[stream_index];
1114 1115 1116
    StreamInfo *stream = st->priv_data;
    int64_t pts, dts;
    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 1122
    preload = av_rescale(s->preload, 90000, AV_TIME_BASE);

1123 1124
    pts = pkt->pts;
    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 1129
            if (dts != AV_NOPTS_VALUE)
                s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
1130 1131
            s->last_scr = 0;
        } else {
1132 1133
            s->last_scr = dts - preload;
            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 1140

    if (dts != AV_NOPTS_VALUE) dts += preload;
    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 1144
            dts / 90000.0, pts / 90000.0, pkt->flags,
            pkt->stream_index, pts != AV_NOPTS_VALUE);
1145 1146
    if (!stream->premux_packet)
        stream->next_packet = &stream->premux_packet;
1147 1148
    *stream->next_packet     =
    pkt_desc                 = av_mallocz(sizeof(PacketDesc));
1149 1150
    if (!pkt_desc)
        return AVERROR(ENOMEM);
1151 1152 1153 1154 1155 1156 1157
    pkt_desc->pts            = pts;
    pkt_desc->dts            = dts;
    pkt_desc->unwritten_size =
    pkt_desc->size           = size;
    if (!stream->predecode_packet)
        stream->predecode_packet = pkt_desc;
    stream->next_packet = &pkt_desc->next;
1158

1159
    if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
1160
        return -1;
1161

1162 1163 1164 1165 1166
    if (s->is_dvd) {
        // min VOBU length 0.4 seconds (mpucoder)
        if (is_iframe &&
            (s->packet_number == 0 ||
             (pts - stream->vobu_start_pts >= 36000))) {
1167
            stream->bytes_to_iframe = av_fifo_size(stream->fifo);
1168 1169
            stream->align_iframe    = 1;
            stream->vobu_start_pts  = pts;
1170 1171 1172
        }
    }

1173
    av_fifo_generic_write(stream->fifo, buf, size, NULL);
1174

1175 1176 1177
    for (;;) {
        int ret = output_packet(ctx, 0);
        if (ret <= 0)
1178 1179 1180 1181 1182 1183 1184 1185 1186
            return ret;
    }
}

static int mpeg_mux_end(AVFormatContext *ctx)
{
    StreamInfo *stream;
    int i;

1187 1188 1189
    for (;;) {
        int ret = output_packet(ctx, 1);
        if (ret < 0)
1190
            return ret;
1191
        else if (ret == 0)
1192 1193 1194
            break;
    }

1195
    /* End header according to MPEG-1 systems standard. We do not write
1196 1197 1198 1199
     * it as it is usually not needed by decoders and because it
     * complicates MPEG stream concatenation. */
    // avio_wb32(ctx->pb, ISO_11172_END_CODE);
    // avio_flush(ctx->pb);
1200

1201
    for (i = 0; i < ctx->nb_streams; i++) {
1202 1203
        stream = ctx->streams[i]->priv_data;

1204
        av_assert0(av_fifo_size(stream->fifo) == 0);
Lukasz Marek's avatar
Lukasz Marek committed
1205
        av_fifo_freep(&stream->fifo);
1206 1207 1208 1209
    }
    return 0;
}

1210 1211 1212
#define OFFSET(x) offsetof(MpegMuxContext, x)
#define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
1213
    { "muxrate", NULL,                                          OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
1214
    { "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload),  AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
1215 1216 1217
    { NULL },
};

1218 1219 1220 1221 1222 1223
#define MPEGENC_CLASS(flavor)                   \
static const AVClass flavor ## _class = {       \
    .class_name = #flavor " muxer",             \
    .item_name  = av_default_item_name,         \
    .version    = LIBAVUTIL_VERSION_INT,        \
    .option     = options,                      \
1224 1225
};

1226
#if CONFIG_MPEG1SYSTEM_MUXER
1227
MPEGENC_CLASS(mpeg)
1228
AVOutputFormat ff_mpeg1system_muxer = {
1229
    .name              = "mpeg",
1230
    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
1231 1232 1233
    .mime_type         = "video/mpeg",
    .extensions        = "mpg,mpeg",
    .priv_data_size    = sizeof(MpegMuxContext),
1234 1235
    .audio_codec       = AV_CODEC_ID_MP2,
    .video_codec       = AV_CODEC_ID_MPEG1VIDEO,
1236 1237 1238
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
1239
    .priv_class        = &mpeg_class,
1240 1241
};
#endif
1242

1243
#if CONFIG_MPEG1VCD_MUXER
1244
MPEGENC_CLASS(vcd)
1245
AVOutputFormat ff_mpeg1vcd_muxer = {
1246
    .name              = "vcd",
1247
    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
1248 1249
    .mime_type         = "video/mpeg",
    .priv_data_size    = sizeof(MpegMuxContext),
1250 1251
    .audio_codec       = AV_CODEC_ID_MP2,
    .video_codec       = AV_CODEC_ID_MPEG1VIDEO,
1252 1253 1254
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
1255
    .priv_class        = &vcd_class,
1256 1257
};
#endif
1258

1259
#if CONFIG_MPEG2VOB_MUXER
1260
MPEGENC_CLASS(vob)
1261
AVOutputFormat ff_mpeg2vob_muxer = {
1262
    .name              = "vob",
1263
    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
1264 1265 1266
    .mime_type         = "video/mpeg",
    .extensions        = "vob",
    .priv_data_size    = sizeof(MpegMuxContext),
1267 1268
    .audio_codec       = AV_CODEC_ID_MP2,
    .video_codec       = AV_CODEC_ID_MPEG2VIDEO,
1269 1270 1271
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
1272
    .priv_class        = &vob_class,
1273 1274 1275 1276
};
#endif

/* Same as mpeg2vob_mux except that the pack size is 2324 */
1277
#if CONFIG_MPEG2SVCD_MUXER
1278
MPEGENC_CLASS(svcd)
1279
AVOutputFormat ff_mpeg2svcd_muxer = {
1280
    .name              = "svcd",
1281
    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
1282 1283 1284
    .mime_type         = "video/mpeg",
    .extensions        = "vob",
    .priv_data_size    = sizeof(MpegMuxContext),
1285 1286
    .audio_codec       = AV_CODEC_ID_MP2,
    .video_codec       = AV_CODEC_ID_MPEG2VIDEO,
1287 1288 1289
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
1290
    .priv_class        = &svcd_class,
1291 1292 1293 1294
};
#endif

/*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
1295
#if CONFIG_MPEG2DVD_MUXER
1296
MPEGENC_CLASS(dvd)
1297
AVOutputFormat ff_mpeg2dvd_muxer = {
1298
    .name              = "dvd",
1299
    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
1300 1301 1302
    .mime_type         = "video/mpeg",
    .extensions        = "dvd",
    .priv_data_size    = sizeof(MpegMuxContext),
1303 1304
    .audio_codec       = AV_CODEC_ID_MP2,
    .video_codec       = AV_CODEC_ID_MPEG2VIDEO,
1305 1306 1307
    .write_header      = mpeg_mux_init,
    .write_packet      = mpeg_mux_write_packet,
    .write_trailer     = mpeg_mux_end,
1308
    .priv_class        = &dvd_class,
1309 1310
};
#endif