ffmpeg.c File Reference

#include "config.h"
#include <ctype.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <errno.h>
#include <signal.h>
#include <limits.h>
#include "libavformat/avformat.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
#include "libavformat/framehook.h"
#include "libavcodec/opt.h"
#include "libavutil/fifo.h"
#include "libavutil/avstring.h"
#include "libavformat/os_support.h"
#include <time.h>
#include "cmdutils.h"
#include <assert.h>

Go to the source code of this file.

Data Structures
struct	AVStreamMap
struct	AVMetaDataMap
struct	AVOutputStream
struct	AVInputStream
struct	AVInputFile
Defines
#define	MAX_FILES   20
#define	QSCALE_NONE   -99999
#define	DEFAULT_PASS_LOGFILENAME   "ffmpeg2pass"
#define	MAX_AUDIO_PACKET_SIZE   (128 * 1024)
#define	AV_DELAY_MAX   0.100
#define	SCALEBITS   10
#define	ONE_HALF   (1 << (SCALEBITS - 1))
#define	FIX(x)   ((int) ((x) * (1<<SCALEBITS) + 0.5))
#define	RGB_TO_Y(r, g, b)
#define	RGB_TO_U(r1, g1, b1, shift)
#define	RGB_TO_V(r1, g1, b1, shift)
Functions
static void	term_exit (void)
static void	sigterm_handler (int sig)
static void	term_init (void)
static int	read_key (void)
static int	decode_interrupt_cb (void)
static int	av_exit (int ret)
static int	read_ffserver_streams (AVFormatContext *s, const char *filename)
static double	get_sync_ipts (const AVOutputStream *ost)
static void	write_frame (AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
static void	do_audio_out (AVFormatContext *s, AVOutputStream *ost, AVInputStream *ist, unsigned char *buf, int size)
static void	pre_process_video_frame (AVInputStream *ist, AVPicture *picture, void **bufp)
static void	do_subtitle_out (AVFormatContext *s, AVOutputStream *ost, AVInputStream *ist, AVSubtitle *sub, int64_t pts)
static void	do_video_out (AVFormatContext *s, AVOutputStream *ost, AVInputStream *ist, AVFrame *in_picture, int *frame_size)
static double	psnr (double d)
static void	do_video_stats (AVFormatContext *os, AVOutputStream *ost, int frame_size)
static void	print_report (AVFormatContext **output_files, AVOutputStream **ost_table, int nb_ostreams, int is_last_report)
static int	output_packet (AVInputStream *ist, int ist_index, AVOutputStream **ost_table, int nb_ostreams, const AVPacket *pkt)
static void	print_sdp (AVFormatContext **avc, int n)
static int	stream_index_from_inputs (AVFormatContext **input_files, int nb_input_files, AVInputFile *file_table, AVInputStream **ist_table, enum CodecType type, int programid)
static int	av_encode (AVFormatContext **output_files, int nb_output_files, AVFormatContext **input_files, int nb_input_files, AVStreamMap *stream_maps, int nb_stream_maps)
static void	opt_format (const char *arg)
static int	opt_default (const char *opt, const char *arg)
static void	opt_video_rc_override_string (const char *arg)
static int	opt_me_threshold (const char *opt, const char *arg)
static int	opt_verbose (const char *opt, const char *arg)
static void	opt_frame_rate (const char *arg)
static int	opt_bitrate (const char *opt, const char *arg)
static void	opt_frame_crop_top (const char *arg)
static void	opt_frame_crop_bottom (const char *arg)
static void	opt_frame_crop_left (const char *arg)
static void	opt_frame_crop_right (const char *arg)
static void	opt_frame_size (const char *arg)
static void	opt_pad_color (const char *arg)
static void	opt_frame_pad_top (const char *arg)
static void	opt_frame_pad_bottom (const char *arg)
static void	opt_frame_pad_left (const char *arg)
static void	opt_frame_pad_right (const char *arg)
static void	list_pix_fmts (void)
static void	opt_frame_pix_fmt (const char *arg)
static void	opt_frame_aspect_ratio (const char *arg)
static void	opt_qscale (const char *arg)
static void	opt_top_field_first (const char *arg)
static int	opt_thread_count (const char *opt, const char *arg)
static int	opt_audio_rate (const char *opt, const char *arg)
static int	opt_audio_channels (const char *opt, const char *arg)
static void	opt_video_channel (const char *arg)
static void	opt_video_standard (const char *arg)
static void	opt_codec (int *pstream_copy, char **pcodec_name, int codec_type, const char *arg)
static void	opt_audio_codec (const char *arg)
static void	opt_audio_tag (const char *arg)
static void	opt_video_tag (const char *arg)
static void	opt_video_codec (const char *arg)
static void	opt_subtitle_codec (const char *arg)
static void	opt_map (const char *arg)
static void	opt_map_meta_data (const char *arg)
static void	opt_input_ts_scale (const char *arg)
static int	opt_recording_time (const char *opt, const char *arg)
static int	opt_start_time (const char *opt, const char *arg)
static int	opt_rec_timestamp (const char *opt, const char *arg)
static int	opt_input_ts_offset (const char *opt, const char *arg)
static enum CodecID	find_codec_or_die (const char *name, int type, int encoder)
static void	set_context_opts (void *ctx, void *opts_ctx, int flags)
static void	opt_input_file (const char *filename)
static void	check_audio_video_sub_inputs (int *has_video_ptr, int *has_audio_ptr, int *has_subtitle_ptr)
static void	new_video_stream (AVFormatContext *oc)
static void	new_audio_stream (AVFormatContext *oc)
static void	new_subtitle_stream (AVFormatContext *oc)
static void	opt_new_audio_stream (void)
static void	opt_new_video_stream (void)
static void	opt_new_subtitle_stream (void)
static void	opt_output_file (const char *filename)
static void	opt_pass (const char *pass_str)
static int64_t	getutime (void)
static void	parse_matrix_coeffs (uint16_t *dest, const char *str)
static void	opt_inter_matrix (const char *arg)
static void	opt_intra_matrix (const char *arg)
static void	log_callback_help (void *ptr, int level, const char *fmt, va_list vl)
static void	show_help (void)
static void	opt_target (const char *arg)
static void	opt_vstats_file (const char *arg)
static void	opt_vstats (void)
static int	opt_bsf (const char *opt, const char *arg)
static int	opt_preset (const char *opt, const char *arg)
int	main (int argc, char **argv)
Variables
const char	program_name [] = "FFmpeg"
const int	program_birth_year = 2000
static const OptionDef	options []
static AVFormatContext *	input_files [MAX_FILES]
static int64_t	input_files_ts_offset [MAX_FILES]
static double	input_files_ts_scale [MAX_FILES][MAX_STREAMS]
static int	nb_input_files = 0
static AVFormatContext *	output_files [MAX_FILES]
static int	nb_output_files = 0
static AVStreamMap	stream_maps [MAX_FILES]
static int	nb_stream_maps
static AVMetaDataMap	meta_data_maps [MAX_FILES]
static int	nb_meta_data_maps
static AVInputFormat *	file_iformat
static AVOutputFormat *	file_oformat
static int	frame_width = 0
static int	frame_height = 0
static float	frame_aspect_ratio = 0
static enum PixelFormat	frame_pix_fmt = PIX_FMT_NONE
static int	frame_padtop = 0
static int	frame_padbottom = 0
static int	frame_padleft = 0
static int	frame_padright = 0
static int	padcolor [3] = {16,128,128}
static int	frame_topBand = 0
static int	frame_bottomBand = 0
static int	frame_leftBand = 0
static int	frame_rightBand = 0
static int	max_frames [4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX}
static AVRational	frame_rate
static float	video_qscale = 0
static uint16_t *	intra_matrix = NULL
static uint16_t *	inter_matrix = NULL
static const char *	video_rc_override_string = NULL
static int	video_disable = 0
static int	video_discard = 0
static char *	video_codec_name = NULL
static int	video_codec_tag = 0
static int	same_quality = 0
static int	do_deinterlace = 0
static int	top_field_first = -1
static int	me_threshold = 0
static int	intra_dc_precision = 8
static int	loop_input = 0
static int	loop_output = AVFMT_NOOUTPUTLOOP
static int	qp_hist = 0
static int	intra_only = 0
static int	audio_sample_rate = 44100
static float	audio_qscale = QSCALE_NONE
static int	audio_disable = 0
static int	audio_channels = 1
static char *	audio_codec_name = NULL
static int	audio_codec_tag = 0
static char *	audio_language = NULL
static int	subtitle_disable = 0
static char *	subtitle_codec_name = NULL
static char *	subtitle_language = NULL
static float	mux_preload = 0.5
static float	mux_max_delay = 0.7
static int64_t	recording_time = INT64_MAX
static int64_t	start_time = 0
static int64_t	rec_timestamp = 0
static int64_t	input_ts_offset = 0
static int	file_overwrite = 0
static char *	str_title = NULL
static char *	str_author = NULL
static char *	str_copyright = NULL
static char *	str_comment = NULL
static char *	str_genre = NULL
static char *	str_album = NULL
static int	do_benchmark = 0
static int	do_hex_dump = 0
static int	do_pkt_dump = 0
static int	do_psnr = 0
static int	do_pass = 0
static char *	pass_logfilename = NULL
static int	audio_stream_copy = 0
static int	video_stream_copy = 0
static int	subtitle_stream_copy = 0
static int	video_sync_method = -1
static int	audio_sync_method = 0
static float	audio_drift_threshold = 0.1
static int	copy_ts = 0
static int	opt_shortest = 0
static int	video_global_header = 0
static char *	vstats_filename
static FILE *	vstats_file
static int	opt_programid = 0
static int	rate_emu = 0
static int	video_channel = 0
static char *	video_standard
static int	audio_volume = 256
static int	using_stdin = 0
static int	using_vhook = 0
static int	verbose = 1
static int	thread_count = 1
static int	q_pressed = 0
static int64_t	video_size = 0
static int64_t	audio_size = 0
static int64_t	extra_size = 0
static int	nb_frames_dup = 0
static int	nb_frames_drop = 0
static int	input_sync
static uint64_t	limit_filesize = 0
static int	pgmyuv_compatibility_hack = 0
static float	dts_delta_threshold = 10
static unsigned int	sws_flags = SWS_BICUBIC
static const char **	opt_names
static int	opt_name_count
static AVCodecContext *	avctx_opts [CODEC_TYPE_NB]
static AVFormatContext *	avformat_opts
static struct SwsContext *	sws_opts
static int64_t	timer_start
static AVBitStreamFilterContext *	video_bitstream_filters = NULL
static AVBitStreamFilterContext *	audio_bitstream_filters = NULL
static AVBitStreamFilterContext *	subtitle_bitstream_filters = NULL
static AVBitStreamFilterContext *	bitstream_filters [MAX_FILES][MAX_STREAMS]
static volatile sig_atomic_t	received_sigterm = 0
static int	bit_buffer_size = 1024*256
static uint8_t *	bit_buffer = NULL
static const OptionDef	options []

---

Define Documentation

#define AV_DELAY_MAX   0.100

Definition at line 721 of file ffmpeg.c.

#define DEFAULT_PASS_LOGFILENAME   "ffmpeg2pass"

Definition at line 223 of file ffmpeg.c.

#define FIX

(

x

)

((int) ((x) * (1<<SCALEBITS) + 0.5))

Definition at line 2372 of file ffmpeg.c.

Referenced by C_JPEG_TO_CCIR(), idct32(), and rgb24_to_yuv420p().

#define MAX_AUDIO_PACKET_SIZE   (128 * 1024)

Definition at line 504 of file ffmpeg.c.

Referenced by do_audio_out().

#define MAX_FILES   20

Definition at line 84 of file ffmpeg.c.

#define ONE_HALF   (1 << (SCALEBITS - 1))

Definition at line 2371 of file ffmpeg.c.

Referenced by C_JPEG_TO_CCIR(), and rgb24_to_yuv420p().

#define QSCALE_NONE   -99999

Definition at line 141 of file ffmpeg.c.

Referenced by new_audio_stream().

#define RGB_TO_U	(	r1,
		g1,
		b1,
		shift		)

Value:

(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)

Definition at line 2378 of file ffmpeg.c.

Referenced by opt_pad_color().

#define RGB_TO_V	(	r1,
		g1,
		b1,
		shift		)

Value:

(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)

Definition at line 2382 of file ffmpeg.c.

Referenced by opt_pad_color().

#define RGB_TO_Y	(	r,
		g,
		b		)

Value:

((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)

Definition at line 2374 of file ffmpeg.c.

Referenced by opt_pad_color().

#define SCALEBITS   10

Definition at line 2370 of file ffmpeg.c.

Referenced by C_JPEG_TO_CCIR(), and rgb24_to_yuv420p().

---

Function Documentation

static int av_encode	(	AVFormatContext **	output_files,
		int	nb_output_files,
		AVFormatContext **	input_files,
		int	nb_input_files,
		AVStreamMap *	stream_maps,
		int	nb_stream_maps
	)			[static]

Definition at line 1483 of file ffmpeg.c.

References av_gettime(), av_mallocz(), AVStream::codec, AVInputStream::discard, AVInputStream::file_index, AVInputStream::frame, AVInputStream::index, input_files, AVInputFile::ist_index, AVFormatContext::nb_streams, AVInputFile::nb_streams, NULL, AVCodecContext::rate_emu, AVInputStream::st, AVInputStream::start, and AVFormatContext::streams.

Referenced by main().

{
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
    AVFormatContext *is, *os;
    AVCodecContext *codec, *icodec;
    AVOutputStream *ost, **ost_table = NULL;
    AVInputStream *ist, **ist_table = NULL;
    AVInputFile *file_table;
    int key;
    int want_sdp = 1;

    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
    if (!file_table)
        goto fail;

    /* input stream init */
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        file_table[i].ist_index = j;
        file_table[i].nb_streams = is->nb_streams;
        j += is->nb_streams;
    }
    nb_istreams = j;

    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
    if (!ist_table)
        goto fail;

    for(i=0;i<nb_istreams;i++) {
        ist = av_mallocz(sizeof(AVInputStream));
        if (!ist)
            goto fail;
        ist_table[i] = ist;
    }
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        for(k=0;k<is->nb_streams;k++) {
            ist = ist_table[j++];
            ist->st = is->streams[k];
            ist->file_index = i;
            ist->index = k;
            ist->discard = 1; /* the stream is discarded by default
                                 (changed later) */

            if (ist->st->codec->rate_emu) {
                ist->start = av_gettime();
                ist->frame = 0;
            }
        }
    }

    /* output stream init */
    nb_ostreams = 0;
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
        if (!os->nb_streams) {
            fprintf(stderr, "Output file does not contain any stream\n");
            av_exit(1);
        }
        nb_ostreams += os->nb_streams;
    }
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
        av_exit(1);
    }

    /* Sanity check the mapping args -- do the input files & streams exist? */
    for(i=0;i<nb_stream_maps;i++) {
        int fi = stream_maps[i].file_index;
        int si = stream_maps[i].stream_index;

        if (fi < 0 || fi > nb_input_files - 1 ||
            si < 0 || si > file_table[fi].nb_streams - 1) {
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
            av_exit(1);
        }
        fi = stream_maps[i].sync_file_index;
        si = stream_maps[i].sync_stream_index;
        if (fi < 0 || fi > nb_input_files - 1 ||
            si < 0 || si > file_table[fi].nb_streams - 1) {
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
            av_exit(1);
        }
    }

    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
    if (!ost_table)
        goto fail;
    for(i=0;i<nb_ostreams;i++) {
        ost = av_mallocz(sizeof(AVOutputStream));
        if (!ost)
            goto fail;
        ost_table[i] = ost;
    }

    n = 0;
    for(k=0;k<nb_output_files;k++) {
        os = output_files[k];
        for(i=0;i<os->nb_streams;i++) {
            int found;
            ost = ost_table[n++];
            ost->file_index = k;
            ost->index = i;
            ost->st = os->streams[i];
            if (nb_stream_maps > 0) {
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
                    stream_maps[n-1].stream_index;

                /* Sanity check that the stream types match */
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
                        ost->file_index, ost->index);
                    av_exit(1);
                }

            } else {
                if(opt_programid) {
                    found = 0;
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
                    if(j != -1) {
                        ost->source_index = j;
                        found = 1;
                    }
                } else {
                    /* get corresponding input stream index : we select the first one with the right type */
                    found = 0;
                    for(j=0;j<nb_istreams;j++) {
                        ist = ist_table[j];
                        if (ist->discard &&
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
                            ost->source_index = j;
                            found = 1;
                            break;
                        }
                    }
                }

                if (!found) {
                    if(! opt_programid) {
                        /* try again and reuse existing stream */
                        for(j=0;j<nb_istreams;j++) {
                            ist = ist_table[j];
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
                                ost->source_index = j;
                                found = 1;
                            }
                        }
                    }
                    if (!found) {
                        int i= ost->file_index;
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
                                ost->file_index, ost->index);
                        av_exit(1);
                    }
                }
            }
            ist = ist_table[ost->source_index];
            ist->discard = 0;
            ost->sync_ist = (nb_stream_maps > 0) ?
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
                         stream_maps[n-1].sync_stream_index] : ist;
        }
    }

    /* for each output stream, we compute the right encoding parameters */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        os = output_files[ost->file_index];
        ist = ist_table[ost->source_index];

        codec = ost->st->codec;
        icodec = ist->st->codec;

        if (!ost->st->language[0])
            av_strlcpy(ost->st->language, ist->st->language,
                       sizeof(ost->st->language));

        ost->st->disposition = ist->st->disposition;

        if (ost->st->stream_copy) {
            /* if stream_copy is selected, no need to decode or encode */
            codec->codec_id = icodec->codec_id;
            codec->codec_type = icodec->codec_type;

            if(!codec->codec_tag){
                if(   !os->oformat->codec_tag
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
                    codec->codec_tag = icodec->codec_tag;
            }

            codec->bit_rate = icodec->bit_rate;
            codec->extradata= icodec->extradata;
            codec->extradata_size= icodec->extradata_size;
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
                codec->time_base = icodec->time_base;
            else
                codec->time_base = ist->st->time_base;
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
                if(audio_volume != 256) {
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
                    av_exit(1);
                }
                codec->sample_rate = icodec->sample_rate;
                codec->channels = icodec->channels;
                codec->frame_size = icodec->frame_size;
                codec->block_align= icodec->block_align;
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
                    codec->block_align= 0;
                if(codec->codec_id == CODEC_ID_AC3)
                    codec->block_align= 0;
                break;
            case CODEC_TYPE_VIDEO:
                if(using_vhook) {
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
                    av_exit(1);
                }
                codec->pix_fmt = icodec->pix_fmt;
                codec->width = icodec->width;
                codec->height = icodec->height;
                codec->has_b_frames = icodec->has_b_frames;
                break;
            case CODEC_TYPE_SUBTITLE:
                break;
            default:
                abort();
            }
        } else {
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
                if (av_fifo_init(&ost->fifo, 1024))
                    goto fail;
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
                icodec->request_channels = codec->channels;
                ist->decoding_needed = 1;
                ost->encoding_needed = 1;
                break;
            case CODEC_TYPE_VIDEO:
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
                ost->video_resample = ((codec->width != icodec->width -
                                (frame_leftBand + frame_rightBand) +
                                (frame_padleft + frame_padright)) ||
                        (codec->height != icodec->height -
                                (frame_topBand  + frame_bottomBand) +
                                (frame_padtop + frame_padbottom)) ||
                        (codec->pix_fmt != icodec->pix_fmt));
                if (ost->video_crop) {
                    ost->topBand = frame_topBand;
                    ost->leftBand = frame_leftBand;
                }
                if (ost->video_pad) {
                    ost->padtop = frame_padtop;
                    ost->padleft = frame_padleft;
                    ost->padbottom = frame_padbottom;
                    ost->padright = frame_padright;
                    if (!ost->video_resample) {
                        avcodec_get_frame_defaults(&ost->pict_tmp);
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
                                         codec->width, codec->height))
                            goto fail;
                    }
                }
                if (ost->video_resample) {
                    avcodec_get_frame_defaults(&ost->pict_tmp);
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
                                         codec->width, codec->height)) {
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
                        av_exit(1);
                    }
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
                    ost->img_resample_ctx = sws_getContext(
                            icodec->width - (frame_leftBand + frame_rightBand),
                            icodec->height - (frame_topBand + frame_bottomBand),
                            icodec->pix_fmt,
                            codec->width - (frame_padleft + frame_padright),
                            codec->height - (frame_padtop + frame_padbottom),
                            codec->pix_fmt,
                            sws_flags, NULL, NULL, NULL);
                    if (ost->img_resample_ctx == NULL) {
                        fprintf(stderr, "Cannot get resampling context\n");
                        av_exit(1);
                    }
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
                }
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
                break;
            case CODEC_TYPE_SUBTITLE:
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
                break;
            default:
                abort();
                break;
            }
            /* two pass mode */
            if (ost->encoding_needed &&
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                char logfilename[1024];
                FILE *f;
                int size;
                char *logbuffer;

                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
                         pass_logfilename ?
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
                if (codec->flags & CODEC_FLAG_PASS1) {
                    f = fopen(logfilename, "w");
                    if (!f) {
                        perror(logfilename);
                        av_exit(1);
                    }
                    ost->logfile = f;
                } else {
                    /* read the log file */
                    f = fopen(logfilename, "r");
                    if (!f) {
                        perror(logfilename);
                        av_exit(1);
                    }
                    fseek(f, 0, SEEK_END);
                    size = ftell(f);
                    fseek(f, 0, SEEK_SET);
                    logbuffer = av_malloc(size + 1);
                    if (!logbuffer) {
                        fprintf(stderr, "Could not allocate log buffer\n");
                        av_exit(1);
                    }
                    size = fread(logbuffer, 1, size, f);
                    fclose(f);
                    logbuffer[size] = '\0';
                    codec->stats_in = logbuffer;
                }
            }
        }
        if(codec->