PeerStreamer

/*

 * ffmpeg main

 * Copyright (c) 2000-2003 Fabrice Bellard

 *

 * 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/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[] = "ffmpeg";

const int program_birth_year = 2000;

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

typedef struct AVStreamMap {

    int file_index;

    int stream_index;

    int sync_file_index;

    int sync_stream_index;

} AVStreamMap;

/**

 * select an input file for an output file

 */

typedef struct AVMetaDataMap {

    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

} AVMetaDataMap;

typedef struct AVChapterMap {

    int in_file;

    int out_file;

} AVChapterMap;

static const OptionDef options[];

#define MAX_FILES 100

#define MAX_STREAMS 1024    /* arbitrary sanity check value */

#define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h

static const char *last_asked_format = NULL;

static AVFormatContext *input_files[MAX_FILES];

static int64_t input_files_ts_offset[MAX_FILES];

static double *input_files_ts_scale[MAX_FILES] = {NULL};

static AVCodec **input_codecs = NULL;

static int nb_input_files = 0;

static int nb_input_codecs = 0;

static int nb_input_files_ts_scale[MAX_FILES] = {0};

static AVFormatContext *output_files[MAX_FILES];

static AVCodec **output_codecs = NULL;

static int nb_output_files = 0;

static int nb_output_codecs = 0;

static AVStreamMap *stream_maps = NULL;

static int nb_stream_maps;

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

static AVMetaDataMap (*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 AVChapterMap *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;

static AVFilterGraph *graph = NULL;

#endif

static int intra_only = 0;

static int audio_sample_rate = 44100;

static int64_t channel_layout = 0;

#define QSCALE_NONE -99999

static float audio_qscale = QSCALE_NONE;

static int audio_disable = 0;

static int audio_channels = 1;

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 recording_timestamp = 0;

static int64_t input_ts_offset = 0;

static int file_overwrite = 0;

static AVMetadata *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 int video_global_header = 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  video_channel = 0;

static char *video_standard;

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 "ffmpeg2pass"

struct AVInputStream;

typedef struct AVOutputStream {

    int file_index;          /* file index */

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

    int source_index;        /* AVInputStream 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 AVInputStream *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;

    /* 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;

    /* 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;

   int sws_flags;

} AVOutputStream;

static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };

static int nb_output_streams_for_file[MAX_FILES] = { 0 };

typedef struct AVInputStream {

    int file_index;

    int 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' */

    int64_t sample_index;      /* current sample */

    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;

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

    int showed_multi_packet_warning;

    int is_past_recording_time;

#if CONFIG_AVFILTER

    AVFilterContext *output_video_filter;

    AVFilterContext *input_video_filter;

    AVFrame *filter_frame;

    int has_filter_frame;

    AVFilterBufferRef *picref;

#endif

} AVInputStream;

typedef struct AVInputFile {

    int eof_reached;      /* true if eof reached */

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

    int buffer_size;      /* current total buffer size */

    int nb_streams;       /* nb streams we are aware of */

} AVInputFile;

#if CONFIG_AVFILTER

static int configure_video_filters(AVInputStream *ist, AVOutputStream *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;

    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(&ist->input_video_filter, avfilter_get_by_name("buffer"),

                                       "src", args, NULL, graph);

    if (ret < 0)

        return ret;

    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,

                                       "out", NULL, &ffsink_ctx, graph);

    if (ret < 0)

        return ret;

    last_filter = ist->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, 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);

    graph->scale_sws_opts = av_strdup(args);

    if (vfilters) {

        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 = ist->output_video_filter;

        inputs->pad_idx = 0;

        inputs->next    = NULL;

        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)

            return ret;

        av_freep(&vfilters);

    } else {

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

            return ret;

    }

    if ((ret = avfilter_graph_config(graph, NULL)) < 0)

        return ret;

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

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

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

        ist->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 void

sigterm_handler(int sig)

{

    received_sigterm = sig;

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

}

static int ffmpeg_exit(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]);

    }

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

        av_close_input_file(input_files[i]);

        av_free(input_files_ts_scale[i]);

    }

    av_free(intra_matrix);

    av_free(inter_matrix);

    if (vstats_file)

        fclose(vstats_file);

    av_free(vstats_filename);

    av_free(streamid_map);

    av_free(input_codecs);

    av_free(output_codecs);

    av_free(stream_maps);

    av_free(meta_data_maps);

    av_free(video_codec_name);

    av_free(audio_codec_name);

    av_free(subtitle_codec_name);

    av_free(data_codec_name);

    av_free(video_standard);

    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;

}

/* 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");

        ffmpeg_exit(1);

    }

    if (*size < new_size) {

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

        if (!tmp) {

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

            ffmpeg_exit(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];

        }

    }

}

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 AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)

{

    int idx = oc->nb_streams - 1;

    AVOutputStream *ost;

    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(AVOutputStream));

    if (!ost) {

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

        ffmpeg_exit(1);

    }

    ost->file_index = file_idx;

    ost->index = idx;

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

    return ost;

}

static int read_ffserver_streams(AVFormatContext *s, const char *filename)

{

    int i, err;

    AVFormatContext *ic;

    int nopts = 0;

    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);

    if (err < 0)

        return err;

    /* copy stream format */

    s->nb_streams = 0;

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

        AVStream *st;

        AVCodec *codec;

        s->nb_streams++;

        // FIXME: a more elegant solution is needed

        st = av_mallocz(sizeof(AVStream));

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

        st->codec = avcodec_alloc_context();

        if (!st->codec) {

            print_error(filename, AVERROR(ENOMEM));

            ffmpeg_exit(1);

        }

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

        s->streams[i] = st;

        codec = avcodec_find_encoder(st->codec->codec_id);

        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;

        new_output_stream(s, nb_output_files);

    }

    if (!nopts)

        s->timestamp = av_gettime();

    av_close_input_file(ic);

    return 0;

}

static double

get_sync_ipts(const AVOutputStream *ost)

{

    const AVInputStream *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)

                ffmpeg_exit(1);

        }

        *pkt= new_pkt;

        bsfc= bsfc->next;

    }

    ret= av_interleaved_write_frame(s, pkt);

    if(ret < 0){

        print_error("av_interleaved_write_frame()", ret);

        ffmpeg_exit(1);

    }

}

#define MAX_AUDIO_PACKET_SIZE (128 * 1024)

static void do_audio_out(AVFormatContext *s,

                         AVOutputStream *ost,

                         AVInputStream *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_bits_per_sample_fmt(enc->sample_fmt)/8;

    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;

    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");

        ffmpeg_exit(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");

        ffmpeg_exit(1);

    }

    if (enc->channels != dec->channels)

        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->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 (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,

                                                   enc->sample_rate, dec->sample_rate,

                                                   enc->sample_fmt,  dec->sample_fmt,

                                                   16, 10, 0, 0.8);

            if (!ost->resample) {

                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",

                        dec->channels, dec->sample_rate,

                        enc->channels, enc->sample_rate);

                ffmpeg_exit(1);

            }

        }

    }

#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))

    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&

        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {

        if (ost->reformat_ctx)

            av_audio_convert_free(ost->reformat_ctx);

        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,

                                                   dec->sample_fmt, 1, NULL, 0);

        if (!ost->reformat_ctx) {

            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",

                av_get_sample_fmt_name(dec->sample_fmt),

                av_get_sample_fmt_name(enc->sample_fmt));

            ffmpeg_exit(1);

        }

        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);

    }

    if(audio_sync_method){

        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts

                - av_fifo_size(ost->fifo)/(enc->channels * 2);

        double idelta= delta*dec->sample_rate / enc->sample_rate;

        int byte_delta= ((int)idelta)*2*dec->channels;

        //FIXME resample delay

        if(fabs(delta) > 50){

            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){

                if(byte_delta < 0){

                    byte_delta= FFMAX(byte_delta, -size);

                    size += byte_delta;

                    buf  -= byte_delta;

                    if(verbose > 2)

                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);

                    if(!size)

                        return;

                    ist->is_start=0;

                }else{

                    static uint8_t *input_tmp= NULL;

                    input_tmp= av_realloc(input_tmp, byte_delta + size);

                    if(byte_delta > allocated_for_size - size){

                        allocated_for_size= byte_delta + (int64_t)size;

                        goto need_realloc;

                    }

                    ist->is_start=0;

                    memset(input_tmp, 0, byte_delta);

                    memcpy(input_tmp + byte_delta, buf, size);

                    buf= input_tmp;

                    size += byte_delta;

                    if(verbose > 2)

                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);

                }

            }else if(audio_sync_method>1){

                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);

                av_assert0(ost->audio_resample);

                if(verbose > 2)

                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);

//                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));

                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);

            }

        }

    }else

        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)

                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong

    if (ost->audio_resample) {

        buftmp = audio_buf;

        size_out = audio_resample(ost->resample,

                                  (short *)buftmp, (short *)buf,

                                  size / (dec->channels * isize));

        size_out = size_out * enc->channels * osize;

    } else {

        buftmp = buf;

        size_out = size;

    }

    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {

        const void *ibuf[6]= {buftmp};

        void *obuf[6]= {audio_buf};

        int istride[6]= {isize};

        int ostride[6]= {osize};

        int len= size_out/istride[0];

        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {

            printf("av_audio_convert() failed\n");

            if (exit_on_error)

                ffmpeg_exit(1);

            return;

        }

        buftmp = audio_buf;

        size_out = len*osize;

    }

    /* now encode as many frames as possible */

    if (enc->frame_size > 1) {

        /* output resampled raw samples */

        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {

            fprintf(stderr, "av_fifo_realloc2() failed\n");

            ffmpeg_exit(1);

        }

        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);

        frame_bytes = enc->frame_size * osize * enc->channels;

        while (av_fifo_size(ost->fifo) >= frame_bytes) {

            AVPacket pkt;

            av_init_packet(&pkt);

            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);

            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,

                                       (short *)audio_buf);

            if (ret < 0) {

                fprintf(stderr, "Audio encoding failed\n");

                ffmpeg_exit(1);

            }

            audio_size += ret;

            pkt.stream_index= ost->index;

            pkt.data= audio_out;

            pkt.size= ret;

            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

            pkt.flags |= AV_PKT_FLAG_KEY;