ffmpeg.c

/*
 * FFmpeg main 
 * Copyright (c) 2000,2001 Gerard Lantau
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#ifndef CONFIG_WIN32
#include "config.h"
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/poll.h>
#include <termios.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <ctype.h>
#endif

#include "avformat.h"

#define MAXINT64 INT64_C(0x7fffffffffffffff)

typedef struct {
    const char *name;
    int flags;
#define HAS_ARG    0x0001
#define OPT_BOOL   0x0002
#define OPT_EXPERT 0x0004
#define OPT_STRING 0x0008
    union {
        void (*func_arg)();
        int *int_arg;
        char **str_arg;
    } u;
    const char *help;
    const char *argname;
} OptionDef;

/* select an input stream for an output stream */
typedef struct AVStreamMap {
    int file_index;
    int stream_index;
} AVStreamMap;

extern const OptionDef options[];

void show_help(void);

#define MAX_FILES 20

static AVFormatContext *input_files[MAX_FILES];
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 AVFormat *file_format;
static int frame_width  = 160;
static int frame_height = 128;
static int frame_rate = 25 * FRAME_RATE_BASE;
static int video_bit_rate = 200000;
static int video_qscale = 0;
static int video_disable = 0;
static int video_codec_id = CODEC_ID_NONE;
static int same_quality = 0;
static int do_deinterlace = 0;

static int gop_size = 12;
static int intra_only = 0;
static int audio_sample_rate = 44100;
static int audio_bit_rate = 64000;
static int audio_disable = 0;
static int audio_channels = 1;
static int audio_codec_id = CODEC_ID_NONE;

static INT64 recording_time = 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 int do_benchmark = 0;

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 fifo_packet_rptr;    /* read index in the corresponding
                                avinputstream packet fifo */
    /* video only */
    AVPicture pict_tmp;         /* temporary image for resizing */
    int video_resample;
    ImgReSampleContext *img_resample_ctx; /* for image resampling */
    
    /* audio only */
    int audio_resample;
    ReSampleContext *resample; /* for audio resampling */
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
} AVOutputStream;

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 pts;               /* current pts */
    int frame_number;        /* current frame */
    INT64 sample_index;      /* current sample */
} 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 buffer_size_max;  /* buffer size at which we consider we can stop
                             buffering */
} AVInputFile;

#ifndef CONFIG_WIN32

/* init terminal so that we can grab keys */
static struct termios oldtty;

static void term_exit(void)
{
    tcsetattr (0, TCSANOW, &oldtty);
}

static void term_init(void)
{
    struct termios tty;

    tcgetattr (0, &tty);
    oldtty = tty;

    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
                          |INLCR|IGNCR|ICRNL|IXON);
    tty.c_oflag |= OPOST;
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
    tty.c_cflag &= ~(CSIZE|PARENB);
    tty.c_cflag |= CS8;
    tty.c_cc[VMIN] = 1;
    tty.c_cc[VTIME] = 0;
    
    tcsetattr (0, TCSANOW, &tty);

    atexit(term_exit);
}

/* read a key without blocking */
static int read_key(void)
{
    struct timeval tv;
    int n;
    unsigned char ch;
    fd_set rfds;

    FD_ZERO(&rfds);
    FD_SET(0, &rfds);
    tv.tv_sec = 0;
    tv.tv_usec = 0;
    n = select(1, &rfds, NULL, NULL, &tv);
    if (n > 0) {
        if (read(0, &ch, 1) == 1)
            return ch;
    }
    return -1;
}

#define AUDIO_FIFO_SIZE 8192

/* main loop for grabbing */
int av_grab(AVFormatContext *s)
{
    UINT8 audio_buf[AUDIO_FIFO_SIZE/2];
    UINT8 audio_buf1[AUDIO_FIFO_SIZE/2];
    UINT8 audio_out[AUDIO_FIFO_SIZE/2];
    UINT8 video_buffer[128*1024];
    char buf[256];
    short *samples;
    URLContext *audio_handle = NULL, *video_handle = NULL;
    int ret;
    AVCodecContext *enc, *first_video_enc = NULL;
    int frame_size, frame_bytes;
    int use_audio, use_video;
    int frame_rate, sample_rate, channels;
    int width, height, frame_number, i, pix_fmt = 0;
    AVOutputStream *ost_table[s->nb_streams], *ost;
    UINT8 *picture_in_buf = NULL, *picture_420p = NULL;
    int audio_fifo_size = 0, picture_size = 0;
    INT64 time_start;

    /* init output stream info */
    for(i=0;i<s->nb_streams;i++)
        ost_table[i] = NULL;

    /* output stream init */
    for(i=0;i<s->nb_streams;i++) {
        ost = av_mallocz(sizeof(AVOutputStream));
        if (!ost)
            goto fail;
        ost->index = i;
        ost->st = s->streams[i];
        ost_table[i] = ost;
    }

    use_audio = 0;
    use_video = 0;
    frame_rate = 0;
    sample_rate = 0;
    frame_size = 0;
    channels = 1;
    width = 0;
    height = 0;
    frame_number = 0;
    
    for(i=0;i<s->nb_streams;i++) {
        AVCodec *codec;

        ost = ost_table[i];
        enc = &ost->st->codec;
        codec = avcodec_find_encoder(enc->codec_id);
        if (!codec) {
            fprintf(stderr, "Unknown codec\n");
            return -1;
        }
        if (avcodec_open(enc, codec) < 0) {
            fprintf(stderr, "Incorrect encode parameters\n");
            return -1;
        }
        switch(enc->codec_type) {
        case CODEC_TYPE_AUDIO:
            use_audio = 1;
            if (enc->sample_rate > sample_rate)
                sample_rate = enc->sample_rate;
            if (enc->frame_size > frame_size)
                frame_size = enc->frame_size;
            if (enc->channels > channels)
                channels = enc->channels;
            break;
        case CODEC_TYPE_VIDEO:
            if (!first_video_enc)
                first_video_enc = enc;
            use_video = 1;
            if (enc->frame_rate > frame_rate)
                frame_rate = enc->frame_rate;
            if (enc->width > width)
                width = enc->width;
            if (enc->height > height)
                height = enc->height;
            break;
        }
    }

    /* audio */
    samples = NULL;
    if (use_audio) {
        snprintf(buf, sizeof(buf), "audio:%d,%d", sample_rate, channels);
        ret = url_open(&audio_handle, buf, URL_RDONLY);
        if (ret < 0) {
            fprintf(stderr, "Could not open audio device: disabling audio capture\n");
            use_audio = 0;
        } else {
            URLFormat f;
            /* read back exact grab parameters */
            if (url_getformat(audio_handle, &f) < 0) {
                fprintf(stderr, "could not read back video grab parameters\n");
                goto fail;
            }
            sample_rate = f.sample_rate;
            channels = f.channels;
            audio_fifo_size = ((AUDIO_FIFO_SIZE / 2) / audio_handle->packet_size) * 
                audio_handle->packet_size;
            fprintf(stderr, "Audio sampling: %d Hz, %s\n", 
                    sample_rate, channels == 2 ? "stereo" : "mono");
        }
    }
    
    /* video */
    if (use_video) {
        snprintf(buf, sizeof(buf), "video:%d,%d,%f", 
                 width, height, (float)frame_rate / FRAME_RATE_BASE);

        ret = url_open(&video_handle, buf, URL_RDONLY);
        if (ret < 0) {
            fprintf(stderr,"Could not init video 4 linux capture: disabling video capture\n");
            use_video = 0;
        } else {
            URLFormat f;
            const char *pix_fmt_str;
            /* read back exact grab parameters */
            if (url_getformat(video_handle, &f) < 0) {
                fprintf(stderr, "could not read back video grab parameters\n");
                goto fail;
            }
            width = f.width;
            height = f.height;
            pix_fmt = f.pix_fmt;
            switch(pix_fmt) {
            case PIX_FMT_YUV420P:
                pix_fmt_str = "420P";
                break;
            case PIX_FMT_YUV422:
                pix_fmt_str = "422";
                break;
            case PIX_FMT_RGB24:
                pix_fmt_str = "RGB24";
                break;
            case PIX_FMT_BGR24:
                pix_fmt_str = "BGR24";
                break;
            default:
                pix_fmt_str = "???";
                break;
            }
            picture_size = video_handle->packet_size;
            picture_in_buf = malloc(picture_size);
            if (!picture_in_buf)
                goto fail;
            /* allocate a temporary picture if not grabbing in 420P format */
            if (pix_fmt != PIX_FMT_YUV420P) {
                picture_420p = malloc((width * height * 3) / 2);
            }
            fprintf(stderr, "Video sampling: %dx%d, %s format, %0.2f fps\n", 
                    width, height, pix_fmt_str, (float)frame_rate / FRAME_RATE_BASE);
        }
    }

    if (!use_video && !use_audio) {
        fprintf(stderr,"Could not open grab devices : exiting\n");
        exit(1);
    }

    /* init built in conversion functions */
    for(i=0;i<s->nb_streams;i++) {
        ost = ost_table[i];
        enc = &ost->st->codec;
        switch(enc->codec_type) {
        case CODEC_TYPE_AUDIO:
            ost->audio_resample = 0;
            if ((enc->channels != channels ||
                 enc->sample_rate != sample_rate)) {
                ost->audio_resample = 1;
                ost->resample = audio_resample_init(enc->channels, channels,
                                                    enc->sample_rate, sample_rate);
            }
            if (fifo_init(&ost->fifo, (2 * audio_fifo_size * enc->sample_rate) / 
                          sample_rate))
                goto fail;
            break;
        case CODEC_TYPE_VIDEO:
            ost->video_resample = 0;
            if (enc->width != width ||
                enc->height != height) {
                UINT8 *buf;
                ost->video_resample = 1;
                buf = malloc((enc->width * enc->height * 3) / 2);
                if (!buf)
                    goto fail;
                ost->pict_tmp.data[0] = buf;
                ost->pict_tmp.data[1] = buf + enc->width * height;
                ost->pict_tmp.data[2] = ost->pict_tmp.data[1] + (enc->width * height) / 4;
                ost->pict_tmp.linesize[0] = enc->width;
                ost->pict_tmp.linesize[1] = enc->width / 2;
                ost->pict_tmp.linesize[2] = enc->width / 2;
                ost->img_resample_ctx = img_resample_init(
                                  ost->st->codec.width, ost->st->codec.height,
                                  width, height);
            }
        }
    }

    fprintf(stderr, "Press [q] to stop encoding\n");

    s->format->write_header(s);
    time_start = gettime();
    term_init();
    
    for(;;) {
        /* if 'q' pressed, exits */
        if (read_key() == 'q')
            break;

        /* read & compress audio frames */
        if (use_audio) {
            int ret, nb_samples, nb_samples_out;
            UINT8 *buftmp;

            for(;;) {
                ret = url_read(audio_handle, audio_buf, audio_fifo_size);
                if (ret <= 0)
                    break;
                /* fill each codec fifo by doing the right sample
                   rate conversion. This is not optimal because we
                   do too much work, but it is easy to do */
                nb_samples = ret / (channels * 2);
                for(i=0;i<s->nb_streams;i++) {
                    ost = ost_table[i];
                    enc = &ost->st->codec;
                    if (enc->codec_type == CODEC_TYPE_AUDIO) {
                        /* rate & stereo convertion */
                        if (!ost->audio_resample) {
                            buftmp = audio_buf;
                            nb_samples_out = nb_samples;
                        } else {
                            buftmp = audio_buf1;
                            nb_samples_out = audio_resample(ost->resample, 
                                                            (short *)buftmp, (short *)audio_buf,
                                                            nb_samples);
                        }
                        fifo_write(&ost->fifo, buftmp, nb_samples_out * enc->channels * 2, 
                                   &ost->fifo.wptr);
                    }
                }
                
                /* compress as many frame as possible with each audio codec */
                for(i=0;i<s->nb_streams;i++) {
                    ost = ost_table[i];
                    enc = &ost->st->codec;
                    if (enc->codec_type == CODEC_TYPE_AUDIO) {
                        frame_bytes = enc->frame_size * 2 * enc->channels;
                        
                        while (fifo_read(&ost->fifo, audio_buf, 
                                         frame_bytes, &ost->fifo.rptr) == 0) {
                            ret = avcodec_encode_audio(enc,
                                                       audio_out, sizeof(audio_out), 
                                                       (short *)audio_buf);
                            s->format->write_packet(s, ost->index, audio_out, ret);
                        }
                    }
                }
            }
        }

        if (use_video) {
            AVPicture *picture1, *picture2, *picture;
            AVPicture picture_tmp0, picture_tmp1;

            ret = url_read(video_handle, picture_in_buf, picture_size);
            if (ret < 0)
                break;
            
            picture2 = &picture_tmp0;
            avpicture_fill(picture2, picture_in_buf, pix_fmt, width, height);

            if (pix_fmt != PIX_FMT_YUV420P) {
                picture = &picture_tmp1;
                img_convert(picture, PIX_FMT_YUV420P,
                            picture2, pix_fmt, 
                            width, height);
            } else {
                picture = picture2;
            }
            
            for(i=0;i<s->nb_streams;i++) {
                ost = ost_table[i];
                enc = &ost->st->codec;
                if (enc->codec_type == CODEC_TYPE_VIDEO) {
                    int n1, n2, nb;

                    /* feed each codec with its requested frame rate */
                    n1 = ((INT64)frame_number * enc->frame_rate) / frame_rate;
                    n2 = (((INT64)frame_number + 1) * enc->frame_rate) / frame_rate;
                    nb = n2 - n1;
                    if (nb > 0) {
                        /* resize the picture if needed */
                        if (ost->video_resample) {
                            picture1 = &ost->pict_tmp;
                            img_resample(ost->img_resample_ctx, 
                                         picture1, picture);
                        } else {
                            picture1 = picture;
                        }
                        ret = avcodec_encode_video(enc, video_buffer, 
                                                   sizeof(video_buffer), 
                                                   picture1);
                        s->format->write_packet(s, ost->index, video_buffer, ret);
                    }
                }
            }
            frame_number++;
        }
        
        /* write report */
        {
            char buf[1024];
            INT64 total_size;
            float ti, bitrate;
            static float last_ti;
            INT64 ti1;

            total_size = url_ftell(&s->pb);
            ti1 = gettime() - time_start;
            /* check elapsed time */
            if (recording_time && ti1 >= recording_time)
                break;

            ti = ti1 / 1000000.0;
            if (ti < 0.1)
                ti = 0.1;
            /* dispaly twice per second */
            if ((ti - last_ti) >= 0.5) {
                last_ti = ti;
                bitrate = (int)((total_size * 8) / ti / 1000.0);
                
                buf[0] = '\0';
                if (use_video) {
                    sprintf(buf + strlen(buf), "frame=%5d fps=%4.1f q=%2d ",
                            frame_number, (float)frame_number / ti, first_video_enc->quality);
                }
                
                sprintf(buf + strlen(buf), "size=%8LdkB time=%0.1f bitrate=%6.1fkbits/s", 
                        total_size / 1024, ti, bitrate);
                fprintf(stderr, "%s    \r", buf);
                fflush(stderr);
            }
        }
    }
    term_exit();

    for(i=0;i<s->nb_streams;i++) {
        ost = ost_table[i];
        enc = &ost->st->codec;
        avcodec_close(enc);
    }
    s->format->write_trailer(s);
    
    if (audio_handle)
        url_close(audio_handle);

    if (video_handle)
        url_close(video_handle);

    /* write report */
    {
        float ti, bitrate;
        INT64 total_size;

        total_size = url_ftell(&s->pb);

        ti = (gettime() - time_start) / 1000000.0;
        if (ti < 0.1)
            ti = 0.1;
        bitrate = (int)((total_size * 8) / ti / 1000.0);

        fprintf(stderr, "\033[K\nTotal time = %0.1f s, %Ld KBytes, %0.1f kbits/s\n", 
                ti, total_size / 1024, bitrate);
        if (use_video) {
            fprintf(stderr, "Total frames = %d\n", frame_number);
        }
    }

    ret = 0;
 fail1:
    if (picture_in_buf)
        free(picture_in_buf);
    if (picture_420p)
        free(picture_420p);
    for(i=0;i<s->nb_streams;i++) {
        ost = ost_table[i];
        if (ost) {
            if (ost->fifo.buffer)
                fifo_free(&ost->fifo);
            if (ost->pict_tmp.data[0])
                free(ost->pict_tmp.data[0]);
            if (ost->video_resample)
                img_resample_close(ost->img_resample_ctx);
            if (ost->audio_resample)
                audio_resample_close(ost->resample);
            free(ost);
        }
    }
    return ret;
 fail:
    ret = -ENOMEM;
    goto fail1;
}

#endif /* CONFIG_WIN32 */

int read_ffserver_streams(AVFormatContext *s, const char *filename)
{
    int i;
    AVFormatContext *ic;

    ic = av_open_input_file(filename, FFM_PACKET_SIZE);
    if (!ic)
        return -EIO;
    /* copy stream format */
    s->nb_streams = ic->nb_streams;
    for(i=0;i<ic->nb_streams;i++) {
        AVStream *st;
        st = av_mallocz(sizeof(AVFormatContext));
        memcpy(st, ic->streams[i], sizeof(AVStream));
        s->streams[i] = st;
    }

    av_close_input_file(ic);
    return 0;
}

#define MAX_AUDIO_PACKET_SIZE 16384

static void do_audio_out(AVFormatContext *s, 
                         AVOutputStream *ost, 
                         AVInputStream *ist,
                         unsigned char *buf, int size)
{
    UINT8 *buftmp;
    UINT8 audio_buf[2*MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */
    UINT8 audio_out[MAX_AUDIO_PACKET_SIZE]; /* XXX: allocate it */
    int size_out, frame_bytes, ret;
    AVCodecContext *enc;

    enc = &ost->st->codec;

    if (ost->audio_resample) {
        buftmp = audio_buf;
        size_out = audio_resample(ost->resample, 
                                  (short *)buftmp, (short *)buf,
                                  size / (ist->st->codec.channels * 2));
        size_out = size_out * enc->channels * 2;
    } else {
        buftmp = buf;
        size_out = size;
    }

    /* now encode as many frames as possible */
    if (enc->codec_id != CODEC_ID_PCM) {
        /* output resampled raw samples */
        fifo_write(&ost->fifo, buftmp, size_out, 
                   &ost->fifo.wptr);

        frame_bytes = enc->frame_size * 2 * enc->channels;
        
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
                     &ost->fifo.rptr) == 0) {
            ret = avcodec_encode_audio(enc,
                                       audio_out, sizeof(audio_out), (short *)audio_buf);
            s->format->write_packet(s, ost->index, audio_out, ret);
        }
    } else {
        /* XXX: handle endianness */
        s->format->write_packet(s, ost->index, buftmp, size_out);
    }
}

/* write a picture to a raw mux */
static void write_picture(AVFormatContext *s, int index, AVPicture *picture, 
                          int pix_fmt, int w, int h)
{
    UINT8 *buf, *src, *dest;
    int size, j, i;

    size = avpicture_get_size(pix_fmt, w, h);
    buf = malloc(size);
    if (!buf)
        return;

    /* XXX: not efficient, should add test if we can take
       directly the AVPicture */
    switch(pix_fmt) {
    case PIX_FMT_YUV420P:
        dest = buf;
        for(i=0;i<3;i++) {
            if (i == 1) {
                w >>= 1;
                h >>= 1;
            }
            src = picture->data[i];
            for(j=0;j<h;j++) {
                memcpy(dest, src, w);
                dest += w;
                src += picture->linesize[i];
            }
        }
        break;
    case PIX_FMT_YUV422P:
        size = (w * h) * 2; 
        buf = malloc(size);
        dest = buf;
        for(i=0;i<3;i++) {
            if (i == 1) {
                w >>= 1;
            }
            src = picture->data[i];
            for(j=0;j<h;j++) {
                memcpy(dest, src, w);
                dest += w;
                src += picture->linesize[i];
            }
        }
        break;
    case PIX_FMT_YUV444P:
        size = (w * h) * 3; 
        buf = malloc(size);
        dest = buf;
        for(i=0;i<3;i++) {
            src = picture->data[i];
            for(j=0;j<h;j++) {
                memcpy(dest, src, w);
                dest += w;
                src += picture->linesize[i];
            }
        }
        break;
    case PIX_FMT_YUV422:
        size = (w * h) * 2; 
        buf = malloc(size);
        dest = buf;
        src = picture->data[0];
        for(j=0;j<h;j++) {
            memcpy(dest, src, w * 2);
            dest += w * 2;
            src += picture->linesize[0];
        }
        break;
    case PIX_FMT_RGB24:
    case PIX_FMT_BGR24:
        size = (w * h) * 3; 
        buf = malloc(size);
        dest = buf;
        src = picture->data[0];
        for(j=0;j<h;j++) {
            memcpy(dest, src, w * 3);
            dest += w * 3;
            src += picture->linesize[0];
        }
        break;
    default:
        return;
    }
    s->format->write_packet(s, index, buf, size);
    free(buf);
}


static void do_video_out(AVFormatContext *s, 
                         AVOutputStream *ost, 
                         AVInputStream *ist,
                         AVPicture *picture1)
{
    int n1, n2, nb, i, ret, frame_number;
    AVPicture *picture, *picture2, *pict;
    AVPicture picture_tmp1, picture_tmp2;
    UINT8 video_buffer[128*1024];
    UINT8 *buf = NULL, *buf1 = NULL;
    AVCodecContext *enc, *dec;

    enc = &ost->st->codec;
    dec = &ist->st->codec;

    frame_number = ist->frame_number;
    /* first drop frame if needed */
    n1 = ((INT64)frame_number * enc->frame_rate) / dec->frame_rate;
    n2 = (((INT64)frame_number + 1) * enc->frame_rate) / dec->frame_rate;
    nb = n2 - n1;
    if (nb <= 0)
        return;
    
    /* deinterlace : must be done before any resize */
    if (do_deinterlace) {
        int size;

        /* create temporary picture */
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
        buf1 = malloc(size);
        if (!buf1)
            return;
        
        picture2 = &picture_tmp2;
        avpicture_fill(picture2, buf1, dec->pix_fmt, dec->width, dec->height);

        if (avpicture_deinterlace(picture2, picture1, 
                                  dec->pix_fmt, dec->width, dec->height) < 0) {
            /* if error, do not deinterlace */
            free(buf1);
            buf1 = NULL;
            picture2 = picture1;
        }
    } else {
        picture2 = picture1;
    }

    /* convert pixel format if needed */
    if (enc->pix_fmt != dec->pix_fmt) {
        int size;

        /* create temporary picture */
        size = avpicture_get_size(enc->pix_fmt, dec->width, dec->height);
        buf = malloc(size);
        if (!buf)
            return;
        pict = &picture_tmp1;
        avpicture_fill(pict, buf, enc->pix_fmt, dec->width, dec->height);
        
        if (img_convert(pict, enc->pix_fmt, 
                        picture2, dec->pix_fmt, 
                        dec->width, dec->height) < 0) {
            fprintf(stderr, "pixel format conversion not handled\n");
            goto the_end;
        }
    } else {
        pict = picture2;
    }

    /* XXX: resampling could be done before raw format convertion in
       some cases to go faster */
    /* XXX: only works for YUV420P */
    if (ost->video_resample) {
        picture = &ost->pict_tmp;
        img_resample(ost->img_resample_ctx, picture, pict);
    } else {
        picture = pict;
    }

    /* duplicates frame if needed */
    /* XXX: pb because no interleaving */
    for(i=0;i<nb;i++) {
        if (enc->codec_id != CODEC_ID_RAWVIDEO) {
            /* handles sameq here. This is not correct because it may
               not be a global option */
            if (same_quality) {
                enc->quality = dec->quality;
            }
            ret = avcodec_encode_video(enc, 
                                       video_buffer, sizeof(video_buffer), 
                                       picture);
            s->format->write_packet(s, ost->index, video_buffer, ret);
        } else {
            write_picture(s, ost->index, picture, enc->pix_fmt, enc->width, enc->height);
        }
    }
    the_end:
    if (buf)
        free(buf);
    if (buf1)
        free(buf1);
}

//#define HEX_DUMP

#ifdef HEX_DUMP
static void hex_dump(UINT8 *buf, int size)
{
    int len, i, j, c;

    for(i=0;i<size;i+=16) {
        len = size - i;
        if (len > 16)
            len = 16;
        printf("%08x ", i);
        for(j=0;j<16;j++) {
            if (j < len)
                printf(" %02x", buf[i+j]);
            else
                printf("   ");
        }
        printf(" ");
        for(j=0;j<len;j++) {
            c = buf[i+j];
            if (c < ' ' || c > '~')
                c = '.';
            printf("%c", c);
        }
        printf("\n");
    }
}
#endif

/*
 * The following code is the main loop of the file converter
 */
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)
{
    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;
    INT64 min_pts, start_time;
    AVInputFile *file_table;

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

    memset(file_table, 0, sizeof(file_table));
    
    /* input stream init */
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        file_table[i].ist_index = j;
        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) */
        }
    }

    /* output stream init */
    nb_ostreams = 0;
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
        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");
        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;
            } 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;
                    }
                }
                
                if (!found) {
                    /* 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;