2007-06-21 11:39:29 +02:00
|
|
|
/*
|
2016-04-27 19:45:23 +02:00
|
|
|
* MPEG-1/2 muxer
|
2009-01-19 16:46:40 +01:00
|
|
|
* Copyright (c) 2000, 2001, 2002 Fabrice Bellard
|
2007-06-21 11:39:29 +02:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2013-11-23 21:32:55 +01:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2013-04-18 15:54:26 +02:00
|
|
|
#include "libavutil/attributes.h"
|
2008-05-09 13:56:36 +02:00
|
|
|
#include "libavutil/fifo.h"
|
2011-10-09 14:40:11 +02:00
|
|
|
#include "libavutil/log.h"
|
2011-06-04 13:58:23 +02:00
|
|
|
#include "libavutil/mathematics.h"
|
2011-10-09 14:40:11 +02:00
|
|
|
#include "libavutil/opt.h"
|
2014-08-06 05:01:15 +02:00
|
|
|
|
2009-04-12 10:35:26 +02:00
|
|
|
#include "libavcodec/put_bits.h"
|
2014-08-06 05:01:15 +02:00
|
|
|
|
2007-06-21 11:39:29 +02:00
|
|
|
#include "avformat.h"
|
2011-11-29 19:28:15 +01:00
|
|
|
#include "internal.h"
|
2007-06-21 11:39:29 +02:00
|
|
|
#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;
|
|
|
|
|
2014-09-22 09:19:33 +02:00
|
|
|
typedef struct StreamInfo {
|
2009-03-08 15:16:55 +01:00
|
|
|
AVFifoBuffer *fifo;
|
2007-06-21 11:39:29 +02:00
|
|
|
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;
|
|
|
|
|
2014-09-22 09:19:33 +02:00
|
|
|
typedef struct MpegMuxContext {
|
2011-10-09 14:40:11 +02:00
|
|
|
const AVClass *class;
|
2007-06-21 11:39:29 +02:00
|
|
|
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;
|
2012-04-07 07:56:11 +02:00
|
|
|
int user_mux_rate; /* bitrate in units of bits/s */
|
2007-06-21 11:39:29 +02:00
|
|
|
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 */
|
|
|
|
|
2015-05-25 12:43:51 +02:00
|
|
|
int64_t vcd_padding_bitrate_num;
|
2007-06-21 11:39:29 +02:00
|
|
|
int64_t vcd_padding_bytes_written;
|
|
|
|
|
2011-10-09 15:04:38 +02:00
|
|
|
int preload;
|
2007-06-21 11:39:29 +02:00
|
|
|
} MpegMuxContext;
|
|
|
|
|
2011-01-25 23:03:28 +01:00
|
|
|
extern AVOutputFormat ff_mpeg1vcd_muxer;
|
|
|
|
extern AVOutputFormat ff_mpeg2dvd_muxer;
|
|
|
|
extern AVOutputFormat ff_mpeg2svcd_muxer;
|
|
|
|
extern AVOutputFormat ff_mpeg2vob_muxer;
|
2007-09-17 01:00:44 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
static int put_pack_header(AVFormatContext *ctx, uint8_t *buf,
|
|
|
|
int64_t timestamp)
|
2007-06-21 11:39:29 +02:00
|
|
|
{
|
|
|
|
MpegMuxContext *s = ctx->priv_data;
|
|
|
|
PutBitContext pb;
|
|
|
|
|
|
|
|
init_put_bits(&pb, buf, 128);
|
|
|
|
|
2009-10-01 17:40:29 +02:00
|
|
|
put_bits32(&pb, PACK_START_CODE);
|
2014-08-06 05:01:15 +02:00
|
|
|
if (s->is_mpeg2)
|
2007-06-21 11:39:29 +02:00
|
|
|
put_bits(&pb, 2, 0x1);
|
2014-08-06 05:01:15 +02:00
|
|
|
else
|
2007-06-21 11:39:29 +02:00
|
|
|
put_bits(&pb, 4, 0x2);
|
2014-08-06 05:01:15 +02:00
|
|
|
put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
|
|
|
|
put_bits(&pb, 1, 1);
|
2007-06-21 11:39:29 +02:00
|
|
|
put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
|
2014-08-06 05:01:15 +02:00
|
|
|
put_bits(&pb, 1, 1);
|
|
|
|
put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
|
|
|
|
put_bits(&pb, 1, 1);
|
|
|
|
if (s->is_mpeg2)
|
2007-06-21 11:39:29 +02:00
|
|
|
/* 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);
|
2009-04-13 18:59:38 +02:00
|
|
|
return put_bits_ptr(&pb) - pb.buf;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
static int put_system_header(AVFormatContext *ctx, uint8_t *buf,
|
|
|
|
int only_for_stream_id)
|
2007-06-21 11:39:29 +02:00
|
|
|
{
|
|
|
|
MpegMuxContext *s = ctx->priv_data;
|
|
|
|
int size, i, private_stream_coded, id;
|
|
|
|
PutBitContext pb;
|
|
|
|
|
|
|
|
init_put_bits(&pb, buf, 128);
|
|
|
|
|
2009-10-01 17:40:29 +02:00
|
|
|
put_bits32(&pb, SYSTEM_HEADER_START_CODE);
|
2007-06-21 11:39:29 +02:00
|
|
|
put_bits(&pb, 16, 0);
|
|
|
|
put_bits(&pb, 1, 1);
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
/* maximum bit rate of the multiplexed stream */
|
|
|
|
put_bits(&pb, 22, s->mux_rate);
|
2007-06-21 11:39:29 +02:00
|
|
|
put_bits(&pb, 1, 1); /* marker */
|
2014-08-06 05:01:15 +02:00
|
|
|
if (s->is_vcd && only_for_stream_id == VIDEO_ID) {
|
|
|
|
/* This header applies only to the video stream
|
|
|
|
* (see VCD standard p. IV-7) */
|
2007-06-21 11:39:29 +02:00
|
|
|
put_bits(&pb, 6, 0);
|
|
|
|
} else
|
|
|
|
put_bits(&pb, 6, s->audio_bound);
|
|
|
|
|
|
|
|
if (s->is_vcd) {
|
2014-08-06 05:01:15 +02:00
|
|
|
/* see VCD standard, p. IV-7 */
|
2007-06-21 11:39:29 +02:00
|
|
|
put_bits(&pb, 1, 0);
|
|
|
|
put_bits(&pb, 1, 1);
|
|
|
|
} else {
|
2014-08-06 05:01:15 +02:00
|
|
|
put_bits(&pb, 1, 0); /* variable bitrate */
|
2016-04-27 19:45:23 +02:00
|
|
|
put_bits(&pb, 1, 0); /* nonconstrained bitstream */
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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 */
|
|
|
|
|
2009-05-22 00:33:17 +02:00
|
|
|
if (s->is_vcd && (only_for_stream_id & 0xe0) == AUDIO_ID) {
|
2014-08-06 05:01:15 +02:00
|
|
|
/* This header applies only to the audio stream
|
|
|
|
* (see VCD standard p. IV-7) */
|
2007-06-21 11:39:29 +02:00
|
|
|
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
|
2014-08-06 05:01:15 +02:00
|
|
|
* 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. */
|
2007-06-21 11:39:29 +02:00
|
|
|
if (s->is_dvd) {
|
|
|
|
|
|
|
|
int P_STD_max_video = 0;
|
|
|
|
int P_STD_max_mpeg_audio = 0;
|
|
|
|
int P_STD_max_mpeg_PS1 = 0;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
2007-06-21 11:39:29 +02:00
|
|
|
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;
|
2014-08-06 05:01:15 +02:00
|
|
|
} else if (id >= 0xc0 && id <= 0xc7 &&
|
|
|
|
stream->max_buffer_size > P_STD_max_mpeg_audio) {
|
2007-06-21 11:39:29 +02:00
|
|
|
P_STD_max_mpeg_audio = stream->max_buffer_size;
|
2014-08-06 05:01:15 +02:00
|
|
|
} else if (id == 0xe0 &&
|
|
|
|
stream->max_buffer_size > P_STD_max_video) {
|
2007-06-21 11:39:29 +02:00
|
|
|
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);
|
2014-08-06 05:01:15 +02:00
|
|
|
} else {
|
2007-06-21 11:39:29 +02:00
|
|
|
/* audio stream info */
|
|
|
|
private_stream_coded = 0;
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
2007-06-21 11:39:29 +02:00
|
|
|
StreamInfo *stream = ctx->streams[i]->priv_data;
|
|
|
|
|
|
|
|
/* For VCDs, only include the stream info for the stream
|
2014-08-06 05:01:15 +02:00
|
|
|
* 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) {
|
2007-06-21 11:39:29 +02:00
|
|
|
id = stream->id;
|
|
|
|
if (id < 0xc0) {
|
2008-08-03 18:42:32 +02:00
|
|
|
/* special case for private streams (AC-3 uses that) */
|
2007-06-21 11:39:29 +02:00
|
|
|
if (private_stream_coded)
|
|
|
|
continue;
|
|
|
|
private_stream_coded = 1;
|
|
|
|
id = 0xbd;
|
|
|
|
}
|
2014-08-06 05:01:15 +02:00
|
|
|
put_bits(&pb, 8, id); /* stream ID */
|
2007-06-21 11:39:29 +02:00
|
|
|
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);
|
2009-04-13 18:59:38 +02:00
|
|
|
size = put_bits_ptr(&pb) - pb.buf;
|
2007-06-21 11:39:29 +02:00
|
|
|
/* patch packet size */
|
2013-09-26 13:36:45 +02:00
|
|
|
AV_WB16(buf + 4, size - 6);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
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)
|
2014-08-06 05:01:15 +02:00
|
|
|
return 18; // DVD-Video system headers are 18 bytes fixed length.
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
buf_index = 12;
|
|
|
|
private_stream_coded = 0;
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
2007-06-21 11:39:29 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-04-18 15:54:26 +02:00
|
|
|
static av_cold int mpeg_mux_init(AVFormatContext *ctx)
|
2007-06-21 11:39:29 +02:00
|
|
|
{
|
|
|
|
MpegMuxContext *s = ctx->priv_data;
|
2014-08-08 13:05:12 +02:00
|
|
|
int bitrate, i, mpa_id, mpv_id, h264_id, mps_id, ac3_id, dts_id, lpcm_id, j;
|
2007-06-21 11:39:29 +02:00
|
|
|
AVStream *st;
|
|
|
|
StreamInfo *stream;
|
|
|
|
int audio_bitrate;
|
|
|
|
int video_bitrate;
|
|
|
|
|
|
|
|
s->packet_number = 0;
|
2014-08-06 05:01:15 +02:00
|
|
|
s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
|
|
|
|
s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
|
2011-01-25 23:03:28 +01:00
|
|
|
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));
|
2014-08-06 05:01:15 +02:00
|
|
|
s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (ctx->packet_size) {
|
2009-06-17 21:04:02 +02:00
|
|
|
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;
|
|
|
|
}
|
2007-06-21 11:39:29 +02:00
|
|
|
s->packet_size = ctx->packet_size;
|
2009-06-17 21:04:02 +02:00
|
|
|
} else
|
2007-06-21 11:39:29 +02:00
|
|
|
s->packet_size = 2048;
|
2014-08-06 05:01:15 +02:00
|
|
|
if (ctx->max_delay < 0) /* Not set by the caller */
|
2015-05-25 12:57:22 +02:00
|
|
|
ctx->max_delay = AV_TIME_BASE*7/10;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
s->vcd_padding_bytes_written = 0;
|
2015-05-25 12:43:51 +02:00
|
|
|
s->vcd_padding_bitrate_num = 0;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
s->audio_bound = 0;
|
|
|
|
s->video_bound = 0;
|
2014-08-06 05:01:15 +02:00
|
|
|
|
|
|
|
mpa_id = AUDIO_ID;
|
|
|
|
ac3_id = AC3_ID;
|
|
|
|
dts_id = DTS_ID;
|
|
|
|
mpv_id = VIDEO_ID;
|
2014-08-08 13:05:12 +02:00
|
|
|
h264_id = H264_ID;
|
2014-08-06 05:01:15 +02:00
|
|
|
mps_id = SUB_ID;
|
2007-06-21 11:39:29 +02:00
|
|
|
lpcm_id = LPCM_ID;
|
2014-08-06 05:01:15 +02:00
|
|
|
|
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
2015-10-04 12:27:10 +02:00
|
|
|
AVCPBProperties *props;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
st = ctx->streams[i];
|
2007-06-21 11:39:29 +02:00
|
|
|
stream = av_mallocz(sizeof(StreamInfo));
|
|
|
|
if (!stream)
|
|
|
|
goto fail;
|
|
|
|
st->priv_data = stream;
|
|
|
|
|
2011-11-29 19:28:15 +01:00
|
|
|
avpriv_set_pts_info(st, 64, 1, 90000);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
switch (st->codecpar->codec_type) {
|
2010-03-31 01:30:55 +02:00
|
|
|
case AVMEDIA_TYPE_AUDIO:
|
2013-11-24 10:37:52 +01:00
|
|
|
if (!s->is_mpeg2 &&
|
2016-04-10 21:58:15 +02:00
|
|
|
(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))
|
2013-11-24 10:37:52 +01:00
|
|
|
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",
|
2016-04-10 21:58:15 +02:00
|
|
|
avcodec_get_name(st->codecpar->codec_id));
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
|
2007-06-21 11:39:29 +02:00
|
|
|
stream->id = ac3_id++;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
} else if (st->codecpar->codec_id == AV_CODEC_ID_DTS) {
|
2007-06-21 11:39:29 +02:00
|
|
|
stream->id = dts_id++;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
} else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
|
2007-06-21 11:39:29 +02:00
|
|
|
stream->id = lpcm_id++;
|
2014-08-06 05:01:15 +02:00
|
|
|
for (j = 0; j < 4; j++) {
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (lpcm_freq_tab[j] == st->codecpar->sample_rate)
|
2007-06-21 11:39:29 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (j == 4)
|
|
|
|
goto fail;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->channels > 8)
|
2007-06-21 11:39:29 +02:00
|
|
|
return -1;
|
|
|
|
stream->lpcm_header[0] = 0x0c;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
stream->lpcm_header[1] = (st->codecpar->channels - 1) | (j << 4);
|
2007-06-21 11:39:29 +02:00
|
|
|
stream->lpcm_header[2] = 0x80;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
stream->lpcm_align = st->codecpar->channels * 2;
|
2007-06-21 11:39:29 +02:00
|
|
|
} else {
|
|
|
|
stream->id = mpa_id++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This value HAS to be used for VCD (see VCD standard, p. IV-7).
|
2014-08-06 05:01:15 +02:00
|
|
|
* Right now it is also used for everything else. */
|
2007-06-21 11:39:29 +02:00
|
|
|
stream->max_buffer_size = 4 * 1024;
|
|
|
|
s->audio_bound++;
|
|
|
|
break;
|
2010-03-31 01:30:55 +02:00
|
|
|
case AVMEDIA_TYPE_VIDEO:
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
if (st->codecpar->codec_id == AV_CODEC_ID_H264)
|
2014-08-08 13:05:12 +02:00
|
|
|
stream->id = h264_id++;
|
|
|
|
else
|
|
|
|
stream->id = mpv_id++;
|
2015-10-04 12:27:10 +02:00
|
|
|
|
|
|
|
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;
|
2010-10-08 17:41:41 +02:00
|
|
|
else {
|
2014-08-06 05:01:15 +02:00
|
|
|
av_log(ctx, AV_LOG_WARNING,
|
2014-08-08 21:31:54 +02:00
|
|
|
"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");
|
2014-08-06 05:01:15 +02:00
|
|
|
// FIXME: this is probably too small as default
|
|
|
|
stream->max_buffer_size = 230 * 1024;
|
2010-10-07 03:57:39 +02:00
|
|
|
}
|
2013-09-29 17:02:06 +02:00
|
|
|
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;
|
|
|
|
}
|
2007-06-21 11:39:29 +02:00
|
|
|
s->video_bound++;
|
|
|
|
break;
|
2010-03-31 01:30:55 +02:00
|
|
|
case AVMEDIA_TYPE_SUBTITLE:
|
2014-08-06 05:01:15 +02:00
|
|
|
stream->id = mps_id++;
|
2007-06-21 11:39:29 +02:00
|
|
|
stream->max_buffer_size = 16 * 1024;
|
|
|
|
break;
|
|
|
|
default:
|
2015-08-27 17:41:52 +02:00
|
|
|
av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
|
2016-04-10 21:58:15 +02:00
|
|
|
av_get_media_type_string(st->codecpar->codec_type), i);
|
2015-08-27 17:41:52 +02:00
|
|
|
return AVERROR(EINVAL);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
2014-08-06 05:01:15 +02:00
|
|
|
stream->fifo = av_fifo_alloc(16);
|
2009-05-22 21:11:56 +02:00
|
|
|
if (!stream->fifo)
|
|
|
|
goto fail;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
2014-08-06 05:01:15 +02:00
|
|
|
bitrate = 0;
|
2007-06-21 11:39:29 +02:00
|
|
|
audio_bitrate = 0;
|
|
|
|
video_bitrate = 0;
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
2015-10-04 12:27:10 +02:00
|
|
|
AVCPBProperties *props;
|
2007-06-21 11:39:29 +02:00
|
|
|
int codec_rate;
|
2014-08-06 05:01:15 +02:00
|
|
|
st = ctx->streams[i];
|
|
|
|
stream = (StreamInfo *)st->priv_data;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2015-10-04 12:27:10 +02:00
|
|
|
props = (AVCPBProperties*)av_stream_get_side_data(st, AV_PKT_DATA_CPB_PROPERTIES, NULL);
|
|
|
|
if (props)
|
|
|
|
codec_rate = props->max_bitrate;
|
2007-06-21 11:39:29 +02:00
|
|
|
else
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
codec_rate = st->codecpar->bit_rate;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (!codec_rate)
|
|
|
|
codec_rate = (1 << 21) * 8 * 50 / ctx->nb_streams;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
bitrate += codec_rate;
|
|
|
|
|
2009-05-22 00:33:17 +02:00
|
|
|
if ((stream->id & 0xe0) == AUDIO_ID)
|
2007-06-21 11:39:29 +02:00
|
|
|
audio_bitrate += codec_rate;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
|
2007-06-21 11:39:29 +02:00
|
|
|
video_bitrate += codec_rate;
|
|
|
|
}
|
|
|
|
|
2012-04-07 07:56:11 +02:00
|
|
|
if (s->user_mux_rate) {
|
|
|
|
s->mux_rate = (s->user_mux_rate + (8 * 50) - 1) / (8 * 50);
|
|
|
|
} else {
|
2007-06-21 11:39:29 +02:00
|
|
|
/* we increase slightly the bitrate to take into account the
|
2014-08-06 05:01:15 +02:00
|
|
|
* headers. XXX: compute it exactly */
|
|
|
|
bitrate += bitrate / 20;
|
|
|
|
bitrate += 10000;
|
2007-06-21 11:39:29 +02:00
|
|
|
s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
|
2013-09-29 17:02:57 +02:00
|
|
|
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;
|
|
|
|
}
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->is_vcd) {
|
2015-05-25 12:43:51 +02:00
|
|
|
int64_t overhead_rate;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
/* The VCD standard mandates that the mux_rate field is 3528
|
2014-08-06 05:01:15 +02:00
|
|
|
* (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 */
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
/* The VCD standard states that the muxed stream must be
|
2014-08-06 05:01:15 +02:00
|
|
|
* 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 ) */
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
/* Add the header overhead to the data rate.
|
2014-08-06 05:01:15 +02:00
|
|
|
* 2279 data bytes per audio pack, 2294 data bytes per video pack */
|
2015-05-25 12:43:51 +02:00
|
|
|
overhead_rate = audio_bitrate * 2294LL * (2324 - 2279);
|
|
|
|
overhead_rate += video_bitrate * 2279LL * (2324 - 2294);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
/* Add padding so that the full bitrate is 2324*75 bytes/sec */
|
2015-05-25 12:43:51 +02:00
|
|
|
s->vcd_padding_bitrate_num = (2324LL * 75 * 8 - bitrate) * 2279 * 2294 - overhead_rate;
|
|
|
|
#define VCD_PADDING_BITRATE_DEN (2279 * 2294)
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
2014-08-06 05:01:15 +02:00
|
|
|
s->pack_header_freq = 1;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
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
|
2014-08-06 05:01:15 +02:00
|
|
|
* in the whole file: one in the first packet of each stream.
|
|
|
|
* (see standard p. IV-7 and IV-8) */
|
2007-06-21 11:39:29 +02:00
|
|
|
s->system_header_freq = 0x7fffffff;
|
|
|
|
else
|
|
|
|
s->system_header_freq = s->pack_header_freq * 5;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
|
|
|
stream = ctx->streams[i]->priv_data;
|
2007-06-21 11:39:29 +02:00
|
|
|
stream->packet_number = 0;
|
|
|
|
}
|
|
|
|
s->system_header_size = get_system_header_size(ctx);
|
2014-08-08 21:31:54 +02:00
|
|
|
s->last_scr = AV_NOPTS_VALUE;
|
2007-06-21 11:39:29 +02:00
|
|
|
return 0;
|
2014-08-06 05:01:15 +02:00
|
|
|
|
|
|
|
fail:
|
|
|
|
for (i = 0; i < ctx->nb_streams; i++)
|
2014-12-21 19:24:11 +01:00
|
|
|
av_freep(&ctx->streams[i]->priv_data);
|
2007-06-21 11:39:29 +02:00
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
|
|
|
|
2011-02-20 11:04:12 +01:00
|
|
|
static inline void put_timestamp(AVIOContext *pb, int id, int64_t timestamp)
|
2007-06-21 11:39:29 +02:00
|
|
|
{
|
2014-08-06 05:01:15 +02:00
|
|
|
avio_w8(pb, (id << 4) | (((timestamp >> 30) & 0x07) << 1) | 1);
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
|
2014-08-06 05:01:15 +02:00
|
|
|
avio_wb16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* return the number of padding bytes that should be inserted into
|
2014-08-06 05:01:15 +02:00
|
|
|
* the multiplexed stream. */
|
2007-06-21 11:39:29 +02:00
|
|
|
static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
|
|
|
|
{
|
|
|
|
MpegMuxContext *s = ctx->priv_data;
|
|
|
|
int pad_bytes = 0;
|
|
|
|
|
2015-05-25 12:43:51 +02:00
|
|
|
if (s->vcd_padding_bitrate_num > 0 && pts != AV_NOPTS_VALUE) {
|
2007-06-21 11:39:29 +02:00
|
|
|
int64_t full_pad_bytes;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
// FIXME: this is wrong
|
|
|
|
full_pad_bytes =
|
2015-05-25 12:43:51 +02:00
|
|
|
av_rescale(s->vcd_padding_bitrate_num, pts, 90000LL * 8 * VCD_PADDING_BITRATE_DEN);
|
2014-08-06 05:01:15 +02:00
|
|
|
pad_bytes = (int)(full_pad_bytes - s->vcd_padding_bytes_written);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (pad_bytes < 0)
|
2007-06-21 11:39:29 +02:00
|
|
|
/* might happen if we have already padded to a later timestamp. This
|
2014-08-06 05:01:15 +02:00
|
|
|
* can occur if another stream has already advanced further. */
|
|
|
|
pad_bytes = 0;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return pad_bytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write an MPEG padding packet header. */
|
2014-08-06 05:01:15 +02:00
|
|
|
static void put_padding_packet(AVFormatContext *ctx, AVIOContext *pb,
|
|
|
|
int packet_bytes)
|
2007-06-21 11:39:29 +02:00
|
|
|
{
|
|
|
|
MpegMuxContext *s = ctx->priv_data;
|
|
|
|
int i;
|
|
|
|
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb32(pb, PADDING_STREAM);
|
|
|
|
avio_wb16(pb, packet_bytes - 6);
|
2007-06-21 11:39:29 +02:00
|
|
|
if (!s->is_mpeg2) {
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, 0x0f);
|
2007-06-21 11:39:29 +02:00
|
|
|
packet_bytes -= 7;
|
|
|
|
} else
|
|
|
|
packet_bytes -= 6;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < packet_bytes; i++)
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(pb, 0xff);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
static int get_nb_frames(AVFormatContext *ctx, StreamInfo *stream, int len)
|
|
|
|
{
|
|
|
|
int nb_frames = 0;
|
|
|
|
PacketDesc *pkt_desc = stream->premux_packet;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
while (len > 0) {
|
|
|
|
if (pkt_desc->size == pkt_desc->unwritten_size)
|
2007-06-21 11:39:29 +02:00
|
|
|
nb_frames++;
|
2014-08-06 05:01:15 +02:00
|
|
|
len -= pkt_desc->unwritten_size;
|
|
|
|
pkt_desc = pkt_desc->next;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return nb_frames;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* flush the packet on stream stream_index */
|
|
|
|
static int flush_packet(AVFormatContext *ctx, int stream_index,
|
2014-08-06 05:01:15 +02:00
|
|
|
int64_t pts, int64_t dts, int64_t scr, int trailer_size)
|
2007-06-21 11:39:29 +02:00
|
|
|
{
|
2014-08-06 05:01:15 +02:00
|
|
|
MpegMuxContext *s = ctx->priv_data;
|
2007-06-21 11:39:29 +02:00
|
|
|
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;
|
2014-08-06 05:01:15 +02:00
|
|
|
/* "general" pack without data specific to one stream? */
|
|
|
|
int general_pack = 0;
|
2007-06-21 11:39:29 +02:00
|
|
|
int nb_frames;
|
|
|
|
|
|
|
|
id = stream->id;
|
|
|
|
|
2015-03-16 09:57:35 +01:00
|
|
|
av_log(ctx, AV_LOG_TRACE, "packet ID=%2x PTS=%0.3f\n", id, pts / 90000.0);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
buf_ptr = buffer;
|
|
|
|
|
|
|
|
if ((s->packet_number % s->pack_header_freq) == 0 || s->last_scr != scr) {
|
|
|
|
/* output pack and systems header if needed */
|
2014-08-06 05:01:15 +02:00
|
|
|
size = put_pack_header(ctx, buf_ptr, scr);
|
|
|
|
buf_ptr += size;
|
|
|
|
s->last_scr = scr;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
if (s->is_vcd) {
|
|
|
|
/* there is exactly one system header for each stream in a VCD MPEG,
|
2014-08-06 05:01:15 +02:00
|
|
|
* One in the very first video packet and one in the very first
|
|
|
|
* audio packet (see VCD standard p. IV-7 and IV-8). */
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (stream->packet_number == 0) {
|
|
|
|
size = put_system_header(ctx, buf_ptr, id);
|
2007-06-21 11:39:29 +02:00
|
|
|
buf_ptr += size;
|
|
|
|
}
|
|
|
|
} else if (s->is_dvd) {
|
2014-08-06 05:01:15 +02:00
|
|
|
if (stream->align_iframe || s->packet_number == 0) {
|
2007-06-21 11:39:29 +02:00
|
|
|
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) {
|
2014-08-06 05:01:15 +02:00
|
|
|
size = put_system_header(ctx, buf_ptr, 0);
|
2007-06-21 11:39:29 +02:00
|
|
|
buf_ptr += size;
|
2014-08-06 05:01:15 +02:00
|
|
|
size = buf_ptr - buffer;
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_write(ctx->pb, buffer, size);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb32(ctx->pb, PRIVATE_STREAM_2);
|
2014-08-06 05:01:15 +02:00
|
|
|
avio_wb16(ctx->pb, 0x03d4); // length
|
|
|
|
avio_w8(ctx->pb, 0x00); // substream ID, 00=PCI
|
2007-06-21 11:39:29 +02:00
|
|
|
for (i = 0; i < 979; i++)
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0x00);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb32(ctx->pb, PRIVATE_STREAM_2);
|
2014-08-06 05:01:15 +02:00
|
|
|
avio_wb16(ctx->pb, 0x03fa); // length
|
|
|
|
avio_w8(ctx->pb, 0x01); // substream ID, 01=DSI
|
2007-06-21 11:39:29 +02:00
|
|
|
for (i = 0; i < 1017; i++)
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0x00);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
memset(buffer, 0, 128);
|
|
|
|
buf_ptr = buffer;
|
|
|
|
s->packet_number++;
|
|
|
|
stream->align_iframe = 0;
|
2014-08-06 05:01:15 +02:00
|
|
|
// 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;
|
2007-06-21 11:39:29 +02:00
|
|
|
/* GOP Start */
|
|
|
|
} else if (stream->bytes_to_iframe < PES_bytes_to_fill) {
|
2014-08-06 05:01:15 +02:00
|
|
|
pad_packet_bytes = PES_bytes_to_fill -
|
|
|
|
stream->bytes_to_iframe;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ((s->packet_number % s->system_header_freq) == 0) {
|
2014-08-06 05:01:15 +02:00
|
|
|
size = put_system_header(ctx, buf_ptr, 0);
|
2007-06-21 11:39:29 +02:00
|
|
|
buf_ptr += size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
size = buf_ptr - buffer;
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_write(ctx->pb, buffer, size);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
packet_size = s->packet_size - size;
|
|
|
|
|
2009-05-22 00:33:17 +02:00
|
|
|
if (s->is_vcd && (id & 0xe0) == AUDIO_ID)
|
2007-06-21 11:39:29 +02:00
|
|
|
/* The VCD standard demands that 20 zero bytes follow
|
2014-08-06 05:01:15 +02:00
|
|
|
* each audio pack (see standard p. IV-8). */
|
2007-06-21 11:39:29 +02:00
|
|
|
zero_trail_bytes += 20;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if ((s->is_vcd && stream->packet_number == 0) ||
|
|
|
|
(s->is_svcd && s->packet_number == 0)) {
|
2007-06-21 11:39:29 +02:00
|
|
|
/* for VCD the first pack of each stream contains only the pack header,
|
2014-08-06 05:01:15 +02:00
|
|
|
* 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. */
|
2007-06-21 11:39:29 +02:00
|
|
|
/* For SVCD we fill the very first pack to increase compatibility with
|
2014-08-06 05:01:15 +02:00
|
|
|
* some DVD players. Not mandated by the standard. */
|
2007-06-21 11:39:29 +02:00
|
|
|
if (s->is_svcd)
|
2014-08-06 05:01:15 +02:00
|
|
|
/* the system header refers to both streams and no stream data */
|
|
|
|
general_pack = 1;
|
2007-06-21 11:39:29 +02:00
|
|
|
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;
|
2014-08-06 05:01:15 +02:00
|
|
|
if (stream->packet_number == 0)
|
2007-06-21 11:39:29 +02:00
|
|
|
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) {
|
2014-08-06 05:01:15 +02:00
|
|
|
startcode = PRIVATE_STREAM_1;
|
2007-06-21 11:39:29 +02:00
|
|
|
payload_size -= 1;
|
|
|
|
if (id >= 0x40) {
|
|
|
|
payload_size -= 3;
|
|
|
|
if (id >= 0xa0)
|
|
|
|
payload_size -= 3;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
startcode = 0x100 + id;
|
|
|
|
}
|
|
|
|
|
2009-03-08 15:16:55 +01:00
|
|
|
stuffing_size = payload_size - av_fifo_size(stream->fifo);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
// first byte does not fit -> reset pts/dts + stuffing
|
2014-08-06 05:01:15 +02:00
|
|
|
if (payload_size <= trailer_size && pts != AV_NOPTS_VALUE) {
|
|
|
|
int timestamp_len = 0;
|
|
|
|
if (dts != pts)
|
2007-06-21 11:39:29 +02:00
|
|
|
timestamp_len += 5;
|
2014-08-06 05:01:15 +02:00
|
|
|
if (pts != AV_NOPTS_VALUE)
|
2007-06-21 11:39:29 +02:00
|
|
|
timestamp_len += s->is_mpeg2 ? 5 : 4;
|
2014-08-06 05:01:15 +02:00
|
|
|
pts =
|
|
|
|
dts = AV_NOPTS_VALUE;
|
2007-06-21 11:39:29 +02:00
|
|
|
header_len -= timestamp_len;
|
|
|
|
if (s->is_dvd && stream->align_iframe) {
|
|
|
|
pad_packet_bytes += timestamp_len;
|
2014-08-06 05:01:15 +02:00
|
|
|
packet_size -= timestamp_len;
|
2007-06-21 11:39:29 +02:00
|
|
|
} else {
|
|
|
|
payload_size += timestamp_len;
|
|
|
|
}
|
|
|
|
stuffing_size += timestamp_len;
|
2014-08-06 05:01:15 +02:00
|
|
|
if (payload_size > trailer_size)
|
2007-06-21 11:39:29 +02:00
|
|
|
stuffing_size += payload_size - trailer_size;
|
|
|
|
}
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
// can't use padding, so use stuffing
|
|
|
|
if (pad_packet_bytes > 0 && pad_packet_bytes <= 7) {
|
|
|
|
packet_size += pad_packet_bytes;
|
2007-06-21 11:39:29 +02:00
|
|
|
payload_size += pad_packet_bytes; // undo the previous adjustment
|
2014-08-06 05:01:15 +02:00
|
|
|
if (stuffing_size < 0)
|
|
|
|
stuffing_size = pad_packet_bytes;
|
|
|
|
else
|
2007-06-21 11:39:29 +02:00
|
|
|
stuffing_size += pad_packet_bytes;
|
|
|
|
pad_packet_bytes = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (stuffing_size < 0)
|
|
|
|
stuffing_size = 0;
|
2012-03-13 18:12:06 +01:00
|
|
|
|
|
|
|
if (startcode == PRIVATE_STREAM_1 && id >= 0xa0) {
|
|
|
|
if (payload_size < av_fifo_size(stream->fifo))
|
|
|
|
stuffing_size += payload_size % stream->lpcm_align;
|
|
|
|
}
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (stuffing_size > 16) { /* <=16 for MPEG-1, <=32 for MPEG-2 */
|
2007-06-21 11:39:29 +02:00
|
|
|
pad_packet_bytes += stuffing_size;
|
2008-08-26 03:29:43 +02:00
|
|
|
packet_size -= stuffing_size;
|
|
|
|
payload_size -= stuffing_size;
|
2014-08-06 05:01:15 +02:00
|
|
|
stuffing_size = 0;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
nb_frames = get_nb_frames(ctx, stream, payload_size - stuffing_size);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb32(ctx->pb, startcode);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_wb16(ctx->pb, packet_size);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
if (!s->is_mpeg2)
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < stuffing_size; i++)
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0xff);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
if (s->is_mpeg2) {
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0x80); /* mpeg2 id */
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
pes_flags = 0;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
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
|
2014-08-06 05:01:15 +02:00
|
|
|
* 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) */
|
2007-06-21 11:39:29 +02:00
|
|
|
if (stream->packet_number == 0)
|
|
|
|
pes_flags |= 0x01;
|
|
|
|
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, pes_flags); /* flags */
|
|
|
|
avio_w8(ctx->pb, header_len - 3 + stuffing_size);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (pes_flags & 0x80) /* write pts */
|
2007-11-21 08:41:00 +01:00
|
|
|
put_timestamp(ctx->pb, (pes_flags & 0x40) ? 0x03 : 0x02, pts);
|
2014-08-06 05:01:15 +02:00
|
|
|
if (pes_flags & 0x40) /* write dts */
|
2007-11-21 08:41:00 +01:00
|
|
|
put_timestamp(ctx->pb, 0x01, dts);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (pes_flags & 0x01) { /* write pes extension */
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0x10); /* flags */
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
/* P-STD buffer info */
|
2009-05-22 00:33:17 +02:00
|
|
|
if ((id & 0xe0) == AUDIO_ID)
|
2014-08-06 05:01:15 +02:00
|
|
|
avio_wb16(ctx->pb, 0x4000 | stream->max_buffer_size / 128);
|
2007-06-21 11:39:29 +02:00
|
|
|
else
|
2014-08-06 05:01:15 +02:00
|
|
|
avio_wb16(ctx->pb, 0x6000 | stream->max_buffer_size / 1024);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (pts != AV_NOPTS_VALUE) {
|
|
|
|
if (dts != pts) {
|
2007-11-21 08:41:00 +01:00
|
|
|
put_timestamp(ctx->pb, 0x03, pts);
|
|
|
|
put_timestamp(ctx->pb, 0x01, dts);
|
2007-06-21 11:39:29 +02:00
|
|
|
} else {
|
2007-11-21 08:41:00 +01:00
|
|
|
put_timestamp(ctx->pb, 0x02, pts);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
} else {
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0x0f);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->is_mpeg2) {
|
|
|
|
/* special stuffing byte that is always written
|
2014-08-06 05:01:15 +02:00
|
|
|
* to prevent accidental generation of start codes. */
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0xff);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < stuffing_size; i++)
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0xff);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (startcode == PRIVATE_STREAM_1) {
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, id);
|
2007-06-21 11:39:29 +02:00
|
|
|
if (id >= 0xa0) {
|
|
|
|
/* LPCM (XXX: check nb_frames) */
|
2011-02-21 19:28:17 +01:00
|
|
|
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]);
|
2007-06-21 11:39:29 +02:00
|
|
|
} else if (id >= 0x40) {
|
2008-08-03 18:42:32 +02:00
|
|
|
/* AC-3 */
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, nb_frames);
|
2014-08-06 05:01:15 +02:00
|
|
|
avio_wb16(ctx->pb, trailer_size + 1);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* output data */
|
2014-12-19 15:08:44 +01:00
|
|
|
av_assert0(payload_size - stuffing_size <= av_fifo_size(stream->fifo));
|
2014-08-06 05:01:15 +02:00
|
|
|
av_fifo_generic_read(stream->fifo, ctx->pb,
|
2014-08-06 03:31:58 +02:00
|
|
|
payload_size - stuffing_size,
|
|
|
|
(void (*)(void*, void*, int))avio_write);
|
2007-06-21 11:39:29 +02:00
|
|
|
stream->bytes_to_iframe -= payload_size - stuffing_size;
|
2014-08-06 05:01:15 +02:00
|
|
|
} else {
|
|
|
|
payload_size =
|
|
|
|
stuffing_size = 0;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (pad_packet_bytes > 0)
|
2014-08-06 05:01:15 +02:00
|
|
|
put_padding_packet(ctx, ctx->pb, pad_packet_bytes);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < zero_trail_bytes; i++)
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0x00);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2011-03-14 20:39:06 +01:00
|
|
|
avio_flush(ctx->pb);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
s->packet_number++;
|
|
|
|
|
|
|
|
/* only increase the stream packet number if this pack actually contains
|
2014-08-06 05:01:15 +02:00
|
|
|
* something that is specific to this stream! I.e. a dedicated header
|
|
|
|
* or some data. */
|
2007-06-21 11:39:29 +02:00
|
|
|
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
|
2014-08-06 05:01:15 +02:00
|
|
|
* 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... */
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
MpegMuxContext *s = ctx->priv_data;
|
|
|
|
int i;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < s->packet_size; i++)
|
2011-02-21 19:28:17 +01:00
|
|
|
avio_w8(ctx->pb, 0);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
s->vcd_padding_bytes_written += s->packet_size;
|
|
|
|
|
2011-03-14 20:39:06 +01:00
|
|
|
avio_flush(ctx->pb);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
/* increasing the packet number is correct. The SCR of the following packs
|
2014-08-06 05:01:15 +02:00
|
|
|
* 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) */
|
2007-06-21 11:39:29 +02:00
|
|
|
s->packet_number++;
|
|
|
|
}
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
static int remove_decoded_packets(AVFormatContext *ctx, int64_t scr)
|
|
|
|
{
|
2007-06-21 11:39:29 +02:00
|
|
|
int i;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
2007-06-21 11:39:29 +02:00
|
|
|
AVStream *st = ctx->streams[i];
|
|
|
|
StreamInfo *stream = st->priv_data;
|
|
|
|
PacketDesc *pkt_desc;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
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) {
|
2007-06-21 11:39:29 +02:00
|
|
|
av_log(ctx, AV_LOG_ERROR,
|
2013-09-26 01:07:24 +02:00
|
|
|
"buffer underflow st=%d bufi=%d size=%d\n",
|
2007-06-21 11:39:29 +02:00
|
|
|
i, stream->buffer_index, pkt_desc->size);
|
|
|
|
break;
|
|
|
|
}
|
2014-08-06 05:01:15 +02:00
|
|
|
stream->buffer_index -= pkt_desc->size;
|
|
|
|
stream->predecode_packet = pkt_desc->next;
|
2007-06-21 11:39:29 +02:00
|
|
|
av_freep(&pkt_desc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
static int output_packet(AVFormatContext *ctx, int flush)
|
|
|
|
{
|
2007-06-21 11:39:29 +02:00
|
|
|
MpegMuxContext *s = ctx->priv_data;
|
|
|
|
AVStream *st;
|
|
|
|
StreamInfo *stream;
|
2014-08-06 05:01:15 +02:00
|
|
|
int i, avail_space = 0, es_size, trailer_size;
|
|
|
|
int best_i = -1;
|
|
|
|
int best_score = INT_MIN;
|
|
|
|
int ignore_constraints = 0;
|
2015-03-01 16:47:36 +01:00
|
|
|
int ignore_delay = 0;
|
2014-08-06 05:01:15 +02:00
|
|
|
int64_t scr = s->last_scr;
|
2007-06-21 11:39:29 +02:00
|
|
|
PacketDesc *timestamp_packet;
|
2014-08-06 05:01:15 +02:00
|
|
|
const int64_t max_delay = av_rescale(ctx->max_delay, 90000, AV_TIME_BASE);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
retry:
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
2007-06-21 11:39:29 +02:00
|
|
|
AVStream *st = ctx->streams[i];
|
|
|
|
StreamInfo *stream = st->priv_data;
|
2014-08-06 05:01:15 +02:00
|
|
|
const int avail_data = av_fifo_size(stream->fifo);
|
|
|
|
const int space = stream->max_buffer_size - stream->buffer_index;
|
2014-08-08 21:31:54 +02:00
|
|
|
int rel_space = 1024LL * space / stream->max_buffer_size;
|
2014-08-06 05:01:15 +02:00
|
|
|
PacketDesc *next_pkt = stream->premux_packet;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
|
|
|
/* for subtitle, a single PES packet must be generated,
|
2014-08-06 05:01:15 +02:00
|
|
|
* so we flush after every single subtitle packet */
|
|
|
|
if (s->packet_size > avail_data && !flush
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
&& st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
|
2007-06-21 11:39:29 +02:00
|
|
|
return 0;
|
2014-08-06 05:01:15 +02:00
|
|
|
if (avail_data == 0)
|
2007-06-21 11:39:29 +02:00
|
|
|
continue;
|
2014-08-08 21:31:54 +02:00
|
|
|
av_assert0(avail_data > 0);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (space < s->packet_size && !ignore_constraints)
|
2007-06-21 11:39:29 +02:00
|
|
|
continue;
|
|
|
|
|
2015-03-01 16:47:36 +01:00
|
|
|
if (next_pkt && next_pkt->dts - scr > max_delay && !ignore_delay)
|
2007-06-21 11:39:29 +02:00
|
|
|
continue;
|
2013-09-26 03:13:38 +02:00
|
|
|
if ( stream->predecode_packet
|
|
|
|
&& stream->predecode_packet->size > stream->buffer_index)
|
|
|
|
rel_space += 1<<28;
|
2014-08-06 05:01:15 +02:00
|
|
|
if (rel_space > best_score) {
|
|
|
|
best_score = rel_space;
|
|
|
|
best_i = i;
|
|
|
|
avail_space = space;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (best_i < 0) {
|
|
|
|
int64_t best_dts = INT64_MAX;
|
2015-03-01 16:47:36 +01:00
|
|
|
int has_premux = 0;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
2007-06-21 11:39:29 +02:00
|
|
|
AVStream *st = ctx->streams[i];
|
|
|
|
StreamInfo *stream = st->priv_data;
|
2014-08-06 05:01:15 +02:00
|
|
|
PacketDesc *pkt_desc = stream->predecode_packet;
|
|
|
|
if (pkt_desc && pkt_desc->dts < best_dts)
|
|
|
|
best_dts = pkt_desc->dts;
|
2015-03-01 16:47:36 +01:00
|
|
|
has_premux |= !!stream->premux_packet;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
2015-03-01 16:47:36 +01:00
|
|
|
if (best_dts < INT64_MAX) {
|
2015-04-20 03:19:29 +02:00
|
|
|
av_log(ctx, AV_LOG_TRACE, "bumping scr, scr:%f, dts:%f\n",
|
2015-03-01 16:47:36 +01:00
|
|
|
scr / 90000.0, best_dts / 90000.0);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2015-03-01 16:47:36 +01:00
|
|
|
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) {
|
2014-08-06 05:01:15 +02:00
|
|
|
av_log(ctx, AV_LOG_ERROR,
|
2015-03-01 16:47:36 +01:00
|
|
|
"delay too large, ignoring ...\n");
|
|
|
|
ignore_delay = 1;
|
2014-08-06 05:01:15 +02:00
|
|
|
ignore_constraints = 1;
|
2015-03-01 16:47:36 +01:00
|
|
|
} else
|
|
|
|
return 0;
|
|
|
|
|
2007-06-21 11:39:29 +02:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2014-12-19 15:08:44 +01:00
|
|
|
av_assert0(best_i >= 0);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
st = ctx->streams[best_i];
|
2007-06-21 11:39:29 +02:00
|
|
|
stream = st->priv_data;
|
|
|
|
|
2014-12-19 15:08:44 +01:00
|
|
|
av_assert0(av_fifo_size(stream->fifo) > 0);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-12-19 15:08:44 +01:00
|
|
|
av_assert0(avail_space >= s->packet_size || ignore_constraints);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
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;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (timestamp_packet) {
|
2015-03-16 09:57:35 +01:00
|
|
|
av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f scr:%f stream:%d\n",
|
2012-08-21 12:40:41 +02:00
|
|
|
timestamp_packet->dts / 90000.0,
|
|
|
|
timestamp_packet->pts / 90000.0,
|
|
|
|
scr / 90000.0, best_i);
|
2014-08-06 05:01:15 +02:00
|
|
|
es_size = flush_packet(ctx, best_i, timestamp_packet->pts,
|
|
|
|
timestamp_packet->dts, scr, trailer_size);
|
|
|
|
} else {
|
2014-12-19 15:08:44 +01:00
|
|
|
av_assert0(av_fifo_size(stream->fifo) == trailer_size);
|
2014-08-06 05:01:15 +02:00
|
|
|
es_size = flush_packet(ctx, best_i, AV_NOPTS_VALUE, AV_NOPTS_VALUE, scr,
|
|
|
|
trailer_size);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->is_vcd) {
|
|
|
|
/* Write one or more padding sectors, if necessary, to reach
|
2014-08-06 05:01:15 +02:00
|
|
|
* the constant overall bitrate. */
|
2007-06-21 11:39:29 +02:00
|
|
|
int vcd_pad_bytes;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
// FIXME: pts cannot be correct here
|
|
|
|
while ((vcd_pad_bytes = get_vcd_padding_size(ctx, stream->premux_packet->pts)) >= s->packet_size) {
|
2007-06-21 11:39:29 +02:00
|
|
|
put_vcd_padding_sector(ctx);
|
2014-08-06 05:01:15 +02:00
|
|
|
// FIXME: rounding and first few bytes of each packet
|
|
|
|
s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
stream->buffer_index += es_size;
|
2014-08-06 05:01:15 +02:00
|
|
|
// FIXME: rounding and first few bytes of each packet
|
|
|
|
s->last_scr += s->packet_size * 90000LL / (s->mux_rate * 50LL);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
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;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
2014-11-24 16:52:19 +01:00
|
|
|
if (es_size) {
|
|
|
|
av_assert0(stream->premux_packet);
|
2007-06-21 11:39:29 +02:00
|
|
|
stream->premux_packet->unwritten_size -= es_size;
|
2014-11-24 16:52:19 +01:00
|
|
|
}
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (remove_decoded_packets(ctx, s->last_scr) < 0)
|
2007-06-21 11:39:29 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
|
|
|
|
{
|
2014-08-06 05:01:15 +02:00
|
|
|
int stream_index = pkt->stream_index;
|
|
|
|
int size = pkt->size;
|
|
|
|
uint8_t *buf = pkt->data;
|
2007-06-21 11:39:29 +02:00
|
|
|
MpegMuxContext *s = ctx->priv_data;
|
2014-08-06 05:01:15 +02:00
|
|
|
AVStream *st = ctx->streams[stream_index];
|
2007-06-21 11:39:29 +02:00
|
|
|
StreamInfo *stream = st->priv_data;
|
|
|
|
int64_t pts, dts;
|
|
|
|
PacketDesc *pkt_desc;
|
2011-10-09 15:04:38 +02:00
|
|
|
int preload;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 20:42:52 +02:00
|
|
|
const int is_iframe = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
|
2014-08-06 05:01:15 +02:00
|
|
|
(pkt->flags & AV_PKT_FLAG_KEY);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2011-10-09 15:04:38 +02:00
|
|
|
preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
pts = pkt->pts;
|
|
|
|
dts = pkt->dts;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2013-01-04 19:44:27 +01:00
|
|
|
if (s->last_scr == AV_NOPTS_VALUE) {
|
2013-01-04 20:28:45 +01:00
|
|
|
if (dts == AV_NOPTS_VALUE || (dts < preload && ctx->avoid_negative_ts) || s->is_dvd) {
|
2013-01-04 19:50:48 +01:00
|
|
|
if (dts != AV_NOPTS_VALUE)
|
|
|
|
s->preload += av_rescale(-dts, AV_TIME_BASE, 90000);
|
2013-01-04 19:44:27 +01:00
|
|
|
s->last_scr = 0;
|
|
|
|
} else {
|
2013-01-04 20:28:45 +01:00
|
|
|
s->last_scr = dts - preload;
|
|
|
|
s->preload = 0;
|
2013-01-04 19:44:27 +01:00
|
|
|
}
|
2013-01-04 20:15:11 +01:00
|
|
|
preload = av_rescale(s->preload, 90000, AV_TIME_BASE);
|
2013-01-04 20:15:56 +01:00
|
|
|
av_log(ctx, AV_LOG_DEBUG, "First SCR: %"PRId64" First DTS: %"PRId64"\n", s->last_scr, dts + preload);
|
2010-10-16 23:31:31 +02:00
|
|
|
}
|
2013-01-04 19:44:27 +01:00
|
|
|
|
|
|
|
if (dts != AV_NOPTS_VALUE) dts += preload;
|
|
|
|
if (pts != AV_NOPTS_VALUE) pts += preload;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2015-03-16 09:57:35 +01:00
|
|
|
av_log(ctx, AV_LOG_TRACE, "dts:%f pts:%f flags:%d stream:%d nopts:%d\n",
|
2012-08-21 12:40:41 +02:00
|
|
|
dts / 90000.0, pts / 90000.0, pkt->flags,
|
|
|
|
pkt->stream_index, pts != AV_NOPTS_VALUE);
|
2007-06-21 11:39:29 +02:00
|
|
|
if (!stream->premux_packet)
|
|
|
|
stream->next_packet = &stream->premux_packet;
|
2014-08-06 05:01:15 +02:00
|
|
|
*stream->next_packet =
|
|
|
|
pkt_desc = av_mallocz(sizeof(PacketDesc));
|
2016-12-21 23:41:49 +01:00
|
|
|
if (!pkt_desc)
|
|
|
|
return AVERROR(ENOMEM);
|
2014-08-06 05:01:15 +02:00
|
|
|
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;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2009-03-08 15:16:55 +01:00
|
|
|
if (av_fifo_realloc2(stream->fifo, av_fifo_size(stream->fifo) + size) < 0)
|
2008-08-19 20:49:57 +02:00
|
|
|
return -1;
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
if (s->is_dvd) {
|
|
|
|
// min VOBU length 0.4 seconds (mpucoder)
|
|
|
|
if (is_iframe &&
|
|
|
|
(s->packet_number == 0 ||
|
|
|
|
(pts - stream->vobu_start_pts >= 36000))) {
|
2009-03-08 15:16:55 +01:00
|
|
|
stream->bytes_to_iframe = av_fifo_size(stream->fifo);
|
2014-08-06 05:01:15 +02:00
|
|
|
stream->align_iframe = 1;
|
|
|
|
stream->vobu_start_pts = pts;
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-08 15:16:55 +01:00
|
|
|
av_fifo_generic_write(stream->fifo, buf, size, NULL);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (;;) {
|
|
|
|
int ret = output_packet(ctx, 0);
|
|
|
|
if (ret <= 0)
|
2007-06-21 11:39:29 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mpeg_mux_end(AVFormatContext *ctx)
|
|
|
|
{
|
|
|
|
StreamInfo *stream;
|
|
|
|
int i;
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (;;) {
|
|
|
|
int ret = output_packet(ctx, 1);
|
|
|
|
if (ret < 0)
|
2007-06-21 11:39:29 +02:00
|
|
|
return ret;
|
2014-08-06 05:01:15 +02:00
|
|
|
else if (ret == 0)
|
2007-06-21 11:39:29 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-04-27 19:45:23 +02:00
|
|
|
/* End header according to MPEG-1 systems standard. We do not write
|
2014-08-06 05:01:15 +02:00
|
|
|
* 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);
|
2007-06-21 11:39:29 +02:00
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
for (i = 0; i < ctx->nb_streams; i++) {
|
2007-06-21 11:39:29 +02:00
|
|
|
stream = ctx->streams[i]->priv_data;
|
|
|
|
|
2014-12-19 15:08:44 +01:00
|
|
|
av_assert0(av_fifo_size(stream->fifo) == 0);
|
2014-05-06 21:48:14 +02:00
|
|
|
av_fifo_freep(&stream->fifo);
|
2007-06-21 11:39:29 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-09 14:40:11 +02:00
|
|
|
#define OFFSET(x) offsetof(MpegMuxContext, x)
|
|
|
|
#define E AV_OPT_FLAG_ENCODING_PARAM
|
|
|
|
static const AVOption options[] = {
|
2014-08-08 21:31:54 +02:00
|
|
|
{ "muxrate", NULL, OFFSET(user_mux_rate), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, ((1<<22) - 1) * (8 * 50), E },
|
2014-08-06 05:01:15 +02:00
|
|
|
{ "preload", "Initial demux-decode delay in microseconds.", OFFSET(preload), AV_OPT_TYPE_INT, { .i64 = 500000 }, 0, INT_MAX, E },
|
2011-10-09 14:40:11 +02:00
|
|
|
{ NULL },
|
|
|
|
};
|
|
|
|
|
2014-08-06 05:01:15 +02:00
|
|
|
#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, \
|
2011-10-09 14:40:11 +02:00
|
|
|
};
|
|
|
|
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_MPEG1SYSTEM_MUXER
|
2011-10-09 14:40:11 +02:00
|
|
|
MPEGENC_CLASS(mpeg)
|
2011-01-25 23:03:28 +01:00
|
|
|
AVOutputFormat ff_mpeg1system_muxer = {
|
2011-07-16 22:18:12 +02:00
|
|
|
.name = "mpeg",
|
2012-07-24 03:23:48 +02:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream"),
|
2011-07-16 22:18:12 +02:00
|
|
|
.mime_type = "video/mpeg",
|
|
|
|
.extensions = "mpg,mpeg",
|
|
|
|
.priv_data_size = sizeof(MpegMuxContext),
|
2012-08-05 11:11:04 +02:00
|
|
|
.audio_codec = AV_CODEC_ID_MP2,
|
|
|
|
.video_codec = AV_CODEC_ID_MPEG1VIDEO,
|
2011-07-16 22:18:12 +02:00
|
|
|
.write_header = mpeg_mux_init,
|
|
|
|
.write_packet = mpeg_mux_write_packet,
|
|
|
|
.write_trailer = mpeg_mux_end,
|
2011-10-09 14:40:11 +02:00
|
|
|
.priv_class = &mpeg_class,
|
2007-06-21 11:39:29 +02:00
|
|
|
};
|
|
|
|
#endif
|
2014-08-06 05:01:15 +02:00
|
|
|
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_MPEG1VCD_MUXER
|
2011-10-09 14:40:11 +02:00
|
|
|
MPEGENC_CLASS(vcd)
|
2011-01-25 23:03:28 +01:00
|
|
|
AVOutputFormat ff_mpeg1vcd_muxer = {
|
2011-07-16 22:18:12 +02:00
|
|
|
.name = "vcd",
|
2012-07-24 03:23:48 +02:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 Systems / MPEG program stream (VCD)"),
|
2011-07-16 22:18:12 +02:00
|
|
|
.mime_type = "video/mpeg",
|
|
|
|
.priv_data_size = sizeof(MpegMuxContext),
|
2012-08-05 11:11:04 +02:00
|
|
|
.audio_codec = AV_CODEC_ID_MP2,
|
|
|
|
.video_codec = AV_CODEC_ID_MPEG1VIDEO,
|
2011-07-16 22:18:12 +02:00
|
|
|
.write_header = mpeg_mux_init,
|
|
|
|
.write_packet = mpeg_mux_write_packet,
|
|
|
|
.write_trailer = mpeg_mux_end,
|
2011-10-09 14:40:11 +02:00
|
|
|
.priv_class = &vcd_class,
|
2007-06-21 11:39:29 +02:00
|
|
|
};
|
|
|
|
#endif
|
2014-08-06 05:01:15 +02:00
|
|
|
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_MPEG2VOB_MUXER
|
2011-10-09 14:40:11 +02:00
|
|
|
MPEGENC_CLASS(vob)
|
2011-01-25 23:03:28 +01:00
|
|
|
AVOutputFormat ff_mpeg2vob_muxer = {
|
2011-07-16 22:18:12 +02:00
|
|
|
.name = "vob",
|
2012-07-24 23:51:41 +02:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (VOB)"),
|
2011-07-16 22:18:12 +02:00
|
|
|
.mime_type = "video/mpeg",
|
|
|
|
.extensions = "vob",
|
|
|
|
.priv_data_size = sizeof(MpegMuxContext),
|
2012-08-05 11:11:04 +02:00
|
|
|
.audio_codec = AV_CODEC_ID_MP2,
|
|
|
|
.video_codec = AV_CODEC_ID_MPEG2VIDEO,
|
2011-07-16 22:18:12 +02:00
|
|
|
.write_header = mpeg_mux_init,
|
|
|
|
.write_packet = mpeg_mux_write_packet,
|
|
|
|
.write_trailer = mpeg_mux_end,
|
2011-10-09 14:40:11 +02:00
|
|
|
.priv_class = &vob_class,
|
2007-06-21 11:39:29 +02:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Same as mpeg2vob_mux except that the pack size is 2324 */
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_MPEG2SVCD_MUXER
|
2011-10-09 14:40:11 +02:00
|
|
|
MPEGENC_CLASS(svcd)
|
2011-01-25 23:03:28 +01:00
|
|
|
AVOutputFormat ff_mpeg2svcd_muxer = {
|
2011-07-16 22:18:12 +02:00
|
|
|
.name = "svcd",
|
2012-07-24 03:23:48 +02:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (SVCD)"),
|
2011-07-16 22:18:12 +02:00
|
|
|
.mime_type = "video/mpeg",
|
|
|
|
.extensions = "vob",
|
|
|
|
.priv_data_size = sizeof(MpegMuxContext),
|
2012-08-05 11:11:04 +02:00
|
|
|
.audio_codec = AV_CODEC_ID_MP2,
|
|
|
|
.video_codec = AV_CODEC_ID_MPEG2VIDEO,
|
2011-07-16 22:18:12 +02:00
|
|
|
.write_header = mpeg_mux_init,
|
|
|
|
.write_packet = mpeg_mux_write_packet,
|
|
|
|
.write_trailer = mpeg_mux_end,
|
2011-10-09 14:40:11 +02:00
|
|
|
.priv_class = &svcd_class,
|
2007-06-21 11:39:29 +02:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
|
2009-01-14 00:44:16 +01:00
|
|
|
#if CONFIG_MPEG2DVD_MUXER
|
2011-10-09 14:40:11 +02:00
|
|
|
MPEGENC_CLASS(dvd)
|
2011-01-25 23:03:28 +01:00
|
|
|
AVOutputFormat ff_mpeg2dvd_muxer = {
|
2011-07-16 22:18:12 +02:00
|
|
|
.name = "dvd",
|
2012-07-24 23:51:41 +02:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS (DVD VOB)"),
|
2011-07-16 22:18:12 +02:00
|
|
|
.mime_type = "video/mpeg",
|
|
|
|
.extensions = "dvd",
|
|
|
|
.priv_data_size = sizeof(MpegMuxContext),
|
2012-08-05 11:11:04 +02:00
|
|
|
.audio_codec = AV_CODEC_ID_MP2,
|
|
|
|
.video_codec = AV_CODEC_ID_MPEG2VIDEO,
|
2011-07-16 22:18:12 +02:00
|
|
|
.write_header = mpeg_mux_init,
|
|
|
|
.write_packet = mpeg_mux_write_packet,
|
|
|
|
.write_trailer = mpeg_mux_end,
|
2011-10-09 14:40:11 +02:00
|
|
|
.priv_class = &dvd_class,
|
2007-06-21 11:39:29 +02:00
|
|
|
};
|
|
|
|
#endif
|