@@ -12,6 +12,7 @@ doc/*.html

 doc/*.pod

 doxy

 ffmpeg

+avconv

 avplay

 avprobe

 avserver

@@ -53,6 +53,7 @@ COMPILE_S = $(call COMPILE,AS)

 %.c %.h: TAG = GEN

 PROGS-$(CONFIG_FFMPEG)   += ffmpeg

+PROGS-$(CONFIG_AVCONV)   += avconv

 PROGS-$(CONFIG_AVPLAY)   += avplay

 PROGS-$(CONFIG_AVPROBE)  += avprobe

 PROGS-$(CONFIG_AVSERVER) += avserver

@@ -64,7 +65,7 @@ HOSTPROGS  := $(TESTTOOLS:%=tests/%)

 TOOLS       = qt-faststart trasher

 TOOLS-$(CONFIG_ZLIB) += cws2fws

-BASENAMES   = ffmpeg avplay avprobe avserver

+BASENAMES   = ffmpeg avconv avplay avprobe avserver

 ALLPROGS    = $(BASENAMES:%=%$(EXESUF))

 ALLMANPAGES = $(BASENAMES:%=%.1)

new file mode 100644

@@ -0,0 +1,4428 @@

+/*

+ * avconv main

+ * Copyright (c) 2000-2011 The libav developers.

+ *

+ * This file is part of Libav.

+ *

+ * Libav 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.

+ *

+ * Libav 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 Libav; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#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 <unistd.h>

+#include "libavformat/avformat.h"

+#include "libavdevice/avdevice.h"

+#include "libswscale/swscale.h"

+#include "libavutil/opt.h"

+#include "libavcodec/audioconvert.h"

+#include "libavutil/audioconvert.h"

+#include "libavutil/parseutils.h"

+#include "libavutil/samplefmt.h"

+#include "libavutil/colorspace.h"

+#include "libavutil/fifo.h"

+#include "libavutil/intreadwrite.h"

+#include "libavutil/dict.h"

+#include "libavutil/mathematics.h"

+#include "libavutil/pixdesc.h"

+#include "libavutil/avstring.h"

+#include "libavutil/libm.h"

+#include "libavformat/os_support.h"

+

+#if CONFIG_AVFILTER

+# include "libavfilter/avfilter.h"

+# include "libavfilter/avfiltergraph.h"

+# include "libavfilter/vsrc_buffer.h"

+#endif

+

+#if HAVE_SYS_RESOURCE_H

+#include <sys/types.h>

+#include <sys/time.h>

+#include <sys/resource.h>

+#elif HAVE_GETPROCESSTIMES

+#include <windows.h>

+#endif

+#if HAVE_GETPROCESSMEMORYINFO

+#include <windows.h>

+#include <psapi.h>

+#endif

+

+#if HAVE_SYS_SELECT_H

+#include <sys/select.h>

+#endif

+

+#include <time.h>

+

+#include "cmdutils.h"

+

+#include "libavutil/avassert.h"

+

+const char program_name[] = "avconv";

+const int program_birth_year = 2000;

+

+/* select an input stream for an output stream */

+typedef struct StreamMap {

+    int file_index;

+    int stream_index;

+    int sync_file_index;

+    int sync_stream_index;

+} StreamMap;

+

+/**

+ * select an input file for an output file

+ */

+typedef struct MetadataMap {

+    int  file;      //< file index

+    char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram

+    int  index;     //< stream/chapter/program number

+} MetadataMap;

+

+typedef struct ChapterMap {

+    int in_file;

+    int out_file;

+} ChapterMap;

+

+static const OptionDef options[];

+

+#define MAX_FILES 100

+

+static const char *last_asked_format = NULL;

+static double *ts_scale;

+static int  nb_ts_scale;

+

+static AVFormatContext *output_files[MAX_FILES];

+static AVDictionary *output_opts[MAX_FILES];

+static int nb_output_files = 0;

+

+static StreamMap *stream_maps = NULL;

+static int nb_stream_maps;

+

+/* first item specifies output metadata, second is input */

+static MetadataMap (*meta_data_maps)[2] = NULL;

+static int nb_meta_data_maps;

+static int metadata_global_autocopy   = 1;

+static int metadata_streams_autocopy  = 1;

+static int metadata_chapters_autocopy = 1;

+

+static ChapterMap *chapter_maps = NULL;

+static int nb_chapter_maps;

+

+/* indexed by output file stream index */

+static int *streamid_map = NULL;

+static int nb_streamid_map = 0;

+

+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 enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;

+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 unsigned int video_codec_tag = 0;

+static char *video_language = NULL;

+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;

+#if CONFIG_AVFILTER

+static char *vfilters = NULL;

+#endif

+

+static int intra_only = 0;

+static int audio_sample_rate = 0;

+#define QSCALE_NONE -99999

+static float audio_qscale = QSCALE_NONE;

+static int audio_disable = 0;

+static int audio_channels = 0;

+static char  *audio_codec_name = NULL;

+static unsigned 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 unsigned int subtitle_codec_tag = 0;

+

+static int data_disable = 0;

+static char *data_codec_name = NULL;

+static unsigned int data_codec_tag = 0;

+

+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 input_ts_offset = 0;

+static int file_overwrite = 0;

+static AVDictionary *metadata;

+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_prefix = NULL;

+static int audio_stream_copy = 0;

+static int video_stream_copy = 0;

+static int subtitle_stream_copy = 0;

+static int data_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 copy_tb;

+static int opt_shortest = 0;

+static char *vstats_filename;

+static FILE *vstats_file;

+static int opt_programid = 0;

+static int copy_initial_nonkeyframes = 0;

+

+static int rate_emu = 0;

+

+static int audio_volume = 256;

+

+static int exit_on_error = 0;

+static int using_stdin = 0;

+static int verbose = 1;

+static int thread_count= 1;

+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 force_fps = 0;

+static char *forced_key_frames = NULL;

+

+static float dts_delta_threshold = 10;

+

+static int64_t timer_start;

+

+static uint8_t *audio_buf;

+static uint8_t *audio_out;

+static unsigned int allocated_audio_out_size, allocated_audio_buf_size;

+

+static short *samples;

+

+static AVBitStreamFilterContext *video_bitstream_filters=NULL;

+static AVBitStreamFilterContext *audio_bitstream_filters=NULL;

+static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;

+

+#define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"

+

+struct InputStream;

+

+typedef struct OutputStream {

+    int file_index;          /* file index */

+    int index;               /* stream index in the output file */

+    int source_index;        /* InputStream index */

+    AVStream *st;            /* stream in the output file */

+    int encoding_needed;     /* true if encoding needed for this stream */

+    int frame_number;

+    /* input pts and corresponding output pts

+       for A/V sync */

+    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */

+    struct InputStream *sync_ist; /* input stream to sync against */

+    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number

+    AVBitStreamFilterContext *bitstream_filters;

+    AVCodec *enc;

+

+    /* video only */

+    int video_resample;

+    AVFrame pict_tmp;      /* temporary image for resampling */

+    struct SwsContext *img_resample_ctx; /* for image resampling */

+    int resample_height;

+    int resample_width;

+    int resample_pix_fmt;

+    AVRational frame_rate;

+

+    float frame_aspect_ratio;

+

+    /* forced key frames */

+    int64_t *forced_kf_pts;

+    int forced_kf_count;

+    int forced_kf_index;

+

+    /* audio only */

+    int audio_resample;

+    ReSampleContext *resample; /* for audio resampling */

+    int resample_sample_fmt;

+    int resample_channels;

+    int resample_sample_rate;

+    int reformat_pair;

+    AVAudioConvert *reformat_ctx;

+    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */

+    FILE *logfile;

+

+#if CONFIG_AVFILTER

+    AVFilterContext *output_video_filter;

+    AVFilterContext *input_video_filter;

+    AVFilterBufferRef *picref;

+    char *avfilter;

+    AVFilterGraph *graph;

+#endif

+

+   int sws_flags;

+   AVDictionary *opts;

+} OutputStream;

+

+static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };

+static int nb_output_streams_for_file[MAX_FILES] = { 0 };

+

+typedef struct InputStream {

+    int file_index;

+    AVStream *st;

+    int discard;             /* true if stream data should be discarded */

+    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */

+    AVCodec *dec;

+

+    int64_t       start;     /* time when read started */

+    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts

+                                is not defined */

+    int64_t       pts;       /* current pts */

+    PtsCorrectionContext pts_ctx;

+    double ts_scale;

+    int is_start;            /* is 1 at the start and after a discontinuity */

+    int showed_multi_packet_warning;

+    int is_past_recording_time;

+    AVDictionary *opts;

+} InputStream;

+

+typedef struct InputFile {

+    AVFormatContext *ctx;

+    int eof_reached;      /* true if eof reached */

+    int ist_index;        /* index of first stream in ist_table */

+    int buffer_size;      /* current total buffer size */

+    int64_t ts_offset;

+} InputFile;

+

+static InputStream *input_streams = NULL;

+static int         nb_input_streams = 0;

+static InputFile   *input_files   = NULL;

+static int         nb_input_files   = 0;

+

+#if CONFIG_AVFILTER

+

+static int configure_video_filters(InputStream *ist, OutputStream *ost)

+{

+    AVFilterContext *last_filter, *filter;

+    /** filter graph containing all filters including input & output */

+    AVCodecContext *codec = ost->st->codec;

+    AVCodecContext *icodec = ist->st->codec;

+    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };

+    AVRational sample_aspect_ratio;

+    char args[255];

+    int ret;

+

+    ost->graph = avfilter_graph_alloc();

+

+    if (ist->st->sample_aspect_ratio.num){

+        sample_aspect_ratio = ist->st->sample_aspect_ratio;

+    }else

+        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;

+

+    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,

+             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,

+             sample_aspect_ratio.num, sample_aspect_ratio.den);

+

+    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),

+                                       "src", args, NULL, ost->graph);

+    if (ret < 0)

+        return ret;

+    ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,

+                                       "out", NULL, &ffsink_ctx, ost->graph);

+    if (ret < 0)

+        return ret;

+    last_filter = ost->input_video_filter;

+

+    if (codec->width  != icodec->width || codec->height != icodec->height) {

+        snprintf(args, 255, "%d:%d:flags=0x%X",

+                 codec->width,

+                 codec->height,

+                 ost->sws_flags);

+        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),

+                                                NULL, args, NULL, ost->graph)) < 0)

+            return ret;

+        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)

+            return ret;

+        last_filter = filter;

+    }

+

+    snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);

+    ost->graph->scale_sws_opts = av_strdup(args);

+

+    if (ost->avfilter) {

+        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));

+        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));

+

+        outputs->name    = av_strdup("in");

+        outputs->filter_ctx = last_filter;

+        outputs->pad_idx = 0;

+        outputs->next    = NULL;

+

+        inputs->name    = av_strdup("out");

+        inputs->filter_ctx = ost->output_video_filter;

+        inputs->pad_idx = 0;

+        inputs->next    = NULL;

+

+        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)

+            return ret;

+        av_freep(&ost->avfilter);

+    } else {

+        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)

+            return ret;

+    }

+

+    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)

+        return ret;

+

+    codec->width  = ost->output_video_filter->inputs[0]->w;

+    codec->height = ost->output_video_filter->inputs[0]->h;

+    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =

+        ost->frame_aspect_ratio ? // overriden by the -aspect cli option

+        av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :

+        ost->output_video_filter->inputs[0]->sample_aspect_ratio;

+

+    return 0;

+}

+#endif /* CONFIG_AVFILTER */

+

+static void term_exit(void)

+{

+    av_log(NULL, AV_LOG_QUIET, "");

+}

+

+static volatile int received_sigterm = 0;

+static volatile int received_nb_signals = 0;

+

+static void

+sigterm_handler(int sig)

+{

+    received_sigterm = sig;

+    received_nb_signals++;

+    term_exit();

+}

+

+static void term_init(void)

+{

+    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */

+    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */

+#ifdef SIGXCPU

+    signal(SIGXCPU, sigterm_handler);

+#endif

+}

+

+static int decode_interrupt_cb(void)

+{

+    return received_nb_signals > 1;

+}

+

+static int exit_program(int ret)

+{

+    int i;

+

+    /* close files */

+    for(i=0;i<nb_output_files;i++) {

+        AVFormatContext *s = output_files[i];

+        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)

+            avio_close(s->pb);

+        avformat_free_context(s);

+        av_free(output_streams_for_file[i]);

+        av_dict_free(&output_opts[i]);

+    }

+    for(i=0;i<nb_input_files;i++) {

+        av_close_input_file(input_files[i].ctx);

+    }

+    for (i = 0; i < nb_input_streams; i++)

+        av_dict_free(&input_streams[i].opts);

+

+    av_free(intra_matrix);

+    av_free(inter_matrix);

+

+    if (vstats_file)

+        fclose(vstats_file);

+    av_free(vstats_filename);

+

+    av_free(streamid_map);

+    av_free(stream_maps);

+    av_free(meta_data_maps);

+

+    av_freep(&input_streams);

+    av_freep(&input_files);

+

+    av_free(video_codec_name);

+    av_free(audio_codec_name);

+    av_free(subtitle_codec_name);

+    av_free(data_codec_name);

+

+    uninit_opts();

+    av_free(audio_buf);

+    av_free(audio_out);

+    allocated_audio_buf_size= allocated_audio_out_size= 0;

+    av_free(samples);

+

+#if CONFIG_AVFILTER

+    avfilter_uninit();

+#endif

+

+    if (received_sigterm) {

+        fprintf(stderr,

+            "Received signal %d: terminating.\n",

+            (int) received_sigterm);

+        exit (255);

+    }

+

+    exit(ret); /* not all OS-es handle main() return value */

+    return ret;

+}

+

+static void assert_avoptions(AVDictionary *m)

+{

+    AVDictionaryEntry *t;

+    if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {

+        av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);

+        exit_program(1);

+    }

+}

+

+static void assert_codec_experimental(AVCodecContext *c, int encoder)

+{

+    const char *codec_string = encoder ? "encoder" : "decoder";

+    AVCodec *codec;

+    if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&

+        c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

+        av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "

+                "results.\nAdd '-strict experimental' if you want to use it.\n",

+                codec_string, c->codec->name);

+        codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);

+        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))

+            av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",

+                   codec_string, codec->name);

+        exit_program(1);

+    }

+}

+

+/* similar to ff_dynarray_add() and av_fast_realloc() */

+static void *grow_array(void *array, int elem_size, int *size, int new_size)

+{

+    if (new_size >= INT_MAX / elem_size) {

+        fprintf(stderr, "Array too big.\n");

+        exit_program(1);

+    }

+    if (*size < new_size) {

+        uint8_t *tmp = av_realloc(array, new_size*elem_size);

+        if (!tmp) {

+            fprintf(stderr, "Could not alloc buffer.\n");

+            exit_program(1);

+        }

+        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);

+        *size = new_size;

+        return tmp;

+    }

+    return array;

+}

+

+static void choose_sample_fmt(AVStream *st, AVCodec *codec)

+{

+    if(codec && codec->sample_fmts){

+        const enum AVSampleFormat *p= codec->sample_fmts;

+        for(; *p!=-1; p++){

+            if(*p == st->codec->sample_fmt)

+                break;

+        }

+        if (*p == -1) {

+            av_log(NULL, AV_LOG_WARNING,

+                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",

+                   av_get_sample_fmt_name(st->codec->sample_fmt),

+                   codec->name,

+                   av_get_sample_fmt_name(codec->sample_fmts[0]));

+            st->codec->sample_fmt = codec->sample_fmts[0];

+        }

+    }

+}

+

+/**

+ * Update the requested input sample format based on the output sample format.

+ * This is currently only used to request float output from decoders which

+ * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.

+ * Ideally this will be removed in the future when decoders do not do format

+ * conversion and only output in their native format.

+ */

+static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,

+                              AVCodecContext *enc)

+{

+    /* if sample formats match or a decoder sample format has already been

+       requested, just return */

+    if (enc->sample_fmt == dec->sample_fmt ||

+        dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)

+        return;

+

+    /* if decoder supports more than one output format */

+    if (dec_codec && dec_codec->sample_fmts &&

+        dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&

+        dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {

+        const enum AVSampleFormat *p;

+        int min_dec = -1, min_inc = -1;

+

+        /* find a matching sample format in the encoder */

+        for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {

+            if (*p == enc->sample_fmt) {

+                dec->request_sample_fmt = *p;

+                return;

+            } else if (*p > enc->sample_fmt) {

+                min_inc = FFMIN(min_inc, *p - enc->sample_fmt);

+            } else

+                min_dec = FFMIN(min_dec, enc->sample_fmt - *p);

+        }

+

+        /* if none match, provide the one that matches quality closest */

+        dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :

+                                  enc->sample_fmt - min_dec;

+    }

+}

+

+static void choose_sample_rate(AVStream *st, AVCodec *codec)

+{

+    if(codec && codec->supported_samplerates){

+        const int *p= codec->supported_samplerates;

+        int best=0;

+        int best_dist=INT_MAX;

+        for(; *p; p++){

+            int dist= abs(st->codec->sample_rate - *p);

+            if(dist < best_dist){

+                best_dist= dist;

+                best= *p;

+            }

+        }

+        if(best_dist){

+            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);

+        }

+        st->codec->sample_rate= best;

+    }

+}

+

+static void choose_pixel_fmt(AVStream *st, AVCodec *codec)

+{

+    if(codec && codec->pix_fmts){

+        const enum PixelFormat *p= codec->pix_fmts;

+        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){

+            if(st->codec->codec_id==CODEC_ID_MJPEG){

+                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};

+            }else if(st->codec->codec_id==CODEC_ID_LJPEG){

+                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};

+            }

+        }

+        for(; *p!=-1; p++){

+            if(*p == st->codec->pix_fmt)

+                break;

+        }

+        if (*p == -1) {

+            if(st->codec->pix_fmt != PIX_FMT_NONE)

+                av_log(NULL, AV_LOG_WARNING,

+                        "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",

+                        av_pix_fmt_descriptors[st->codec->pix_fmt].name,

+                        codec->name,

+                        av_pix_fmt_descriptors[codec->pix_fmts[0]].name);

+            st->codec->pix_fmt = codec->pix_fmts[0];

+        }

+    }

+}

+

+static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)

+{

+    OutputStream *ost;

+    AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);

+    int idx      = oc->nb_streams - 1;

+

+    if (!st) {

+        av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");

+        exit_program(1);

+    }

+

+    output_streams_for_file[file_idx] =

+        grow_array(output_streams_for_file[file_idx],

+                   sizeof(*output_streams_for_file[file_idx]),

+                   &nb_output_streams_for_file[file_idx],

+                   oc->nb_streams);

+    ost = output_streams_for_file[file_idx][idx] =

+        av_mallocz(sizeof(OutputStream));

+    if (!ost) {

+        fprintf(stderr, "Could not alloc output stream\n");

+        exit_program(1);

+    }

+    ost->file_index = file_idx;

+    ost->index = idx;

+    ost->st    = st;

+    ost->enc   = codec;

+    if (codec)

+        ost->opts  = filter_codec_opts(codec_opts, codec->id, 1);

+

+    avcodec_get_context_defaults3(st->codec, codec);

+

+    ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);

+    return ost;

+}

+

+static int read_avserver_streams(AVFormatContext *s, const char *filename)

+{

+    int i, err;

+    AVFormatContext *ic = NULL;

+    int nopts = 0;

+

+    err = avformat_open_input(&ic, filename, NULL, NULL);

+    if (err < 0)

+        return err;

+    /* copy stream format */

+    for(i=0;i<ic->nb_streams;i++) {

+        AVStream *st;

+        OutputStream *ost;

+        AVCodec *codec;

+

+        codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);

+        ost   = new_output_stream(s, nb_output_files, codec);

+        st    = ost->st;

+

+        // FIXME: a more elegant solution is needed

+        memcpy(st, ic->streams[i], sizeof(AVStream));

+        st->info = NULL;

+        avcodec_copy_context(st->codec, ic->streams[i]->codec);

+

+        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {

+            if (audio_stream_copy) {

+                st->stream_copy = 1;

+            } else

+                choose_sample_fmt(st, codec);

+        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {

+            if (video_stream_copy) {

+                st->stream_copy = 1;

+            } else

+                choose_pixel_fmt(st, codec);

+        }

+

+        if(st->codec->flags & CODEC_FLAG_BITEXACT)

+            nopts = 1;

+    }

+

+    av_close_input_file(ic);

+    return 0;

+}

+

+static double

+get_sync_ipts(const OutputStream *ost)

+{

+    const InputStream *ist = ost->sync_ist;

+    return (double)(ist->pts - start_time)/AV_TIME_BASE;

+}

+

+static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){

+    int ret;

+

+    while(bsfc){

+        AVPacket new_pkt= *pkt;

+        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,

+                                          &new_pkt.data, &new_pkt.size,

+                                          pkt->data, pkt->size,

+                                          pkt->flags & AV_PKT_FLAG_KEY);

+        if(a>0){

+            av_free_packet(pkt);

+            new_pkt.destruct= av_destruct_packet;

+        } else if(a<0){

+            fprintf(stderr, "%s failed for stream %d, codec %s",

+                    bsfc->filter->name, pkt->stream_index,

+                    avctx->codec ? avctx->codec->name : "copy");

+            print_error("", a);

+            if (exit_on_error)

+                exit_program(1);

+        }

+        *pkt= new_pkt;

+

+        bsfc= bsfc->next;

+    }

+

+    ret= av_interleaved_write_frame(s, pkt);

+    if(ret < 0){

+        print_error("av_interleaved_write_frame()", ret);

+        exit_program(1);

+    }

+}

+

+#define MAX_AUDIO_PACKET_SIZE (128 * 1024)

+

+static void do_audio_out(AVFormatContext *s,

+                         OutputStream *ost,

+                         InputStream *ist,

+                         unsigned char *buf, int size)

+{

+    uint8_t *buftmp;

+    int64_t audio_out_size, audio_buf_size;

+    int64_t allocated_for_size= size;

+

+    int size_out, frame_bytes, ret, resample_changed;

+    AVCodecContext *enc= ost->st->codec;

+    AVCodecContext *dec= ist->st->codec;

+    int osize = av_get_bytes_per_sample(enc->sample_fmt);

+    int isize = av_get_bytes_per_sample(dec->sample_fmt);

+    const int coded_bps = av_get_bits_per_sample(enc->codec->id);

+

+need_realloc:

+    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);

+    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;

+    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API

+    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);

+    audio_buf_size*= osize*enc->channels;

+

+    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);

+    if(coded_bps > 8*osize)

+        audio_out_size= audio_out_size * coded_bps / (8*osize);

+    audio_out_size += FF_MIN_BUFFER_SIZE;

+

+    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){

+        fprintf(stderr, "Buffer sizes too large\n");

+        exit_program(1);

+    }

+

+    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);

+    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);

+    if (!audio_buf || !audio_out){

+        fprintf(stderr, "Out of memory in do_audio_out\n");

+        exit_program(1);

+    }

+

+    if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)

+        ost->audio_resample = 1;

+

+    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||

+                       ost->resample_channels    != dec->channels   ||

+                       ost->resample_sample_rate != dec->sample_rate;

+

+    if ((ost->audio_resample && !ost->resample) || resample_changed) {

+        if (resample_changed) {

+            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",

+                   ist->file_index, ist->st->index,

+                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,

+                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);

+            ost->resample_sample_fmt  = dec->sample_fmt;

+            ost->resample_channels    = dec->channels;

+            ost->resample_sample_rate = dec->sample_rate;

+            if (ost->resample)

+                audio_resample_close(ost->resample);

+        }

+        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */

+        if (audio_sync_method <= 1 &&

+            ost->resample_sample_fmt  == enc->sample_fmt &&

+            ost->resample_channels    == enc->channels   &&

+            ost->resample_sample_rate == enc->sample_rate) {

+            ost->resample = NULL;

+            ost->audio_resample = 0;

+        } else if (ost->audio_resample) {

+            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)

+                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");

+            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,