ffmpeg.c 143 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1
/*
2
 * FFmpeg main
Fabrice Bellard's avatar
Fabrice Bellard committed
3
 * Copyright (c) 2000-2003 Fabrice Bellard
Fabrice Bellard's avatar
Fabrice Bellard committed
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Fabrice Bellard's avatar
Fabrice Bellard committed
20
 */
21

22
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

25 26 27 28 29 30
#include "config.h"
#include <ctype.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <errno.h>
31
#include <signal.h>
32
#include <limits.h>
33
#include <unistd.h>
34 35 36 37
#include "libavformat/avformat.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
#include "libavcodec/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavcodec/colorspace.h"
40 41 42
#include "libavutil/fifo.h"
#include "libavutil/avstring.h"
#include "libavformat/os_support.h"
43

44
#if HAVE_SYS_RESOURCE_H
45
#include <sys/types.h>
46
#include <sys/resource.h>
47
#elif HAVE_GETPROCESSTIMES
48 49 50
#include <windows.h>
#endif

51
#if HAVE_SYS_SELECT_H
52 53 54
#include <sys/select.h>
#endif

55
#if HAVE_TERMIOS_H
Fabrice Bellard's avatar
Fabrice Bellard committed
56 57 58 59
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <termios.h>
60
#elif HAVE_CONIO_H
61
#include <conio.h>
Fabrice Bellard's avatar
Fabrice Bellard committed
62
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
63
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
64
#include <time.h>
Fabrice Bellard's avatar
Fabrice Bellard committed
65

Fabrice Bellard's avatar
Fabrice Bellard committed
66 67
#include "cmdutils.h"

68 69 70
#undef NDEBUG
#include <assert.h>

71 72
#undef exit

73
const char program_name[] = "FFmpeg";
74
const int program_birth_year = 2000;
75

Fabrice Bellard's avatar
Fabrice Bellard committed
76 77 78 79
/* select an input stream for an output stream */
typedef struct AVStreamMap {
    int file_index;
    int stream_index;
80 81
    int sync_file_index;
    int sync_stream_index;
Fabrice Bellard's avatar
Fabrice Bellard committed
82 83
} AVStreamMap;

84 85 86 87 88 89
/** select an input file for an output file */
typedef struct AVMetaDataMap {
    int out_file;
    int in_file;
} AVMetaDataMap;

90
static const OptionDef options[];
Fabrice Bellard's avatar
Fabrice Bellard committed
91 92 93 94

#define MAX_FILES 20

static AVFormatContext *input_files[MAX_FILES];
95
static int64_t input_files_ts_offset[MAX_FILES];
96
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
Aurelien Jacobs's avatar
Aurelien Jacobs committed
97
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
Fabrice Bellard's avatar
Fabrice Bellard committed
98
static int nb_input_files = 0;
Aurelien Jacobs's avatar
Aurelien Jacobs committed
99
static int nb_icodecs;
Fabrice Bellard's avatar
Fabrice Bellard committed
100 101

static AVFormatContext *output_files[MAX_FILES];
Aurelien Jacobs's avatar
Aurelien Jacobs committed
102
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
Fabrice Bellard's avatar
Fabrice Bellard committed
103
static int nb_output_files = 0;
Aurelien Jacobs's avatar
Aurelien Jacobs committed
104
static int nb_ocodecs;
Fabrice Bellard's avatar
Fabrice Bellard committed
105

106
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
Fabrice Bellard's avatar
Fabrice Bellard committed
107 108
static int nb_stream_maps;

109 110 111
static AVMetaDataMap meta_data_maps[MAX_FILES];
static int nb_meta_data_maps;

112 113
static AVInputFormat *file_iformat;
static AVOutputFormat *file_oformat;
114 115
static int frame_width  = 0;
static int frame_height = 0;
116
static float frame_aspect_ratio = 0;
117
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
118
static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
119 120 121 122 123
static int frame_padtop  = 0;
static int frame_padbottom = 0;
static int frame_padleft  = 0;
static int frame_padright = 0;
static int padcolor[3] = {16,128,128}; /* default to black */
124 125 126 127
static int frame_topBand  = 0;
static int frame_bottomBand = 0;
static int frame_leftBand  = 0;
static int frame_rightBand = 0;
128
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
129
static AVRational frame_rate;
130
static float video_qscale = 0;
131 132
static uint16_t *intra_matrix = NULL;
static uint16_t *inter_matrix = NULL;
133
static const char *video_rc_override_string=NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
134
static int video_disable = 0;
135
static int video_discard = 0;
136
static char *video_codec_name = NULL;
137
static int video_codec_tag = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
138
static int same_quality = 0;
139
static int do_deinterlace = 0;
140
static int top_field_first = -1;
141
static int me_threshold = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
142
static int intra_dc_precision = 8;
143
static int loop_input = 0;
144
static int loop_output = AVFMT_NOOUTPUTLOOP;
145
static int qp_hist = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
146 147 148

static int intra_only = 0;
static int audio_sample_rate = 44100;
149
static int64_t channel_layout = 0;
150 151
#define QSCALE_NONE -99999
static float audio_qscale = QSCALE_NONE;
Fabrice Bellard's avatar
Fabrice Bellard committed
152 153
static int audio_disable = 0;
static int audio_channels = 1;
154
static char  *audio_codec_name = NULL;
155
static int audio_codec_tag = 0;
156 157
static char *audio_language = NULL;

158
static int subtitle_disable = 0;
159
static char *subtitle_codec_name = NULL;
160
static char *subtitle_language = NULL;
161
static int subtitle_codec_tag = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
162

163 164
static float mux_preload= 0.5;
static float mux_max_delay= 0.7;
165

166
static int64_t recording_time = INT64_MAX;
167
static int64_t start_time = 0;
168
static int64_t rec_timestamp = 0;
169
static int64_t input_ts_offset = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
170
static int file_overwrite = 0;
171 172
static int metadata_count;
static AVMetadataTag *metadata;
Fabrice Bellard's avatar
Fabrice Bellard committed
173
static int do_benchmark = 0;
174
static int do_hex_dump = 0;
175
static int do_pkt_dump = 0;
176
static int do_psnr = 0;
177
static int do_pass = 0;
Stefano Sabatini's avatar
Stefano Sabatini committed
178
static char *pass_logfilename_prefix = NULL;
179 180
static int audio_stream_copy = 0;
static int video_stream_copy = 0;
181
static int subtitle_stream_copy = 0;
182
static int video_sync_method= -1;
183
static int audio_sync_method= 0;
184
static float audio_drift_threshold= 0.1;
185
static int copy_ts= 0;
186
static int opt_shortest = 0;
187
static int video_global_header = 0;
188
static char *vstats_filename;
189
static FILE *vstats_file;
190
static int opt_programid = 0;
191
static int copy_initial_nonkeyframes = 0;
192

193 194
static int rate_emu = 0;

195
static int  video_channel = 0;
196
static char *video_standard;
197

198
static int audio_volume = 256;
199

200
static int exit_on_error = 0;
201
static int using_stdin = 0;
202
static int verbose = 1;
203
static int thread_count= 1;
204
static int q_pressed = 0;
205 206 207
static int64_t video_size = 0;
static int64_t audio_size = 0;
static int64_t extra_size = 0;
208 209
static int nb_frames_dup = 0;
static int nb_frames_drop = 0;
210
static int input_sync;
211
static uint64_t limit_filesize = 0;
212
static int force_fps = 0;
213

214
static int pgmyuv_compatibility_hack=0;
215
static float dts_delta_threshold = 10;
216

217
static unsigned int sws_flags = SWS_BICUBIC;
218

Benoit Fouet's avatar
Benoit Fouet committed
219
static int64_t timer_start;
220

221 222 223 224 225 226
static uint8_t *audio_buf;
static uint8_t *audio_out;
static uint8_t *audio_out2;

static short *samples;

227 228
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
229
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
230
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
231

Stefano Sabatini's avatar
Stefano Sabatini committed
232
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
Fabrice Bellard's avatar
Fabrice Bellard committed
233

234 235
struct AVInputStream;

Fabrice Bellard's avatar
Fabrice Bellard committed
236 237 238 239 240
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 */
241 242 243 244
    int encoding_needed;     /* true if encoding needed for this stream */
    int frame_number;
    /* input pts and corresponding output pts
       for A/V sync */
245 246
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
    struct AVInputStream *sync_ist; /* input stream to sync against */
247
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
Fabrice Bellard's avatar
Fabrice Bellard committed
248
    /* video only */
249
    int video_resample;
250
    AVFrame pict_tmp;      /* temporary image for resampling */
251 252
    struct SwsContext *img_resample_ctx; /* for image resampling */
    int resample_height;
253
    int resample_width;
254
    int resample_pix_fmt;
255

256 257 258 259 260
    /* full frame size of first frame */
    int original_height;
    int original_width;

    /* cropping area sizes */
261
    int video_crop;
262 263
    int topBand;
    int bottomBand;
264
    int leftBand;
265 266 267 268 269 270 271
    int rightBand;

    /* cropping area of first frame */
    int original_topBand;
    int original_bottomBand;
    int original_leftBand;
    int original_rightBand;
272

273
    /* padding area sizes */
274
    int video_pad;
275
    int padtop;
276 277 278
    int padbottom;
    int padleft;
    int padright;
279

Fabrice Bellard's avatar
Fabrice Bellard committed
280 281 282
    /* audio only */
    int audio_resample;
    ReSampleContext *resample; /* for audio resampling */
283 284
    int reformat_pair;
    AVAudioConvert *reformat_ctx;
285
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
286
    FILE *logfile;
Fabrice Bellard's avatar
Fabrice Bellard committed
287 288 289 290 291 292 293 294
} 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' */
295
    int64_t sample_index;      /* current sample */
296 297

    int64_t       start;     /* time when read started */
298 299
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
                                is not defined */
300
    int64_t       pts;       /* current pts */
301
    int is_start;            /* is 1 at the start and after a discontinuity */
Fabrice Bellard's avatar
Fabrice Bellard committed
302 303 304 305 306 307
} 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 */
308
    int nb_streams;       /* nb streams we are aware of */
Fabrice Bellard's avatar
Fabrice Bellard committed
309 310
} AVInputFile;

311
#if HAVE_TERMIOS_H
Fabrice Bellard's avatar
Fabrice Bellard committed
312

Fabrice Bellard's avatar
Fabrice Bellard committed
313 314
/* init terminal so that we can grab keys */
static struct termios oldtty;
315
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
316 317 318

static void term_exit(void)
{
319
#if HAVE_TERMIOS_H
Fabrice Bellard's avatar
Fabrice Bellard committed
320
    tcsetattr (0, TCSANOW, &oldtty);
321
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
322 323
}

324
static volatile int received_sigterm = 0;
325 326 327 328 329 330 331 332

static void
sigterm_handler(int sig)
{
    received_sigterm = sig;
    term_exit();
}

Fabrice Bellard's avatar
Fabrice Bellard committed
333 334
static void term_init(void)
{
335
#if HAVE_TERMIOS_H
Fabrice Bellard's avatar
Fabrice Bellard committed
336 337 338 339 340 341 342 343 344 345 346 347 348
    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;
349

Fabrice Bellard's avatar
Fabrice Bellard committed
350
    tcsetattr (0, TCSANOW, &tty);
351 352
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
353

354 355 356 357 358
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
    /*
    register a function to be called at normal program termination
    */
Fabrice Bellard's avatar
Fabrice Bellard committed
359
    atexit(term_exit);
360
#if CONFIG_BEOS_NETSERVER
361 362
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
363 364 365 366 367
}

/* read a key without blocking */
static int read_key(void)
{
368
#if HAVE_TERMIOS_H
369
    int n = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
370
    unsigned char ch;
371
#if !CONFIG_BEOS_NETSERVER
372
    struct timeval tv;
Fabrice Bellard's avatar
Fabrice Bellard committed
373 374 375 376 377 378 379
    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);
380
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
381
    if (n > 0) {
382 383
        n = read(0, &ch, 1);
        if (n == 1)
Fabrice Bellard's avatar
Fabrice Bellard committed
384
            return ch;
385 386

        return n;
Fabrice Bellard's avatar
Fabrice Bellard committed
387
    }
388
#elif HAVE_CONIO_H
389 390
    if(kbhit())
        return(getch());
391
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
392 393 394
    return -1;
}

395 396 397 398 399
static int decode_interrupt_cb(void)
{
    return q_pressed || (q_pressed = read_key() == 'q');
}

400
static int av_exit(int ret)
401 402 403 404 405 406 407 408
{
    int i;

    /* close files */
    for(i=0;i<nb_output_files;i++) {
        /* maybe av_close_output_file ??? */
        AVFormatContext *s = output_files[i];
        int j;
409
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
410 411
            url_fclose(s->pb);
        for(j=0;j<s->nb_streams;j++) {
412
            av_metadata_free(&s->streams[j]->metadata);
413 414 415
            av_free(s->streams[j]->codec);
            av_free(s->streams[j]);
        }
416 417 418 419 420 421 422
        for(j=0;j<s->nb_programs;j++) {
            av_metadata_free(&s->programs[j]->metadata);
        }
        for(j=0;j<s->nb_chapters;j++) {
            av_metadata_free(&s->chapters[j]->metadata);
        }
        av_metadata_free(&s->metadata);
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
        av_free(s);
    }
    for(i=0;i<nb_input_files;i++)
        av_close_input_file(input_files[i]);

    av_free(intra_matrix);
    av_free(inter_matrix);

    if (vstats_file)
        fclose(vstats_file);
    av_free(vstats_filename);

    av_free(opt_names);

    av_free(video_codec_name);
    av_free(audio_codec_name);
    av_free(subtitle_codec_name);

    av_free(video_standard);

443
#if CONFIG_POWERPC_PERF
444
    void powerpc_display_perf_report(void);
445 446 447
    powerpc_display_perf_report();
#endif /* CONFIG_POWERPC_PERF */

448 449 450 451
    for (i=0;i<CODEC_TYPE_NB;i++)
        av_free(avcodec_opts[i]);
    av_free(avformat_opts);
    av_free(sws_opts);
452 453 454 455
    av_free(audio_buf);
    av_free(audio_out);
    av_free(audio_out2);
    av_free(samples);
456

457 458 459 460 461 462 463
    if (received_sigterm) {
        fprintf(stderr,
            "Received signal %d: terminating.\n",
            (int) received_sigterm);
        exit (255);
    }

464 465
    exit(ret); /* not all OS-es handle main() return value */
    return ret;
466 467
}

468
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
Fabrice Bellard's avatar
Fabrice Bellard committed
469
{
470
    int i, err;
Fabrice Bellard's avatar
Fabrice Bellard committed
471
    AVFormatContext *ic;
472
    int nopts = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
473

474 475 476
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
    if (err < 0)
        return err;
Fabrice Bellard's avatar
Fabrice Bellard committed
477 478 479 480
    /* copy stream format */
    s->nb_streams = ic->nb_streams;
    for(i=0;i<ic->nb_streams;i++) {
        AVStream *st;
Michael Niedermayer's avatar
Michael Niedermayer committed
481

482
        // FIXME: a more elegant solution is needed
483
        st = av_mallocz(sizeof(AVStream));
Fabrice Bellard's avatar
Fabrice Bellard committed
484
        memcpy(st, ic->streams[i], sizeof(AVStream));
485 486
        st->codec = avcodec_alloc_context();
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
Fabrice Bellard's avatar
Fabrice Bellard committed
487
        s->streams[i] = st;
488 489 490 491 492 493

        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
            st->stream_copy = 1;
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
            st->stream_copy = 1;

494 495 496 497 498
        if(!st->codec->thread_count)
            st->codec->thread_count = 1;
        if(st->codec->thread_count>1)
            avcodec_thread_init(st->codec, st->codec->thread_count);

499 500
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
            nopts = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
501 502
    }

503 504 505
    if (!nopts)
        s->timestamp = av_gettime();

Fabrice Bellard's avatar
Fabrice Bellard committed
506 507 508 509
    av_close_input_file(ic);
    return 0;
}

510 511 512 513
static double
get_sync_ipts(const AVOutputStream *ost)
{
    const AVInputStream *ist = ost->sync_ist;
514
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
515 516
}

517
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
518 519
    int ret;

520 521 522 523 524 525
    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 & PKT_FLAG_KEY);
526
        if(a>0){
527 528
            av_free_packet(pkt);
            new_pkt.destruct= av_destruct_packet;
529
        } else if(a<0){
530 531 532
            fprintf(stderr, "%s failed for stream %d, codec %s",
                    bsfc->filter->name, pkt->stream_index,
                    avctx->codec ? avctx->codec->name : "copy");
533
            print_error("", a);
534 535
            if (exit_on_error)
                av_exit(1);
536 537 538 539 540 541
        }
        *pkt= new_pkt;

        bsfc= bsfc->next;
    }

542 543 544
    ret= av_interleaved_write_frame(s, pkt);
    if(ret < 0){
        print_error("av_interleaved_write_frame()", ret);
545
        av_exit(1);
546
    }
547 548
}

549
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
Fabrice Bellard's avatar
Fabrice Bellard committed
550

551 552
static void do_audio_out(AVFormatContext *s,
                         AVOutputStream *ost,
Fabrice Bellard's avatar
Fabrice Bellard committed
553 554 555
                         AVInputStream *ist,
                         unsigned char *buf, int size)
{
556
    uint8_t *buftmp;
Michael Niedermayer's avatar
Michael Niedermayer committed
557
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
558

Fabrice Bellard's avatar
Fabrice Bellard committed
559
    int size_out, frame_bytes, ret;
560
    AVCodecContext *enc= ost->st->codec;
561
    AVCodecContext *dec= ist->st->codec;
562 563
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
Fabrice Bellard's avatar
Fabrice Bellard committed
564

565 566 567 568
    /* SC: dynamic allocation of buffers */
    if (!audio_buf)
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
    if (!audio_out)
Michael Niedermayer's avatar
Michael Niedermayer committed
569
        audio_out = av_malloc(audio_out_size);
570 571 572
    if (!audio_buf || !audio_out)
        return;               /* Should signal an error ! */

573 574 575 576
    if (enc->channels != dec->channels)
        ost->audio_resample = 1;

    if (ost->audio_resample && !ost->resample) {
577 578 579 580 581 582
        if (dec->sample_fmt != 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);
583 584 585 586
        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);
587
            av_exit(1);
588 589 590
        }
    }

591
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
592
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
        if (!audio_out2)
            audio_out2 = av_malloc(audio_out_size);
        if (!audio_out2)
            av_exit(1);
        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",
                avcodec_get_sample_fmt_name(dec->sample_fmt),
                avcodec_get_sample_fmt_name(enc->sample_fmt));
            av_exit(1);
        }
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
    }

611
    if(audio_sync_method){
612
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
613
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
614 615
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
616

617 618
        //FIXME resample delay
        if(fabs(delta) > 50){
619
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
620
                if(byte_delta < 0){
621
                    byte_delta= FFMAX(byte_delta, -size);
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645
                    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 + size <= MAX_AUDIO_PACKET_SIZE)
                        ist->is_start=0;
                    else
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;

                    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){
646
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
647 648 649
                assert(ost->audio_resample);
                if(verbose > 2)
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
650
//                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));
651 652
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
            }
653
        }
654
    }else
655
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
656
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
Fabrice Bellard's avatar
Fabrice Bellard committed
657 658 659

    if (ost->audio_resample) {
        buftmp = audio_buf;
660
        size_out = audio_resample(ost->resample,
Fabrice Bellard's avatar
Fabrice Bellard committed
661
                                  (short *)buftmp, (short *)buf,
662 663
                                  size / (ist->st->codec->channels * isize));
        size_out = size_out * enc->channels * osize;
Fabrice Bellard's avatar
Fabrice Bellard committed
664 665 666 667 668
    } else {
        buftmp = buf;
        size_out = size;
    }

669
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
670 671
        const void *ibuf[6]= {buftmp};
        void *obuf[6]= {audio_out2};
672 673
        int istride[6]= {isize};
        int ostride[6]= {osize};
674 675 676
        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");
677 678
            if (exit_on_error)
                av_exit(1);
679 680 681
            return;
        }
        buftmp = audio_out2;
682
        size_out = len*osize;
683 684
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
685
    /* now encode as many frames as possible */
686
    if (enc->frame_size > 1) {
Fabrice Bellard's avatar
Fabrice Bellard committed
687
        /* output resampled raw samples */
688
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
689 690 691
            fprintf(stderr, "av_fifo_realloc2() failed\n");
            av_exit(1);
        }
692
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
Fabrice Bellard's avatar
Fabrice Bellard committed
693

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

696
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
697 698 699
            AVPacket pkt;
            av_init_packet(&pkt);

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

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

704
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
705
                                       (short *)audio_buf);
706 707 708 709
            if (ret < 0) {
                fprintf(stderr, "Audio encoding failed\n");
                av_exit(1);
            }
710
            audio_size += ret;
711 712 713
            pkt.stream_index= ost->index;
            pkt.data= audio_out;
            pkt.size= ret;
714
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
715
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
716
            pkt.flags |= PKT_FLAG_KEY;
717
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
718

719
            ost->sync_opts += enc->frame_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
720 721
        }
    } else {
722
        AVPacket pkt;
723
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
724
        av_init_packet(&pkt);
725

726
        ost->sync_opts += size_out / (osize * enc->channels);
727

728
        /* output a pcm frame */
729 730 731 732 733
        /* determine the size of the coded buffer */
        size_out /= osize;
        if (coded_bps)
            size_out *= coded_bps;

734
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
735
        ret = avcodec_encode_audio(enc, audio_out, size_out,
736
                                   (short *)buftmp);
737 738 739 740
        if (ret < 0) {
            fprintf(stderr, "Audio encoding failed\n");
            av_exit(1);
        }
741
        audio_size += ret;
742 743 744
        pkt.stream_index= ost->index;
        pkt.data= audio_out;
        pkt.size= ret;
745
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
746
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
747
        pkt.flags |= PKT_FLAG_KEY;
748
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
Fabrice Bellard's avatar
Fabrice Bellard committed
749 750 751
    }
}

752 753 754 755 756
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
{
    AVCodecContext *dec;
    AVPicture *picture2;
    AVPicture picture_tmp;
757
    uint8_t *buf = 0;
758

759
    dec = ist->st->codec;
760 761

    /* deinterlace : must be done before any resize */
762
    if (do_deinterlace) {
763 764 765 766 767 768 769
        int size;

        /* create temporary picture */
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
        buf = av_malloc(size);
        if (!buf)
            return;
770

771 772 773
        picture2 = &picture_tmp;
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);

Ramiro Polla's avatar
Ramiro Polla committed
774 775 776 777 778 779 780 781
        if(avpicture_deinterlace(picture2, picture,
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
            /* if error, do not deinterlace */
            fprintf(stderr, "Deinterlacing failed\n");
            av_free(buf);
            buf = NULL;
            picture2 = picture;
        }
782 783 784 785 786 787 788 789 790
    } else {
        picture2 = picture;
    }

    if (picture != picture2)
        *picture = *picture2;
    *bufp = buf;
}

791 792
/* we begin to correct av delay at this threshold */
#define AV_DELAY_MAX 0.100
Fabrice Bellard's avatar
Fabrice Bellard committed
793

794 795
static void do_subtitle_out(AVFormatContext *s,
                            AVOutputStream *ost,
796 797 798 799 800
                            AVInputStream *ist,
                            AVSubtitle *sub,
                            int64_t pts)
{
    static uint8_t *subtitle_out = NULL;
801
    int subtitle_out_max_size = 1024 * 1024;
802 803 804 805 806 807
    int subtitle_out_size, nb, i;
    AVCodecContext *enc;
    AVPacket pkt;

    if (pts == AV_NOPTS_VALUE) {
        fprintf(stderr, "Subtitle packets must have a pts\n");
808 809
        if (exit_on_error)
            av_exit(1);
810 811 812
        return;
    }

813
    enc = ost->st->codec;
814 815 816 817 818 819 820 821 822 823 824 825 826 827

    if (!subtitle_out) {
        subtitle_out = av_malloc(subtitle_out_max_size);
    }

    /* Note: DVB subtitle need one packet to draw them and one other
       packet to clear them */
    /* XXX: signal it in the codec context ? */
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
        nb = 2;
    else
        nb = 1;

    for(i = 0; i < nb; i++) {
828
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
829 830 831 832
        // start_display_time is required to be 0
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
        sub->end_display_time -= sub->start_display_time;
        sub->start_display_time = 0;
833
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
834
                                                    subtitle_out_max_size, sub);
835 836 837 838
        if (subtitle_out_size < 0) {
            fprintf(stderr, "Subtitle encoding failed\n");
            av_exit(1);
        }
839

840 841 842 843
        av_init_packet(&pkt);
        pkt.stream_index = ost->index;
        pkt.data = subtitle_out;
        pkt.size = subtitle_out_size;
844
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
845 846 847 848 849 850 851 852
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
            /* XXX: the pts correction is handled here. Maybe handling
               it in the codec would be better */
            if (i == 0)
                pkt.pts += 90 * sub->start_display_time;
            else
                pkt.pts += 90 * sub->end_display_time;
        }
853
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
854 855 856
    }
}

857
static int bit_buffer_size= 1024*256;
858
static uint8_t *bit_buffer= NULL;
859

860 861
static void do_video_out(AVFormatContext *s,
                         AVOutputStream *ost,
Fabrice Bellard's avatar
Fabrice Bellard committed
862
                         AVInputStream *ist,
863
                         AVFrame *in_picture,
864
                         int *frame_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
865
{
866
    int nb_frames, i, ret;
867
    int64_t topBand, bottomBand, leftBand, rightBand;
868
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
869
    AVFrame picture_crop_temp, picture_pad_temp;
870
    AVCodecContext *enc, *dec;
871

872
    avcodec_get_frame_defaults(&picture_crop_temp);
873
    avcodec_get_frame_defaults(&picture_pad_temp);
874

875 876
    enc = ost->st->codec;
    dec = ist->st->codec;
Fabrice Bellard's avatar
Fabrice Bellard committed
877

878 879 880
    /* by default, we output a single frame */
    nb_frames = 1;

881 882
    *frame_size = 0;

883
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
884
        double vdelta;
885
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
886 887 888
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
        if (vdelta < -1.1)
            nb_frames = 0;
889 890 891 892
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
            if(vdelta<=-0.6){
                nb_frames=0;
            }else if(vdelta>0.6)
893
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
894
        }else if (vdelta > 1.1)
895
            nb_frames = lrintf(vdelta);
896
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
897 898 899 900
        if (nb_frames == 0){
            ++nb_frames_drop;
            if (verbose>2)
                fprintf(stderr, "*** drop!\n");
901 902
        }else if (nb_frames > 1) {
            nb_frames_dup += nb_frames;
903
            if (verbose>2)
904
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
905 906
        }
    }else
907
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
908

909
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
910
    if (nb_frames <= 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
911
        return;
912

913
    if (ost->video_crop) {
914
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
915
            fprintf(stderr, "error cropping picture\n");
916 917
            if (exit_on_error)
                av_exit(1);
918
            return;
919 920
        }
        formatted_picture = &picture_crop_temp;
921 922
    } else {
        formatted_picture = in_picture;
923 924 925 926 927 928 929 930
    }

    final_picture = formatted_picture;
    padding_src = formatted_picture;
    resampling_dst = &ost->pict_tmp;
    if (ost->video_pad) {
        final_picture = &ost->pict_tmp;
        if (ost->video_resample) {
931
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
932
                fprintf(stderr, "error padding picture\n");
933 934
                if (exit_on_error)
                    av_exit(1);
935
                return;
936 937 938 939 940
            }
            resampling_dst = &picture_pad_temp;
        }
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
941
    if (ost->video_resample) {
942
        padding_src = NULL;
943
        final_picture = &ost->pict_tmp;
944
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
945 946
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
947

948
            fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
            /* keep bands proportional to the frame size */
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;

            /* sanity check to ensure no bad band sizes sneak in */
            assert(topBand    <= INT_MAX && topBand    >= 0);
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
            assert(rightBand  <= INT_MAX && rightBand  >= 0);

            ost->topBand    = topBand;
            ost->bottomBand = bottomBand;
            ost->leftBand   = leftBand;
            ost->rightBand  = rightBand;

            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
968
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985

            /* initialize a new scaler context */
            sws_freeContext(ost->img_resample_ctx);
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
            ost->img_resample_ctx = sws_getContext(
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
                ist->st->codec->pix_fmt,
                ost->st->codec->width  - (ost->padleft  + ost->padright),
                ost->st->codec->height - (ost->padtop   + ost->padbottom),
                ost->st->codec->pix_fmt,
                sws_flags, NULL, NULL, NULL);
            if (ost->img_resample_ctx == NULL) {
                fprintf(stderr, "Cannot get resampling context\n");
                av_exit(1);
            }
        }
986 987
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
988
    }
989 990

    if (ost->video_pad) {
991
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
992 993
                enc->height, enc->width, enc->pix_fmt,
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
Fabrice Bellard's avatar
Fabrice Bellard committed
994
    }
995

Fabrice Bellard's avatar
Fabrice Bellard committed
996
    /* duplicates frame if needed */
997
    for(i=0;i<nb_frames;i++) {
998 999 1000 1001
        AVPacket pkt;
        av_init_packet(&pkt);
        pkt.stream_index= ost->index;

1002 1003 1004 1005
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
            /* raw pictures are written as AVPicture structure to
               avoid any copies. We support temorarily the older
               method. */
1006
            AVFrame* old_frame = enc->coded_frame;
1007
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1008 1009
            pkt.data= (uint8_t *)final_picture;
            pkt.size=  sizeof(AVPicture);
1010 1011
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
            pkt.flags |= PKT_FLAG_KEY;
1012

1013
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1014
            enc->coded_frame = old_frame;
1015
        } else {
1016
            AVFrame big_picture;
1017 1018

            big_picture= *final_picture;
1019 1020 1021
            /* better than nothing: use input picture interlaced
               settings */
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1022
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1023 1024 1025
                if(top_field_first == -1)
                    big_picture.top_field_first = in_picture->top_field_first;
                else
Michael Niedermayer's avatar
Michael Niedermayer committed
1026
                    big_picture.top_field_first = top_field_first;
1027
            }
1028

Fabrice Bellard's avatar
Fabrice Bellard committed
1029 1030 1031
            /* handles sameq here. This is not correct because it may
               not be a global option */
            if (same_quality) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1032 1033 1034
                big_picture.quality = ist->st->quality;
            }else
                big_picture.quality = ost->st->quality;
1035 1036
            if(!me_threshold)
                big_picture.pict_type = 0;
1037
//            big_picture.pts = AV_NOPTS_VALUE;
1038 1039
            big_picture.pts= ost->sync_opts;
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1040
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1041
            ret = avcodec_encode_video(enc,
1042
                                       bit_buffer, bit_buffer_size,
Michael Niedermayer's avatar
Michael Niedermayer committed
1043
                                       &big_picture);
1044
            if (ret < 0) {
1045
                fprintf(stderr, "Video encoding failed\n");
1046
                av_exit(1);
1047
            }
1048

1049
            if(ret>0){
1050
                pkt.data= bit_buffer;
1051
                pkt.size= ret;
1052
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1053
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1054
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1055 1056
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1057

1058
                if(enc->coded_frame->key_frame)
1059
                    pkt.flags |= PKT_FLAG_KEY;
1060
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1061
                *frame_size = ret;
1062
                video_size += ret;
1063 1064
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
                //        enc->frame_number-1, ret, enc->pict_type);
1065 1066 1067 1068
                /* if two pass, output log */
                if (ost->logfile && enc->stats_out) {
                    fprintf(ost->logfile, "%s", enc->stats_out);
                }
1069
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
1070
        }
1071
        ost->sync_opts++;
1072
        ost->frame_number++;
Fabrice Bellard's avatar
Fabrice Bellard committed
1073 1074 1075
    }
}

1076
static double psnr(double d){
1077
    return -10.0*log(d)/log(10.0);
1078 1079
}

1080
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1081
                           int frame_size)
1082 1083 1084 1085
{
    AVCodecContext *enc;
    int frame_number;
    double ti1, bitrate, avg_bitrate;
1086

1087
    /* this is executed just the first time do_video_stats is called */
1088 1089 1090
    if (!vstats_file) {
        vstats_file = fopen(vstats_filename, "w");
        if (!vstats_file) {
1091
            perror("fopen");
1092
            av_exit(1);
1093 1094 1095
        }
    }

1096
    enc = ost->st->codec;
1097
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1098
        frame_number = ost->frame_number;
1099
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1100
        if (enc->flags&CODEC_FLAG_PSNR)
1101
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1102

1103
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1104
        /* compute pts value */
1105
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1106 1107
        if (ti1 < 0.01)
            ti1 = 0.01;
1108

1109
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1110
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1111
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1112
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1113
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1114
    }
1115 1116
}

1117
static void print_report(AVFormatContext **output_files,
1118 1119
                         AVOutputStream **ost_table, int nb_ostreams,
                         int is_last_report)
1120 1121 1122
{
    char buf[1024];
    AVOutputStream *ost;
1123
    AVFormatContext *oc;
1124
    int64_t total_size;
1125 1126 1127
    AVCodecContext *enc;
    int frame_number, vid, i;
    double bitrate, ti1, pts;
1128
    static int64_t last_time = -1;
1129
    static int qp_histogram[52];
1130

1131
    if (!is_last_report) {
1132
        int64_t cur_time;
1133 1134 1135 1136 1137
        /* display the report every 0.5 seconds */
        cur_time = av_gettime();
        if (last_time == -1) {
            last_time = cur_time;
            return;
1138
        }
1139 1140 1141 1142 1143
        if ((cur_time - last_time) < 500000)
            return;
        last_time = cur_time;
    }

1144

1145 1146
    oc = output_files[0];

1147
    total_size = url_fsize(oc->pb);
1148
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1149
        total_size= url_ftell(oc->pb);
1150

1151 1152 1153 1154 1155
    buf[0] = '\0';
    ti1 = 1e10;
    vid = 0;
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
1156
        enc = ost->st->codec;
1157
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1158
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1159
                     !ost->st->stream_copy ?
1160
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1161
        }
1162
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1163 1164
            float t = (av_gettime()-timer_start) / 1000000.0;

1165
            frame_number = ost->frame_number;
1166 1167
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1168
                     !ost->st->stream_copy ?
1169
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1170
            if(is_last_report)
1171
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1172
            if(qp_hist){
1173 1174
                int j;
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1175
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1176 1177 1178 1179
                    qp_histogram[qp]++;
                for(j=0; j<32; j++)
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
            }
1180 1181 1182 1183 1184
            if (enc->flags&CODEC_FLAG_PSNR){
                int j;
                double error, error_sum=0;
                double scale, scale_sum=0;
                char type[3]= {'Y','U','V'};
1185
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
                for(j=0; j<3; j++){
                    if(is_last_report){
                        error= enc->error[j];
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
                    }else{
                        error= enc->coded_frame->error[j];
                        scale= enc->width*enc->height*255.0*255.0;
                    }
                    if(j) scale/=4;
                    error_sum += error;
                    scale_sum += scale;
1197
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1198
                }
1199
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1200
            }
1201 1202 1203
            vid = 1;
        }
        /* compute min output value */
1204
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1205
        if ((pts < ti1) && (pts > 0))
1206 1207 1208 1209
            ti1 = pts;
    }
    if (ti1 < 0.01)
        ti1 = 0.01;
1210

1211 1212
    if (verbose || is_last_report) {
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1213 1214

        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1215
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1216
            (double)total_size / 1024, ti1, bitrate);
1217

1218 1219 1220
        if (verbose > 1)
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
                  nb_frames_dup, nb_frames_drop);
1221

1222 1223 1224
        if (verbose >= 0)
            fprintf(stderr, "%s    \r", buf);

1225 1226
        fflush(stderr);
    }
1227

1228 1229
    if (is_last_report && verbose >= 0){
        int64_t raw= audio_size + video_size + extra_size;
1230
        fprintf(stderr, "\n");
1231 1232 1233 1234 1235 1236 1237
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
                video_size/1024.0,
                audio_size/1024.0,
                extra_size/1024.0,
                100.0*(total_size - raw)/raw
        );
    }
1238 1239
}

1240 1241 1242
/* pkt = NULL means EOF (needed to flush decoder buffers) */
static int output_packet(AVInputStream *ist, int ist_index,
                         AVOutputStream **ost_table, int nb_ostreams,
1243
                         const AVPacket *pkt)
1244 1245 1246
{
    AVFormatContext *os;
    AVOutputStream *ost;
1247
    int ret, i;
1248 1249 1250 1251
    uint8_t *data_buf;
    int data_size, got_picture;
    AVFrame picture;
    void *buffer_to_free;
1252
    static unsigned int samples_size= 0;
1253 1254
    AVSubtitle subtitle, *subtitle_to_free;
    int got_subtitle;
1255 1256
    AVPacket avpkt;

1257 1258 1259
    if(ist->next_pts == AV_NOPTS_VALUE)
        ist->next_pts= ist->pts;

1260 1261
    if (pkt == NULL) {
        /* EOF handling */
1262
        av_init_packet(&avpkt);
1263 1264
        avpkt.data = NULL;
        avpkt.size = 0;
1265
        goto handle_eof;
1266 1267
    } else {
        avpkt = *pkt;
1268 1269
    }

1270 1271 1272
    if(pkt->dts != AV_NOPTS_VALUE)
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);

1273
    //while we have more to decode or while the decoder did output something on EOF
1274
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1275
    handle_eof:
1276
        ist->pts= ist->next_pts;
1277

1278
        if(avpkt.size && avpkt.size != pkt->size && verbose>0)
1279 1280
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);

1281 1282 1283
        /* decode the packet if needed */
        data_buf = NULL; /* fail safe */
        data_size = 0;
1284
        subtitle_to_free = NULL;
1285
        if (ist->decoding_needed) {
1286
            switch(ist->st->codec->codec_type) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1287
            case CODEC_TYPE_AUDIO:{
1288 1289 1290 1291 1292
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
                    av_free(samples);
                    samples= av_malloc(samples_size);
                }
1293
                data_size= samples_size;
1294 1295
                    /* XXX: could avoid copy if PCM 16 bits with same
                       endianness as CPU */
1296 1297
                ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
                                            &avpkt);
1298 1299
                if (ret < 0)
                    goto fail_decode;
1300 1301
                avpkt.data += ret;
                avpkt.size -= ret;
1302 1303 1304 1305 1306 1307 1308
                /* Some bug in mpeg audio decoder gives */
                /* data_size < 0, it seems they are overflows */
                if (data_size <= 0) {
                    /* no audio frame */
                    continue;
                }
                data_buf = (uint8_t *)samples;
1309
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1310
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
Michael Niedermayer's avatar
Michael Niedermayer committed
1311
                break;}
1312
            case CODEC_TYPE_VIDEO:
1313
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1314
                    /* XXX: allocate picture correctly */
1315 1316
                    avcodec_get_frame_defaults(&picture);

1317 1318
                    ret = avcodec_decode_video2(ist->st->codec,
                                                &picture, &got_picture, &avpkt);
1319
                    ist->st->quality= picture.quality;
1320
                    if (ret < 0)
1321 1322 1323 1324 1325
                        goto fail_decode;
                    if (!got_picture) {
                        /* no picture yet */
                        goto discard_packet;
                    }
1326
                    if (ist->st->codec->time_base.num != 0) {
1327
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1328
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1329
                                          ist->st->codec->time_base.num * ticks) /
1330
                            ist->st->codec->time_base.den;
1331
                    }
1332
                    avpkt.size = 0;
1333
                    break;
1334
            case CODEC_TYPE_SUBTITLE:
1335 1336
                ret = avcodec_decode_subtitle2(ist->st->codec,
                                               &subtitle, &got_subtitle, &avpkt);
1337
                if (ret < 0)
1338
                    goto fail_decode;
1339 1340
                if (!got_subtitle) {
                    goto discard_packet;
1341
                }
1342
                subtitle_to_free = &subtitle;
1343
                avpkt.size = 0;
1344 1345 1346 1347 1348
                break;
            default:
                goto fail_decode;
            }
        } else {
1349 1350 1351
            switch(ist->st->codec->codec_type) {
            case CODEC_TYPE_AUDIO:
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1352
                    ist->st->codec->sample_rate;
1353 1354 1355
                break;
            case CODEC_TYPE_VIDEO:
                if (ist->st->codec->time_base.num != 0) {
1356
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1357
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1358
                                      ist->st->codec->time_base.num * ticks) /
1359
                        ist->st->codec->time_base.den;
1360
                }
1361
                break;
1362
            }
1363 1364 1365 1366
            data_buf = avpkt.data;
            data_size = avpkt.size;
            ret = avpkt.size;
            avpkt.size = 0;
1367
        }
1368

1369 1370 1371 1372 1373
        buffer_to_free = NULL;
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
            pre_process_video_frame(ist, (AVPicture *)&picture,
                                    &buffer_to_free);
        }
1374

1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
        // preprocess audio (volume)
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
            if (audio_volume != 256) {
                short *volp;
                volp = samples;
                for(i=0;i<(data_size / sizeof(short));i++) {
                    int v = ((*volp) * audio_volume + 128) >> 8;
                    if (v < -32768) v = -32768;
                    if (v >  32767) v = 32767;
                    *volp++ = v;
1385 1386
                }
            }
1387
        }
1388

1389
        /* frame rate emulation */
1390
        if (rate_emu) {
1391
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1392 1393 1394 1395
            int64_t now = av_gettime() - ist->start;
            if (pts > now)
                usleep(pts - now);
        }
1396

1397 1398 1399 1400 1401
        /* if output time reached then transcode raw format,
           encode packets and output them */
        if (start_time == 0 || ist->pts >= start_time)
            for(i=0;i<nb_ostreams;i++) {
                int frame_size;
1402

1403 1404 1405
                ost = ost_table[i];
                if (ost->source_index == ist_index) {
                    os = output_files[ost->file_index];
1406

1407 1408 1409 1410 1411 1412 1413 1414 1415 1416
                    /* set the input output pts pairs */
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;

                    if (ost->encoding_needed) {
                        switch(ost->st->codec->codec_type) {
                        case CODEC_TYPE_AUDIO:
                            do_audio_out(os, ost, ist, data_buf, data_size);
                            break;
                        case CODEC_TYPE_VIDEO:
                            do_video_out(os, ost, ist, &picture, &frame_size);
1417
                            if (vstats_filename && frame_size)
1418 1419 1420 1421 1422 1423 1424
                                do_video_stats(os, ost, frame_size);
                            break;
                        case CODEC_TYPE_SUBTITLE:
                            do_subtitle_out(os, ost, ist, &subtitle,
                                            pkt->pts);
                            break;
                        default:
1425
                            abort();
1426 1427 1428 1429
                        }
                    } else {
                        AVFrame avframe; //FIXME/XXX remove this
                        AVPacket opkt;
1430 1431
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);

1432 1433
                        av_init_packet(&opkt);

1434
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1435 1436
                            continue;

1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
                        /* no reencoding needed : output the packet directly */
                        /* force the input stream PTS */

                        avcodec_get_frame_defaults(&avframe);
                        ost->st->codec->coded_frame= &avframe;
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;

                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
                            audio_size += data_size;
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
                            video_size += data_size;
                            ost->sync_opts++;
                        }

                        opkt.stream_index= ost->index;
                        if(pkt->pts != AV_NOPTS_VALUE)
1453
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1454 1455 1456
                        else
                            opkt.pts= AV_NOPTS_VALUE;

Baptiste Coudurier's avatar
Baptiste Coudurier committed
1457
                        if (pkt->dts == AV_NOPTS_VALUE)
1458
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1459 1460
                        else
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1461
                        opkt.dts -= ost_tb_start_time;
1462

1463
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1464 1465 1466
                        opkt.flags= pkt->flags;

                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1467
                        if(ost->st->codec->codec_id != CODEC_ID_H264) {
1468 1469
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
                            opkt.destruct= av_destruct_packet;
1470 1471 1472 1473
                        } else {
                            opkt.data = data_buf;
                            opkt.size = data_size;
                        }
1474

1475
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1476 1477 1478
                        ost->st->codec->frame_number++;
                        ost->frame_number++;
                        av_free_packet(&opkt);
1479 1480
                    }
                }
1481 1482 1483 1484 1485 1486
            }
        av_free(buffer_to_free);
        /* XXX: allocate the subtitles in the codec ? */
        if (subtitle_to_free) {
            if (subtitle_to_free->rects != NULL) {
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1487 1488
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1489
                    av_freep(&subtitle_to_free->rects[i]);
1490
                }
1491
                av_freep(&subtitle_to_free->rects);
1492
            }
1493 1494
            subtitle_to_free->num_rects = 0;
            subtitle_to_free = NULL;
1495
        }
1496
    }
1497
 discard_packet:
1498 1499
    if (pkt == NULL) {
        /* EOF handling */
1500

1501 1502 1503
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            if (ost->source_index == ist_index) {
1504
                AVCodecContext *enc= ost->st->codec;
1505
                os = output_files[ost->file_index];
1506

1507
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1508
                    continue;
1509
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1510 1511 1512 1513 1514
                    continue;

                if (ost->encoding_needed) {
                    for(;;) {
                        AVPacket pkt;
1515
                        int fifo_bytes;
1516 1517
                        av_init_packet(&pkt);
                        pkt.stream_index= ost->index;
1518

1519
                        switch(ost->st->codec->codec_type) {
1520
                        case CODEC_TYPE_AUDIO:
1521
                            fifo_bytes = av_fifo_size(ost->fifo);
1522 1523
                            ret = 0;
                            /* encode any samples remaining in fifo */
1524
                            if (fifo_bytes > 0) {
1525
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1526
                                int fs_tmp = enc->frame_size;
1527

1528
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1529 1530 1531 1532 1533 1534 1535 1536 1537
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
                                } else { /* pad */
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
                                    if (samples_size < frame_bytes)
                                        av_exit(1);
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
                                }

Baptiste Coudurier's avatar
Baptiste Coudurier committed
1538
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1539 1540
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
                                                          ost->st->time_base.num, enc->sample_rate);
1541
                                enc->frame_size = fs_tmp;
Michael Niedermayer's avatar
Michael Niedermayer committed
1542 1543
                            }
                            if(ret <= 0) {
1544 1545
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
                            }
1546 1547 1548 1549
                            if (ret < 0) {
                                fprintf(stderr, "Audio encoding failed\n");
                                av_exit(1);
                            }
1550 1551 1552 1553
                            audio_size += ret;
                            pkt.flags |= PKT_FLAG_KEY;
                            break;
                        case CODEC_TYPE_VIDEO:
1554
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1555 1556 1557 1558
                            if (ret < 0) {
                                fprintf(stderr, "Video encoding failed\n");
                                av_exit(1);
                            }
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568
                            video_size += ret;
                            if(enc->coded_frame && enc->coded_frame->key_frame)
                                pkt.flags |= PKT_FLAG_KEY;
                            if (ost->logfile && enc->stats_out) {
                                fprintf(ost->logfile, "%s", enc->stats_out);
                            }
                            break;
                        default:
                            ret=-1;
                        }
1569

1570 1571
                        if(ret<=0)
                            break;
1572
                        pkt.data= bit_buffer;
1573
                        pkt.size= ret;
1574
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1575
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1576
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1577 1578 1579 1580 1581
                    }
                }
            }
        }
    }
1582

1583 1584 1585 1586 1587
    return 0;
 fail_decode:
    return -1;
}

1588 1589 1590 1591 1592 1593
static void print_sdp(AVFormatContext **avc, int n)
{
    char sdp[2048];

    avf_sdp_create(avc, n, sdp, sizeof(sdp));
    printf("SDP:\n%s\n", sdp);
Luca Barbato's avatar
Luca Barbato committed
1594
    fflush(stdout);
1595
}
1596

1597 1598 1599 1600 1601 1602 1603
static int stream_index_from_inputs(AVFormatContext **input_files,
                                    int nb_input_files,
                                    AVInputFile *file_table,
                                    AVInputStream **ist_table,
                                    enum CodecType type,
                                    int programid)
{
1604
    int p, q, z;
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
    for(z=0; z<nb_input_files; z++) {
        AVFormatContext *ic = input_files[z];
        for(p=0; p<ic->nb_programs; p++) {
            AVProgram *program = ic->programs[p];
            if(program->id != programid)
                continue;
            for(q=0; q<program->nb_stream_indexes; q++) {
                int sidx = program->stream_index[q];
                int ris = file_table[z].ist_index + sidx;
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
                    return ris;
            }
        }
    }

    return -1;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
1623 1624 1625 1626 1627 1628 1629 1630 1631
/*
 * 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)
{
1632
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1633 1634 1635 1636
    AVFormatContext *is, *os;
    AVCodecContext *codec, *icodec;
    AVOutputStream *ost, **ost_table = NULL;
    AVInputStream *ist, **ist_table = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
1637
    AVInputFile *file_table;
1638
    char error[1024];
1639
    int key;
1640
    int want_sdp = 1;
1641 1642
    uint8_t no_packet[MAX_FILES]={0};
    int no_packet_count=0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1643

1644
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
Fabrice Bellard's avatar
Fabrice Bellard committed
1645 1646
    if (!file_table)
        goto fail;
1647

Fabrice Bellard's avatar
Fabrice Bellard committed
1648 1649 1650 1651 1652
    /* input stream init */
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        file_table[i].ist_index = j;
1653
        file_table[i].nb_streams = is->nb_streams;
Fabrice Bellard's avatar
Fabrice Bellard committed
1654 1655 1656 1657 1658 1659
        j += is->nb_streams;
    }
    nb_istreams = j;

    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
    if (!ist_table)
Fabrice Bellard's avatar
Fabrice Bellard committed
1660
        goto fail;
1661

Fabrice Bellard's avatar
Fabrice Bellard committed
1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
    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) */
1678

1679
            if (rate_emu) {
1680 1681
                ist->start = av_gettime();
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
1682 1683 1684 1685 1686 1687 1688
        }
    }

    /* output stream init */
    nb_ostreams = 0;
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
1689
        if (!os->nb_streams) {
1690 1691
            dump_format(output_files[i], i, output_files[i]->filename, 1);
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1692
            av_exit(1);
1693
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1694 1695 1696 1697
        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");
1698
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1699 1700
    }

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

1706 1707 1708
        if (fi < 0 || fi > nb_input_files - 1 ||
            si < 0 || si > file_table[fi].nb_streams - 1) {
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1709
            av_exit(1);
1710
        }
1711 1712 1713 1714 1715
        fi = stream_maps[i].sync_file_index;
        si = stream_maps[i].sync_stream_index;
        if (fi < 0 || fi > nb_input_files - 1 ||
            si < 0 || si > file_table[fi].nb_streams - 1) {
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1716
            av_exit(1);
1717
        }
1718
    }
1719

Fabrice Bellard's avatar
Fabrice Bellard committed
1720 1721 1722 1723 1724 1725 1726 1727 1728
    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;
    }
1729

Fabrice Bellard's avatar
Fabrice Bellard committed
1730 1731 1732
    n = 0;
    for(k=0;k<nb_output_files;k++) {
        os = output_files[k];
1733
        for(i=0;i<os->nb_streams;i++,n++) {
Fabrice Bellard's avatar
Fabrice Bellard committed
1734
            int found;
1735
            ost = ost_table[n];
Fabrice Bellard's avatar
Fabrice Bellard committed
1736 1737 1738 1739
            ost->file_index = k;
            ost->index = i;
            ost->st = os->streams[i];
            if (nb_stream_maps > 0) {
1740 1741
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
                    stream_maps[n].stream_index;
1742

1743
                /* Sanity check that the stream types match */
1744
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1745 1746
                    int i= ost->file_index;
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1747
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1748
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1749
                        ost->file_index, ost->index);
1750
                    av_exit(1);
1751
                }
1752

Fabrice Bellard's avatar
Fabrice Bellard committed
1753
            } else {
1754 1755 1756 1757 1758 1759 1760 1761
                if(opt_programid) {
                    found = 0;
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
                    if(j != -1) {
                        ost->source_index = j;
                        found = 1;
                    }
                } else {
1762 1763
                    /* get corresponding input stream index : we select the first one with the right type */
                    found = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1764 1765
                    for(j=0;j<nb_istreams;j++) {
                        ist = ist_table[j];
1766 1767
                        if (ist->discard &&
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
Fabrice Bellard's avatar
Fabrice Bellard committed
1768 1769
                            ost->source_index = j;
                            found = 1;
1770
                            break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1771 1772
                        }
                    }
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784
                }

                if (!found) {
                    if(! opt_programid) {
                        /* try again and reuse existing stream */
                        for(j=0;j<nb_istreams;j++) {
                            ist = ist_table[j];
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
                                ost->source_index = j;
                                found = 1;
                            }
                        }
1785
                    }
Fabrice Bellard's avatar
Fabrice Bellard committed
1786
                    if (!found) {
1787 1788
                        int i= ost->file_index;
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1789 1790
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
                                ost->file_index, ost->index);
1791
                        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1792 1793 1794 1795 1796
                    }
                }
            }
            ist = ist_table[ost->source_index];
            ist->discard = 0;
1797
            ost->sync_ist = (nb_stream_maps > 0) ?
1798 1799
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
                         stream_maps[n].sync_stream_index] : ist;
Fabrice Bellard's avatar
Fabrice Bellard committed
1800 1801 1802 1803 1804
        }
    }

    /* for each output stream, we compute the right encoding parameters */
    for(i=0;i<nb_ostreams;i++) {
1805
        AVMetadataTag *lang;
Fabrice Bellard's avatar
Fabrice Bellard committed
1806
        ost = ost_table[i];
1807
        os = output_files[ost->file_index];
Fabrice Bellard's avatar
Fabrice Bellard committed
1808 1809
        ist = ist_table[ost->source_index];

1810 1811
        codec = ost->st->codec;
        icodec = ist->st->codec;
Fabrice Bellard's avatar
Fabrice Bellard committed
1812

1813 1814 1815
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1816

1817
        ost->st->disposition = ist->st->disposition;
1818
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1819
        codec->chroma_sample_location = icodec->chroma_sample_location;
1820

1821 1822 1823 1824
        if (ost->st->stream_copy) {
            /* if stream_copy is selected, no need to decode or encode */
            codec->codec_id = icodec->codec_id;
            codec->codec_type = icodec->codec_type;
1825 1826 1827 1828 1829 1830 1831 1832

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

1833
            codec->bit_rate = icodec->bit_rate;
1834 1835
            codec->extradata= icodec->extradata;
            codec->extradata_size= icodec->extradata_size;
1836
            if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
1837
                codec->time_base = icodec->time_base;
1838 1839
                codec->time_base.num *= icodec->ticks_per_frame;
            }else
1840
                codec->time_base = ist->st->time_base;
1841 1842
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
1843 1844 1845 1846
                if(audio_volume != 256) {
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
                    av_exit(1);
                }
1847
                codec->channel_layout = icodec->channel_layout;
1848 1849
                codec->sample_rate = icodec->sample_rate;
                codec->channels = icodec->channels;
1850
                codec->frame_size = icodec->frame_size;
1851
                codec->block_align= icodec->block_align;
1852 1853
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
                    codec->block_align= 0;
1854 1855
                if(codec->codec_id == CODEC_ID_AC3)
                    codec->block_align= 0;
1856 1857
                break;
            case CODEC_TYPE_VIDEO:
1858
                codec->pix_fmt = icodec->pix_fmt;
1859 1860
                codec->width = icodec->width;
                codec->height = icodec->height;
1861
                codec->has_b_frames = icodec->has_b_frames;
1862
                break;
1863
            case CODEC_TYPE_SUBTITLE:
1864 1865
                codec->width = icodec->width;
                codec->height = icodec->height;
1866
                break;
1867
            default:
1868
                abort();
1869 1870 1871 1872
            }
        } else {
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
1873 1874
                ost->fifo= av_fifo_alloc(1024);
                if(!ost->fifo)
Fabrice Bellard's avatar
Fabrice Bellard committed
1875
                    goto fail;
1876
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1877 1878
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
                icodec->request_channels = codec->channels;
Fabrice Bellard's avatar
Fabrice Bellard committed
1879 1880
                ist->decoding_needed = 1;
                ost->encoding_needed = 1;
1881 1882
                break;
            case CODEC_TYPE_VIDEO:
1883 1884 1885 1886
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
                    av_exit(1);
                }
1887 1888 1889 1890 1891 1892 1893
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
                ost->video_resample = ((codec->width != icodec->width -
                                (frame_leftBand + frame_rightBand) +
                                (frame_padleft + frame_padright)) ||
                        (codec->height != icodec->height -
                                (frame_topBand  + frame_bottomBand) +
1894 1895
                                (frame_padtop + frame_padbottom)) ||
                        (codec->pix_fmt != icodec->pix_fmt));
1896
                if (ost->video_crop) {
1897 1898 1899 1900
                    ost->topBand    = ost->original_topBand    = frame_topBand;
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
1901 1902
                }
                if (ost->video_pad) {
1903 1904 1905 1906
                    ost->padtop = frame_padtop;
                    ost->padleft = frame_padleft;
                    ost->padbottom = frame_padbottom;
                    ost->padright = frame_padright;
1907 1908
                    if (!ost->video_resample) {
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1909 1910
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
                                         codec->width, codec->height))
1911 1912 1913 1914
                            goto fail;
                    }
                }
                if (ost->video_resample) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1915
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1916 1917
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
                                         codec->width, codec->height)) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1918
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1919
                        av_exit(1);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1920
                    }
1921
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1922 1923 1924 1925
                    ost->img_resample_ctx = sws_getContext(
                            icodec->width - (frame_leftBand + frame_rightBand),
                            icodec->height - (frame_topBand + frame_bottomBand),
                            icodec->pix_fmt,
1926 1927
                            codec->width - (frame_padleft + frame_padright),
                            codec->height - (frame_padtop + frame_padbottom),
1928 1929
                            codec->pix_fmt,
                            sws_flags, NULL, NULL, NULL);
1930 1931
                    if (ost->img_resample_ctx == NULL) {
                        fprintf(stderr, "Cannot get resampling context\n");
1932
                        av_exit(1);
1933
                    }
1934 1935 1936 1937 1938 1939

                    ost->original_height = icodec->height;
                    ost->original_width  = icodec->width;

                    ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
                    ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
1940
                    ost->resample_pix_fmt= icodec->pix_fmt;
1941
                    codec->bits_per_raw_sample= 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1942 1943 1944
                }
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
1945
                break;
1946 1947 1948 1949
            case CODEC_TYPE_SUBTITLE:
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
                break;
1950
            default:
1951
                abort();
1952
                break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1953
            }
1954
            /* two pass mode */
1955
            if (ost->encoding_needed &&
1956 1957 1958 1959 1960
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                char logfilename[1024];
                FILE *f;
                int size;
                char *logbuffer;
1961 1962

                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1963 1964
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
                         i);
1965 1966 1967
                if (codec->flags & CODEC_FLAG_PASS1) {
                    f = fopen(logfilename, "w");
                    if (!f) {
1968
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1969
                        av_exit(1);
1970 1971 1972 1973 1974 1975
                    }
                    ost->logfile = f;
                } else {
                    /* read the log file */
                    f = fopen(logfilename, "r");
                    if (!f) {
1976
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1977
                        av_exit(1);
1978 1979 1980 1981 1982 1983 1984
                    }
                    fseek(f, 0, SEEK_END);
                    size = ftell(f);
                    fseek(f, 0, SEEK_SET);
                    logbuffer = av_malloc(size + 1);
                    if (!logbuffer) {
                        fprintf(stderr, "Could not allocate log buffer\n");
1985
                        av_exit(1);
1986
                    }
1987
                    size = fread(logbuffer, 1, size, f);
1988 1989 1990
                    fclose(f);
                    logbuffer[size] = '\0';
                    codec->stats_in = logbuffer;
1991 1992 1993
                }
            }
        }
1994 1995
        if(codec->codec_type == CODEC_TYPE_VIDEO){
            int size= codec->width * codec->height;
1996
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1997
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1998 1999
    }

2000 2001
    if (!bit_buffer)
        bit_buffer = av_malloc(bit_buffer_size);
2002
    if (!bit_buffer) {
2003 2004
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
                bit_buffer_size);
2005
        ret = AVERROR(ENOMEM);
2006
        goto fail;
2007 2008
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
2009 2010 2011 2012
    /* open each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2013 2014
            AVCodec *codec = output_codecs[i];
            if (!codec)
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2015
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
Fabrice Bellard's avatar
Fabrice Bellard committed
2016
            if (!codec) {
2017 2018
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2019 2020
                ret = AVERROR(EINVAL);
                goto dump_format;
Fabrice Bellard's avatar
Fabrice Bellard committed
2021
            }
2022
            if (avcodec_open(ost->st->codec, codec) < 0) {
2023
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
Fabrice Bellard's avatar
Fabrice Bellard committed
2024
                        ost->file_index, ost->index);
2025 2026
                ret = AVERROR(EINVAL);
                goto dump_format;
Fabrice Bellard's avatar
Fabrice Bellard committed
2027
            }
2028
            extra_size += ost->st->codec->extradata_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
2029 2030 2031 2032 2033 2034 2035
        }
    }

    /* open each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2036 2037
            AVCodec *codec = input_codecs[i];
            if (!codec)
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2038
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
Fabrice Bellard's avatar
Fabrice Bellard committed
2039
            if (!codec) {
2040
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2041
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2042 2043
                ret = AVERROR(EINVAL);
                goto dump_format;
Fabrice Bellard's avatar
Fabrice Bellard committed
2044
            }
2045
            if (avcodec_open(ist->st->codec, codec) < 0) {
2046
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
Fabrice Bellard's avatar
Fabrice Bellard committed
2047
                        ist->file_index, ist->index);
2048 2049
                ret = AVERROR(EINVAL);
                goto dump_format;
Fabrice Bellard's avatar
Fabrice Bellard committed
2050
            }
2051 2052
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
Fabrice Bellard's avatar
Fabrice Bellard committed
2053 2054 2055 2056 2057 2058
        }
    }

    /* init pts */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
2059
        ist->pts = 0;
2060
        ist->next_pts = AV_NOPTS_VALUE;
2061
        ist->is_start = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
2062
    }
2063

2064 2065 2066 2067
    /* set meta data information from input file if required */
    for (i=0;i<nb_meta_data_maps;i++) {
        AVFormatContext *out_file;
        AVFormatContext *in_file;
2068
        AVMetadataTag *mtag;
2069 2070 2071

        int out_file_index = meta_data_maps[i].out_file;
        int in_file_index = meta_data_maps[i].in_file;
2072
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2073 2074
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
                     out_file_index, out_file_index, in_file_index);
2075
            ret = AVERROR(EINVAL);
2076
            goto dump_format;
2077
        }
2078
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2079 2080
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
                     in_file_index, out_file_index, in_file_index);
2081
            ret = AVERROR(EINVAL);
2082
            goto dump_format;
2083 2084
        }

2085 2086 2087
        out_file = output_files[out_file_index];
        in_file = input_files[in_file_index];

2088 2089 2090 2091 2092 2093

        mtag=NULL;
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
                                    in_file->iformat->metadata_conv);
2094
    }
2095

Fabrice Bellard's avatar
Fabrice Bellard committed
2096 2097 2098
    /* open files and write file headers */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
2099
        if (av_write_header(os) < 0) {
2100
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2101
            ret = AVERROR(EINVAL);
2102
            goto dump_format;
2103
        }
2104 2105 2106 2107
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
            want_sdp = 0;
        }
    }
2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138

 dump_format:
    /* dump the file output parameters - cannot be done before in case
       of stream copy */
    for(i=0;i<nb_output_files;i++) {
        dump_format(output_files[i], i, output_files[i]->filename, 1);
    }

    /* dump the stream mapping */
    if (verbose >= 0) {
        fprintf(stderr, "Stream mapping:\n");
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
                    ist_table[ost->source_index]->file_index,
                    ist_table[ost->source_index]->index,
                    ost->file_index,
                    ost->index);
            if (ost->sync_ist != ist_table[ost->source_index])
                fprintf(stderr, " [sync #%d.%d]",
                        ost->sync_ist->file_index,
                        ost->sync_ist->index);
            fprintf(stderr, "\n");
        }
    }

    if (ret) {
        fprintf(stderr, "%s\n", error);
        goto fail;
    }

2139 2140
    if (want_sdp) {
        print_sdp(output_files, nb_output_files);
Fabrice Bellard's avatar
Fabrice Bellard committed
2141 2142
    }

2143
    if (!using_stdin && verbose >= 0) {
2144
        fprintf(stderr, "Press [q] to stop encoding\n");
2145 2146
        url_set_interrupt_cb(decode_interrupt_cb);
    }
2147 2148
    term_init();

2149
    timer_start = av_gettime();
2150

2151
    for(; received_sigterm == 0;) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2152 2153
        int file_index, ist_index;
        AVPacket pkt;
2154 2155
        double ipts_min;
        double opts_min;
2156

Fabrice Bellard's avatar
Fabrice Bellard committed
2157
    redo:
2158 2159
        ipts_min= 1e100;
        opts_min= 1e100;
2160
        /* if 'q' pressed, exits */
2161
        if (!using_stdin) {
2162 2163
            if (q_pressed)
                break;
2164 2165 2166 2167 2168
            /* read_key() returns 0 on EOF */
            key = read_key();
            if (key == 'q')
                break;
        }
2169

2170 2171
        /* select the stream that we must read now by looking at the
           smallest output pts */
Fabrice Bellard's avatar
Fabrice Bellard committed
2172
        file_index = -1;
2173
        for(i=0;i<nb_ostreams;i++) {
2174
            double ipts, opts;
2175 2176 2177
            ost = ost_table[i];
            os = output_files[ost->file_index];
            ist = ist_table[ost->source_index];
2178 2179
            if(no_packet[ist->file_index])
                continue;
2180 2181
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2182
            else
2183
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2184 2185 2186 2187 2188 2189 2190 2191 2192 2193
            ipts = (double)ist->pts;
            if (!file_table[ist->file_index].eof_reached){
                if(ipts < ipts_min) {
                    ipts_min = ipts;
                    if(input_sync ) file_index = ist->file_index;
                }
                if(opts < opts_min) {
                    opts_min = opts;
                    if(!input_sync) file_index = ist->file_index;
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
2194
            }
2195
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2196 2197 2198
                file_index= -1;
                break;
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
2199 2200
        }
        /* if none, if is finished */
2201
        if (file_index < 0) {
2202 2203 2204
            if(no_packet_count){
                no_packet_count=0;
                memset(no_packet, 0, sizeof(no_packet));
2205
                usleep(10000);
2206 2207
                continue;
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
2208
            break;
2209 2210
        }

Fabrice Bellard's avatar
Fabrice Bellard committed
2211
        /* finish if recording time exhausted */
2212
        if (opts_min >= (recording_time / 1000000.0))
Fabrice Bellard's avatar
Fabrice Bellard committed
2213
            break;
2214

2215
        /* finish if limit size exhausted */
2216
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2217 2218
            break;

2219
        /* read a frame from it and output it in the fifo */
Fabrice Bellard's avatar
Fabrice Bellard committed
2220
        is = input_files[file_index];
2221
        ret= av_read_frame(is, &pkt);
2222
        if(ret == AVERROR(EAGAIN)){
2223 2224
            no_packet[file_index]=1;
            no_packet_count++;
2225
            continue;
2226
        }
2227
        if (ret < 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2228
            file_table[file_index].eof_reached = 1;
Alex Beregszaszi's avatar
Alex Beregszaszi committed
2229 2230 2231 2232
            if (opt_shortest)
                break;
            else
                continue;
Fabrice Bellard's avatar
Fabrice Bellard committed
2233
        }
2234

2235 2236 2237
        no_packet_count=0;
        memset(no_packet, 0, sizeof(no_packet));

2238
        if (do_pkt_dump) {
2239
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2240
        }
2241 2242 2243
        /* the following test is needed in case new streams appear
           dynamically in stream : we ignore them */
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2244
            goto discard_packet;
Fabrice Bellard's avatar
Fabrice Bellard committed
2245 2246
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
        ist = ist_table[ist_index];
2247 2248
        if (ist->discard)
            goto discard_packet;
Fabrice Bellard's avatar
Fabrice Bellard committed
2249

2250 2251 2252 2253 2254
        if (pkt.dts != AV_NOPTS_VALUE)
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
        if (pkt.pts != AV_NOPTS_VALUE)
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);

2255 2256 2257 2258 2259 2260 2261
        if(input_files_ts_scale[file_index][pkt.stream_index]){
            if(pkt.pts != AV_NOPTS_VALUE)
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
            if(pkt.dts != AV_NOPTS_VALUE)
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
        }

2262
//        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2263 2264
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2265 2266 2267
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
            int64_t delta= pkt_dts - ist->next_pts;
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2268 2269
                input_files_ts_offset[ist->file_index]-= delta;
                if (verbose > 2)
2270
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2271 2272 2273
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
                if(pkt.pts != AV_NOPTS_VALUE)
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2274 2275 2276
            }
        }

2277
        //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2278
        if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2279 2280 2281 2282

            if (verbose >= 0)
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
                        ist->file_index, ist->index);
2283 2284
            if (exit_on_error)
                av_exit(1);
2285 2286
            av_free_packet(&pkt);
            goto redo;
Michael Niedermayer's avatar
Michael Niedermayer committed
2287
        }
2288

2289
    discard_packet:
Fabrice Bellard's avatar
Fabrice Bellard committed
2290
        av_free_packet(&pkt);
2291

2292 2293
        /* dump report by using the output first video and audio streams */
        print_report(output_files, ost_table, nb_ostreams, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
2294
    }
2295 2296 2297 2298 2299 2300 2301 2302 2303

    /* at the end of stream, we must flush the decoder buffers */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
        }
    }

2304
    term_exit();
Fabrice Bellard's avatar
Fabrice Bellard committed
2305

2306 2307 2308 2309 2310 2311
    /* write the trailer if needed and close file */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
        av_write_trailer(os);
    }

2312 2313 2314
    /* dump report by using the first video and audio streams */
    print_report(output_files, ost_table, nb_ostreams, 1);

Fabrice Bellard's avatar
Fabrice Bellard committed
2315 2316 2317 2318
    /* close each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
2319 2320
            av_freep(&ost->st->codec->stats_in);
            avcodec_close(ost->st->codec);
Fabrice Bellard's avatar
Fabrice Bellard committed
2321 2322
        }
    }
2323

Fabrice Bellard's avatar
Fabrice Bellard committed
2324 2325 2326 2327
    /* close each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
2328
            avcodec_close(ist->st->codec);
Fabrice Bellard's avatar
Fabrice Bellard committed
2329 2330 2331 2332
        }
    }

    /* finished ! */
2333
    ret = 0;
2334

2335
 fail:
2336
    av_freep(&bit_buffer);
2337
    av_free(file_table);
Fabrice Bellard's avatar
Fabrice Bellard committed
2338

Fabrice Bellard's avatar
Fabrice Bellard committed
2339 2340 2341
    if (ist_table) {
        for(i=0;i<nb_istreams;i++) {
            ist = ist_table[i];
2342
            av_free(ist);
Fabrice Bellard's avatar
Fabrice Bellard committed
2343
        }
2344
        av_free(ist_table);
Fabrice Bellard's avatar
Fabrice Bellard committed
2345 2346 2347 2348 2349
    }
    if (ost_table) {
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            if (ost) {
2350 2351 2352 2353
                if (ost->logfile) {
                    fclose(ost->logfile);
                    ost->logfile = NULL;
                }
2354
                av_fifo_free(ost->fifo); /* works even if fifo is not
2355
                                             initialized but set to zero */
2356
                av_free(ost->pict_tmp.data[0]);
Fabrice Bellard's avatar
Fabrice Bellard committed
2357
                if (ost->video_resample)
2358
                    sws_freeContext(ost->img_resample_ctx);
2359
                if (ost->resample)
Fabrice Bellard's avatar
Fabrice Bellard committed
2360
                    audio_resample_close(ost->resample);
2361 2362
                if (ost->reformat_ctx)
                    av_audio_convert_free(ost->reformat_ctx);
2363
                av_free(ost);
Fabrice Bellard's avatar
Fabrice Bellard committed
2364 2365
            }
        }
2366
        av_free(ost_table);
Fabrice Bellard's avatar
Fabrice Bellard committed
2367 2368 2369 2370
    }
    return ret;
}

2371
static void opt_format(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2372
{
2373 2374
    /* compatibility stuff for pgmyuv */
    if (!strcmp(arg, "pgmyuv")) {
2375
        pgmyuv_compatibility_hack=1;
2376
//        opt_image_format(arg);
2377
        arg = "image2";
2378
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2379 2380
    }

2381 2382 2383 2384
    file_iformat = av_find_input_format(arg);
    file_oformat = guess_format(arg, NULL, NULL);
    if (!file_iformat && !file_oformat) {
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2385
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2386 2387 2388
    }
}

2389
static void opt_video_rc_override_string(const char *arg)
2390 2391 2392 2393
{
    video_rc_override_string = arg;
}

2394
static int opt_me_threshold(const char *opt, const char *arg)
2395
{
2396 2397
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
    return 0;
2398 2399
}

2400
static int opt_verbose(const char *opt, const char *arg)
2401
{
2402
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2403
    return 0;
2404 2405
}

2406
static int opt_frame_rate(const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2407
{
2408
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2409
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2410
        av_exit(1);
2411
    }
2412
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2413 2414
}

2415
static int opt_bitrate(const char *opt, const char *arg)
2416 2417 2418 2419 2420
{
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;

    opt_default(opt, arg);

2421
    if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2422
        fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2423 2424

    return 0;
2425 2426
}

2427
static void opt_frame_crop_top(const char *arg)
2428
{
2429
    frame_topBand = atoi(arg);
2430 2431
    if (frame_topBand < 0) {
        fprintf(stderr, "Incorrect top crop size\n");
2432
        av_exit(1);
2433 2434
    }
    if ((frame_topBand) >= frame_height){
2435
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2436
        av_exit(1);
2437 2438 2439 2440
    }
    frame_height -= frame_topBand;
}

2441
static void opt_frame_crop_bottom(const char *arg)
2442 2443 2444 2445
{
    frame_bottomBand = atoi(arg);
    if (frame_bottomBand < 0) {
        fprintf(stderr, "Incorrect bottom crop size\n");
2446
        av_exit(1);
2447 2448
    }
    if ((frame_bottomBand) >= frame_height){
2449
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2450
        av_exit(1);
2451 2452 2453 2454
    }
    frame_height -= frame_bottomBand;
}

2455
static void opt_frame_crop_left(const char *arg)
2456 2457 2458 2459
{
    frame_leftBand = atoi(arg);
    if (frame_leftBand < 0) {
        fprintf(stderr, "Incorrect left crop size\n");
2460
        av_exit(1);
2461 2462
    }
    if ((frame_leftBand) >= frame_width){
2463
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2464
        av_exit(1);
2465 2466 2467 2468
    }
    frame_width -= frame_leftBand;
}

2469
static void opt_frame_crop_right(const char *arg)
2470 2471 2472 2473
{
    frame_rightBand = atoi(arg);
    if (frame_rightBand < 0) {
        fprintf(stderr, "Incorrect right crop size\n");
2474
        av_exit(1);
2475 2476
    }
    if ((frame_rightBand) >= frame_width){
2477
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2478
        av_exit(1);
2479 2480 2481 2482
    }
    frame_width -= frame_rightBand;
}

2483
static void opt_frame_size(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2484
{
2485
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2486
        fprintf(stderr, "Incorrect frame size\n");
2487
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2488 2489 2490
    }
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2491
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2492 2493 2494
    }
}

2495 2496 2497 2498 2499
static void opt_pad_color(const char *arg) {
    /* Input is expected to be six hex digits similar to
       how colors are expressed in html tags (but without the #) */
    int rgb = strtol(arg, NULL, 16);
    int r,g,b;
2500 2501

    r = (rgb >> 16);
2502 2503 2504 2505 2506 2507 2508 2509 2510 2511
    g = ((rgb >> 8) & 255);
    b = (rgb & 255);

    padcolor[0] = RGB_TO_Y(r,g,b);
    padcolor[1] = RGB_TO_U(r,g,b,0);
    padcolor[2] = RGB_TO_V(r,g,b,0);
}

static void opt_frame_pad_top(const char *arg)
{
2512
    frame_padtop = atoi(arg);
2513 2514
    if (frame_padtop < 0) {
        fprintf(stderr, "Incorrect top pad size\n");
2515
        av_exit(1);
2516 2517 2518 2519 2520
    }
}

static void opt_frame_pad_bottom(const char *arg)
{
2521
    frame_padbottom = atoi(arg);
2522 2523
    if (frame_padbottom < 0) {
        fprintf(stderr, "Incorrect bottom pad size\n");
2524
        av_exit(1);
2525 2526 2527 2528 2529 2530
    }
}


static void opt_frame_pad_left(const char *arg)
{
2531
    frame_padleft = atoi(arg);
2532 2533
    if (frame_padleft < 0) {
        fprintf(stderr, "Incorrect left pad size\n");
2534
        av_exit(1);
2535 2536 2537 2538 2539 2540
    }
}


static void opt_frame_pad_right(const char *arg)
{
2541
    frame_padright = atoi(arg);
2542 2543
    if (frame_padright < 0) {
        fprintf(stderr, "Incorrect right pad size\n");
2544
        av_exit(1);
2545 2546 2547
    }
}

2548
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2549 2550
{
    int i;
2551 2552 2553 2554
    char fmt_str[128];
    for (i=-1; i < nb_fmts; i++) {
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
        fprintf(stdout, "%s\n", fmt_str);
2555 2556
    }
}
2557

2558 2559
static void opt_frame_pix_fmt(const char *arg)
{
2560
    if (strcmp(arg, "list")) {
2561
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2562 2563 2564 2565 2566
        if (frame_pix_fmt == PIX_FMT_NONE) {
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
            av_exit(1);
        }
    } else {
2567
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2568
        av_exit(0);
2569
    }
2570 2571
}

2572 2573 2574 2575 2576
static void opt_frame_aspect_ratio(const char *arg)
{
    int x = 0, y = 0;
    double ar = 0;
    const char *p;
2577
    char *end;
2578

2579 2580
    p = strchr(arg, ':');
    if (p) {
2581 2582 2583
        x = strtol(arg, &end, 10);
        if (end == p)
            y = strtol(end+1, &end, 10);
2584 2585
        if (x > 0 && y > 0)
            ar = (double)x / (double)y;
2586
    } else
2587
        ar = strtod(arg, NULL);
2588 2589 2590

    if (!ar) {
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2591
        av_exit(1);
2592 2593 2594 2595
    }
    frame_aspect_ratio = ar;
}

2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613
static int opt_metadata(const char *opt, const char *arg)
{
    char *mid= strchr(arg, '=');

    if(!mid){
        fprintf(stderr, "Missing =\n");
        av_exit(1);
    }
    *mid++= 0;

    metadata_count++;
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
    metadata[metadata_count-1].key  = av_strdup(arg);
    metadata[metadata_count-1].value= av_strdup(mid);

    return 0;
}

2614
static void opt_qscale(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2615
{
2616
    video_qscale = atof(arg);
Loren Merritt's avatar
Loren Merritt committed
2617
    if (video_qscale <= 0 ||
2618
        video_qscale > 255) {
Loren Merritt's avatar
Loren Merritt committed
2619
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2620
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2621 2622 2623
    }
}

2624 2625 2626 2627 2628
static void opt_top_field_first(const char *arg)
{
    top_field_first= atoi(arg);
}

2629
static int opt_thread_count(const char *opt, const char *arg)
2630
{
2631
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2632
#if !HAVE_THREADS
2633 2634
    if (verbose >= 0)
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2635
#endif
2636
    return 0;
2637 2638
}

2639 2640 2641 2642 2643 2644 2645 2646 2647 2648
static void opt_audio_sample_fmt(const char *arg)
{
    if (strcmp(arg, "list"))
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
    else {
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
        av_exit(0);
    }
}

2649
static int opt_audio_rate(const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2650
{
2651 2652
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2653 2654
}

2655
static int opt_audio_channels(const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2656
{
2657 2658
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2659 2660
}

2661
static void opt_video_channel(const char *arg)
2662 2663 2664 2665
{
    video_channel = strtol(arg, NULL, 0);
}

2666 2667 2668 2669 2670
static void opt_video_standard(const char *arg)
{
    video_standard = av_strdup(arg);
}

2671
static void opt_codec(int *pstream_copy, char **pcodec_name,
2672
                      int codec_type, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2673
{
2674
    av_freep(pcodec_name);
2675
    if (!strcmp(arg, "copy")) {
2676
        *pstream_copy = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
2677
    } else {
2678
        *pcodec_name = av_strdup(arg);
Fabrice Bellard's avatar
Fabrice Bellard committed
2679 2680 2681
    }
}

2682 2683
static void opt_audio_codec(const char *arg)
{
2684
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2685 2686
}

2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704
static void opt_audio_tag(const char *arg)
{
    char *tail;
    audio_codec_tag= strtol(arg, &tail, 0);

    if(!tail || *tail)
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
}

static void opt_video_tag(const char *arg)
{
    char *tail;
    video_codec_tag= strtol(arg, &tail, 0);

    if(!tail || *tail)
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
}

2705
static void opt_video_codec(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2706
{
2707
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2708
}
Fabrice Bellard's avatar
Fabrice Bellard committed
2709

2710 2711
static void opt_subtitle_codec(const char *arg)
{
2712
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
Fabrice Bellard's avatar
Fabrice Bellard committed
2713 2714
}

2715 2716 2717 2718 2719 2720 2721 2722 2723
static void opt_subtitle_tag(const char *arg)
{
    char *tail;
    subtitle_codec_tag= strtol(arg, &tail, 0);

    if(!tail || *tail)
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
}

2724
static void opt_map(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2725 2726
{
    AVStreamMap *m;
2727
    char *p;
Fabrice Bellard's avatar
Fabrice Bellard committed
2728 2729 2730

    m = &stream_maps[nb_stream_maps++];

2731
    m->file_index = strtol(arg, &p, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
2732 2733
    if (*p)
        p++;
Juanjo's avatar
Juanjo committed
2734

2735
    m->stream_index = strtol(p, &p, 0);
2736 2737
    if (*p) {
        p++;
2738
        m->sync_file_index = strtol(p, &p, 0);
2739 2740
        if (*p)
            p++;
2741
        m->sync_stream_index = strtol(p, &p, 0);
2742 2743 2744 2745
    } else {
        m->sync_file_index = m->file_index;
        m->sync_stream_index = m->stream_index;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
2746 2747
}

2748 2749 2750
static void opt_map_meta_data(const char *arg)
{
    AVMetaDataMap *m;
2751
    char *p;
2752

2753 2754
    m = &meta_data_maps[nb_meta_data_maps++];

2755
    m->out_file = strtol(arg, &p, 0);
2756 2757 2758
    if (*p)
        p++;

2759
    m->in_file = strtol(p, &p, 0);
2760 2761
}

2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778
static void opt_input_ts_scale(const char *arg)
{
    unsigned int stream;
    double scale;
    char *p;

    stream = strtol(arg, &p, 0);
    if (*p)
        p++;
    scale= strtod(p, &p);

    if(stream >= MAX_STREAMS)
        av_exit(1);

    input_files_ts_scale[nb_input_files][stream]= scale;
}

2779
static int opt_recording_time(const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2780
{
2781 2782
    recording_time = parse_time_or_die(opt, arg, 1);
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2783 2784
}

2785
static int opt_start_time(const char *opt, const char *arg)
2786
{
2787 2788
    start_time = parse_time_or_die(opt, arg, 1);
    return 0;
2789 2790
}

2791
static int opt_rec_timestamp(const char *opt, const char *arg)
2792
{
2793 2794
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
    return 0;
2795 2796
}

2797
static int opt_input_ts_offset(const char *opt, const char *arg)
2798
{
2799 2800
    input_ts_offset = parse_time_or_die(opt, arg, 1);
    return 0;
2801 2802
}

2803 2804
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
{
Michael Niedermayer's avatar
Michael Niedermayer committed
2805
    const char *codec_string = encoder ? "encoder" : "decoder";
2806 2807 2808 2809 2810 2811 2812 2813
    AVCodec *codec;

    if(!name)
        return CODEC_ID_NONE;
    codec = encoder ?
        avcodec_find_encoder_by_name(name) :
        avcodec_find_decoder_by_name(name);
    if(!codec) {
2814
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2815
        av_exit(1);
2816 2817
    }
    if(codec->type != type) {
2818
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2819
        av_exit(1);
2820 2821 2822 2823
    }
    return codec->id;
}

2824
static void opt_input_file(const char *filename)
Fabrice Bellard's avatar
Fabrice Bellard committed
2825 2826 2827
{
    AVFormatContext *ic;
    AVFormatParameters params, *ap = &params;
2828
    int err, i, ret, rfps, rfps_base;
2829
    int64_t timestamp;
Fabrice Bellard's avatar
Fabrice Bellard committed
2830

2831 2832 2833
    if (!strcmp(filename, "-"))
        filename = "pipe:";

2834
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2835
                    !strcmp(filename, "/dev/stdin");
2836

Fabrice Bellard's avatar
Fabrice Bellard committed
2837
    /* get default parameters from command line */
2838
    ic = avformat_alloc_context();
2839

2840
    memset(ap, 0, sizeof(*ap));
2841
    ap->prealloced_context = 1;
2842 2843
    ap->sample_rate = audio_sample_rate;
    ap->channels = audio_channels;
2844 2845
    ap->time_base.den = frame_rate.num;
    ap->time_base.num = frame_rate.den;
2846 2847
    ap->width = frame_width + frame_padleft + frame_padright;
    ap->height = frame_height + frame_padtop + frame_padbottom;
2848
    ap->pix_fmt = frame_pix_fmt;
2849
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2850 2851
    ap->channel = video_channel;
    ap->standard = video_standard;
2852 2853
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2854 2855
    if(pgmyuv_compatibility_hack)
        ap->video_codec_id= CODEC_ID_PGMYUV;
2856

2857
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2858 2859 2860 2861

    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2862
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2863

2864 2865
    /* open the input file with generic libav function */
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
Fabrice Bellard's avatar
Fabrice Bellard committed
2866
    if (err < 0) {
2867
        print_error(filename, err);
2868
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2869
    }
2870 2871 2872 2873 2874 2875
    if(opt_programid) {
        int i;
        for(i=0; i<ic->nb_programs; i++)
            if(ic->programs[i]->id != opt_programid)
                ic->programs[i]->discard = AVDISCARD_ALL;
    }
2876

2877 2878
    ic->loop_input = loop_input;

2879 2880 2881
    /* If not enough info to get the stream parameters, we decode the
       first frames to get it. (used in mpeg case for example) */
    ret = av_find_stream_info(ic);
2882
    if (ret < 0 && verbose >= 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2883
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2884
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2885 2886
    }

2887 2888 2889 2890 2891
    timestamp = start_time;
    /* add the stream start time */
    if (ic->start_time != AV_NOPTS_VALUE)
        timestamp += ic->start_time;

2892 2893
    /* if seeking requested, we execute it */
    if (start_time != 0) {
2894
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2895
        if (ret < 0) {
2896
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2897 2898 2899 2900 2901 2902
                    filename, (double)timestamp / AV_TIME_BASE);
        }
        /* reset seek info */
        start_time = 0;
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
2903 2904
    /* update the current parameters so that they match the one of the input stream */
    for(i=0;i<ic->nb_streams;i++) {
2905
        AVCodecContext *enc = ic->streams[i]->codec;
2906 2907 2908
        if(thread_count>1)
            avcodec_thread_init(enc, thread_count);
        enc->thread_count= thread_count;
Fabrice Bellard's avatar
Fabrice Bellard committed
2909 2910
        switch(enc->codec_type) {
        case CODEC_TYPE_AUDIO:
2911
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2912
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2913
            channel_layout = enc->channel_layout;
Fabrice Bellard's avatar
Fabrice Bellard committed
2914 2915
            audio_channels = enc->channels;
            audio_sample_rate = enc->sample_rate;
2916
            audio_sample_fmt = enc->sample_fmt;
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2917
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2918
            if(audio_disable)
2919
                ic->streams[i]->discard= AVDISCARD_ALL;
Fabrice Bellard's avatar
Fabrice Bellard committed
2920 2921
            break;
        case CODEC_TYPE_VIDEO:
2922
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
Fabrice Bellard's avatar
Fabrice Bellard committed
2923 2924
            frame_height = enc->height;
            frame_width = enc->width;
2925 2926 2927 2928 2929
            if(ic->streams[i]->sample_aspect_ratio.num)
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
            else
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
            frame_aspect_ratio *= (float) enc->width / enc->height;
2930
            frame_pix_fmt = enc->pix_fmt;
2931 2932
            rfps      = ic->streams[i]->r_frame_rate.num;
            rfps_base = ic->streams[i]->r_frame_rate.den;
2933
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2934 2935
            if(me_threshold)
                enc->debug |= FF_DEBUG_MV;
2936

2937
            if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2938 2939

                if (verbose >= 0)
2940
                    fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2941
                            i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2942

2943
                    (float)rfps / rfps_base, rfps, rfps_base);
2944
            }
2945
            /* update the current frame rate to match the stream frame rate */
2946 2947
            frame_rate.num = rfps;
            frame_rate.den = rfps_base;
2948

Aurelien Jacobs's avatar
Aurelien Jacobs committed
2949
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2950
            if(video_disable)
2951 2952 2953
                ic->streams[i]->discard= AVDISCARD_ALL;
            else if(video_discard)
                ic->streams[i]->discard= video_discard;
Fabrice Bellard's avatar
Fabrice Bellard committed
2954
            break;
2955 2956
        case CODEC_TYPE_DATA:
            break;
2957
        case CODEC_TYPE_SUBTITLE:
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2958
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2959 2960
            if(subtitle_disable)
                ic->streams[i]->discard = AVDISCARD_ALL;
2961
            break;
2962
        case CODEC_TYPE_ATTACHMENT:
2963
        case CODEC_TYPE_UNKNOWN:
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2964
            nb_icodecs++;
2965
            break;
2966
        default:
2967
            abort();
Fabrice Bellard's avatar
Fabrice Bellard committed
2968 2969
        }
    }
2970

Fabrice Bellard's avatar
Fabrice Bellard committed
2971
    input_files[nb_input_files] = ic;
2972
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
Fabrice Bellard's avatar
Fabrice Bellard committed
2973
    /* dump the file content */
2974 2975 2976
    if (verbose >= 0)
        dump_format(ic, nb_input_files, filename, 0);

Fabrice Bellard's avatar
Fabrice Bellard committed
2977
    nb_input_files++;
2978 2979
    file_iformat = NULL;
    file_oformat = NULL;
2980

2981
    video_channel = 0;
2982

2983 2984 2985
    av_freep(&video_codec_name);
    av_freep(&audio_codec_name);
    av_freep(&subtitle_codec_name);
Fabrice Bellard's avatar
Fabrice Bellard committed
2986 2987
}

2988 2989
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
                                         int *has_subtitle_ptr)
2990
{
2991
    int has_video, has_audio, has_subtitle, i, j;
2992 2993 2994 2995
    AVFormatContext *ic;

    has_video = 0;
    has_audio = 0;
2996
    has_subtitle = 0;
2997 2998 2999
    for(j=0;j<nb_input_files;j++) {
        ic = input_files[j];
        for(i=0;i<ic->nb_streams;i++) {
3000
            AVCodecContext *enc = ic->streams[i]->codec;
3001 3002 3003 3004 3005 3006 3007
            switch(enc->codec_type) {
            case CODEC_TYPE_AUDIO:
                has_audio = 1;
                break;
            case CODEC_TYPE_VIDEO:
                has_video = 1;
                break;
3008 3009 3010
            case CODEC_TYPE_SUBTITLE:
                has_subtitle = 1;
                break;
3011
            case CODEC_TYPE_DATA:
3012
            case CODEC_TYPE_ATTACHMENT:
3013
            case CODEC_TYPE_UNKNOWN:
3014
                break;
3015
            default:
3016
                abort();
3017 3018 3019 3020 3021
            }
        }
    }
    *has_video_ptr = has_video;
    *has_audio_ptr = has_audio;
3022
    *has_subtitle_ptr = has_subtitle;
3023 3024
}

3025
static void new_video_stream(AVFormatContext *oc)
Fabrice Bellard's avatar
Fabrice Bellard committed
3026 3027
{
    AVStream *st;
3028
    AVCodecContext *video_enc;
3029
    enum CodecID codec_id;
3030

3031 3032 3033
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
3034
        av_exit(1);
3035
    }
3036
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3037 3038 3039
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
    video_bitstream_filters= NULL;

3040
    if(thread_count>1)
3041
        avcodec_thread_init(st->codec, thread_count);
3042

3043
    video_enc = st->codec;
3044

3045 3046
    if(video_codec_tag)
        video_enc->codec_tag= video_codec_tag;
3047

3048
    if(   (video_global_header&1)
3049
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3050
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3051
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3052 3053
    }
    if(video_global_header&2){
3054
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3055
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3056
    }
3057

3058 3059 3060
    if (video_stream_copy) {
        st->stream_copy = 1;
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3061
        video_enc->sample_aspect_ratio =
3062
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3063
    } else {
3064
        const char *p;
3065 3066
        int i;
        AVCodec *codec;
3067
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3068

Aurelien Jacobs's avatar
Aurelien Jacobs committed
3069
        if (video_codec_name) {
3070
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3071 3072 3073 3074 3075 3076
            codec = avcodec_find_encoder_by_name(video_codec_name);
            output_codecs[nb_ocodecs] = codec;
        } else {
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
            codec = avcodec_find_encoder(codec_id);
        }
3077

3078
        video_enc->codec_id = codec_id;
3079

3080
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3081

3082 3083
        if (codec && codec->supported_framerates && !force_fps)
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3084 3085
        video_enc->time_base.den = fps.num;
        video_enc->time_base.num = fps.den;
3086

3087 3088
        video_enc->width = frame_width + frame_padright + frame_padleft;
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3089
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3090
        video_enc->pix_fmt = frame_pix_fmt;
3091
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102

        if(codec && codec->pix_fmts){
            const enum PixelFormat *p= codec->pix_fmts;
            for(; *p!=-1; p++){
                if(*p == video_enc->pix_fmt)
                    break;
            }
            if(*p == -1)
                video_enc->pix_fmt = codec->pix_fmts[0];
        }

3103
        if (intra_only)
3104 3105 3106
            video_enc->gop_size = 0;
        if (video_qscale || same_quality) {
            video_enc->flags |= CODEC_FLAG_QSCALE;
3107
            video_enc->global_quality=
3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122
                st->quality = FF_QP2LAMBDA * video_qscale;
        }

        if(intra_matrix)
            video_enc->intra_matrix = intra_matrix;
        if(inter_matrix)
            video_enc->inter_matrix = inter_matrix;

        video_enc->thread_count = thread_count;
        p= video_rc_override_string;
        for(i=0; p; i++){
            int start, end, q;
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
            if(e!=3){
                fprintf(stderr, "error parsing rc_override\n");
3123
                av_exit(1);
3124
            }
3125 3126
            video_enc->rc_override=
                av_realloc(video_enc->rc_override,
3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141
                           sizeof(RcOverride)*(i+1));
            video_enc->rc_override[i].start_frame= start;
            video_enc->rc_override[i].end_frame  = end;
            if(q>0){
                video_enc->rc_override[i].qscale= q;
                video_enc->rc_override[i].quality_factor= 1.0;
            }
            else{
                video_enc->rc_override[i].qscale= 0;
                video_enc->rc_override[i].quality_factor= -q/100.0;
            }
            p= strchr(p, '/');
            if(p) p++;
        }
        video_enc->rc_override_count=i;
3142 3143
        if (!video_enc->rc_initial_buffer_occupancy)
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3144 3145 3146 3147 3148
        video_enc->me_threshold= me_threshold;
        video_enc->intra_dc_precision= intra_dc_precision - 8;

        if (do_psnr)
            video_enc->flags|= CODEC_FLAG_PSNR;
3149

3150 3151 3152 3153 3154 3155 3156 3157 3158
        /* two pass mode */
        if (do_pass) {
            if (do_pass == 1) {
                video_enc->flags |= CODEC_FLAG_PASS1;
            } else {
                video_enc->flags |= CODEC_FLAG_PASS2;
            }
        }
    }
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3159
    nb_ocodecs++;
3160 3161 3162

    /* reset some key parameters */
    video_disable = 0;
3163
    av_freep(&video_codec_name);
3164 3165 3166 3167 3168 3169 3170
    video_stream_copy = 0;
}

static void new_audio_stream(AVFormatContext *oc)
{
    AVStream *st;
    AVCodecContext *audio_enc;
3171
    enum CodecID codec_id;
3172

3173 3174 3175
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
3176
        av_exit(1);
3177
    }
3178
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3179 3180 3181 3182

    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
    audio_bitstream_filters= NULL;

3183
    if(thread_count>1)
3184
        avcodec_thread_init(st->codec, thread_count);
3185

3186
    audio_enc = st->codec;
3187
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3188

3189 3190
    if(audio_codec_tag)
        audio_enc->codec_tag= audio_codec_tag;
3191

3192
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3193
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3194
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3195
    }
3196 3197 3198 3199
    if (audio_stream_copy) {
        st->stream_copy = 1;
        audio_enc->channels = audio_channels;
    } else {
3200
        AVCodec *codec;
3201

3202
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3203

Aurelien Jacobs's avatar
Aurelien Jacobs committed
3204
        if (audio_codec_name) {
3205
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3206 3207 3208 3209 3210 3211
            codec = avcodec_find_encoder_by_name(audio_codec_name);
            output_codecs[nb_ocodecs] = codec;
        } else {
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
            codec = avcodec_find_encoder(codec_id);
        }
3212
        audio_enc->codec_id = codec_id;
3213

3214 3215 3216 3217
        if (audio_qscale > QSCALE_NONE) {
            audio_enc->flags |= CODEC_FLAG_QSCALE;
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
        }
3218
        audio_enc->thread_count = thread_count;
3219
        audio_enc->channels = audio_channels;
3220
        audio_enc->sample_fmt = audio_sample_fmt;
3221
        audio_enc->channel_layout = channel_layout;
3222 3223
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
            audio_enc->channel_layout = 0;
3224 3225 3226 3227 3228 3229 3230 3231 3232 3233

        if(codec && codec->sample_fmts){
            const enum SampleFormat *p= codec->sample_fmts;
            for(; *p!=-1; p++){
                if(*p == audio_enc->sample_fmt)
                    break;
            }
            if(*p == -1)
                audio_enc->sample_fmt = codec->sample_fmts[0];
        }
3234
    }
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3235
    nb_ocodecs++;
3236
    audio_enc->sample_rate = audio_sample_rate;
3237
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3238
    if (audio_language) {
3239
        av_metadata_set(&st->metadata, "language", audio_language);
3240 3241 3242 3243 3244 3245
        av_free(audio_language);
        audio_language = NULL;
    }

    /* reset some key parameters */
    audio_disable = 0;
3246
    av_freep(&audio_codec_name);
3247 3248 3249
    audio_stream_copy = 0;
}

3250
static void new_subtitle_stream(AVFormatContext *oc)
3251 3252 3253
{
    AVStream *st;
    AVCodecContext *subtitle_enc;
3254

3255 3256 3257
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
3258
        av_exit(1);
3259
    }
3260
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3261

3262 3263 3264
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
    subtitle_bitstream_filters= NULL;

3265
    subtitle_enc = st->codec;
3266
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3267 3268 3269 3270

    if(subtitle_codec_tag)
        subtitle_enc->codec_tag= subtitle_codec_tag;

3271 3272 3273
    if (subtitle_stream_copy) {
        st->stream_copy = 1;
    } else {
3274
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3275
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3276
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3277
    }
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3278
    nb_ocodecs++;
3279 3280

    if (subtitle_language) {
3281
        av_metadata_set(&st->metadata, "language", subtitle_language);
3282 3283 3284 3285
        av_free(subtitle_language);
        subtitle_language = NULL;
    }

3286
    subtitle_disable = 0;
3287
    av_freep(&subtitle_codec_name);
3288 3289 3290 3291 3292 3293 3294 3295
    subtitle_stream_copy = 0;
}

static void opt_new_audio_stream(void)
{
    AVFormatContext *oc;
    if (nb_output_files <= 0) {
        fprintf(stderr, "At least one output file must be specified\n");
3296
        av_exit(1);
3297 3298 3299 3300 3301 3302 3303 3304 3305 3306
    }
    oc = output_files[nb_output_files - 1];
    new_audio_stream(oc);
}

static void opt_new_video_stream(void)
{
    AVFormatContext *oc;
    if (nb_output_files <= 0) {
        fprintf(stderr, "At least one output file must be specified\n");
3307
        av_exit(1);
3308 3309 3310 3311 3312
    }
    oc = output_files[nb_output_files - 1];
    new_video_stream(oc);
}

3313 3314 3315 3316 3317
static void opt_new_subtitle_stream(void)
{
    AVFormatContext *oc;
    if (nb_output_files <= 0) {
        fprintf(stderr, "At least one output file must be specified\n");
3318
        av_exit(1);
3319 3320 3321 3322 3323
    }
    oc = output_files[nb_output_files - 1];
    new_subtitle_stream(oc);
}

3324 3325 3326
static void opt_output_file(const char *filename)
{
    AVFormatContext *oc;
3327
    int use_video, use_audio, use_subtitle;
3328
    int input_has_video, input_has_audio, input_has_subtitle;
3329
    AVFormatParameters params, *ap = &params;
Fabrice Bellard's avatar
Fabrice Bellard committed
3330 3331 3332 3333

    if (!strcmp(filename, "-"))
        filename = "pipe:";

3334
    oc = avformat_alloc_context();
Fabrice Bellard's avatar
Fabrice Bellard committed
3335

3336 3337 3338
    if (!file_oformat) {
        file_oformat = guess_format(NULL, filename, NULL);
        if (!file_oformat) {
3339
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3340
                    filename);
3341
            av_exit(1);
3342
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
3343
    }
3344

3345
    oc->oformat = file_oformat;
3346
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
Fabrice Bellard's avatar
Fabrice Bellard committed
3347

3348
    if (!strcmp(file_oformat->name, "ffm") &&
3349
        av_strstart(filename, "http:", NULL)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
3350 3351
        /* special case for files sent to ffserver: we get the stream
           parameters from ffserver */
3352 3353 3354
        int err = read_ffserver_streams(oc, filename);
        if (err < 0) {
            print_error(filename, err);
3355
            av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
3356 3357
        }
    } else {
3358 3359 3360
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3361

3362 3363 3364
        /* disable if no corresponding type found and at least one
           input file */
        if (nb_input_files > 0) {
3365 3366
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
                                         &input_has_subtitle);
3367 3368 3369 3370
            if (!input_has_video)
                use_video = 0;
            if (!input_has_audio)
                use_audio = 0;
3371 3372
            if (!input_has_subtitle)
                use_subtitle = 0;
3373
        }
3374 3375

        /* manual disable */
Fabrice Bellard's avatar
Fabrice Bellard committed
3376 3377 3378 3379 3380 3381
        if (audio_disable) {
            use_audio = 0;
        }
        if (video_disable) {
            use_video = 0;
        }
3382 3383 3384
        if (subtitle_disable) {
            use_subtitle = 0;
        }
3385

Fabrice Bellard's avatar
Fabrice Bellard committed
3386
        if (use_video) {
3387
            new_video_stream(oc);
Fabrice Bellard's avatar
Fabrice Bellard committed
3388
        }
3389

Fabrice Bellard's avatar
Fabrice Bellard committed
3390
        if (use_audio) {
3391
            new_audio_stream(oc);
Fabrice Bellard's avatar
Fabrice Bellard committed
3392 3393
        }

3394 3395 3396 3397
        if (use_subtitle) {
            new_subtitle_stream(oc);
        }

3398
        oc->timestamp = rec_timestamp;
3399

3400 3401 3402 3403 3404
        for(; metadata_count>0; metadata_count--){
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
                                           metadata[metadata_count-1].value);
        }
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
Fabrice Bellard's avatar
Fabrice Bellard committed
3405 3406
    }

3407
    output_files[nb_output_files++] = oc;
Fabrice Bellard's avatar
Fabrice Bellard committed
3408

3409
    /* check filename in case of an image number is expected */
3410
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3411
        if (!av_filename_number_test(oc->filename)) {
3412
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3413
            av_exit(1);
3414
        }
3415 3416
    }

3417
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
3418
        /* test if it already exists to avoid loosing precious files */
3419
        if (!file_overwrite &&
Fabrice Bellard's avatar
Fabrice Bellard committed
3420
            (strchr(filename, ':') == NULL ||
3421
             filename[1] == ':' ||
3422
             av_strstart(filename, "file:", NULL))) {
Fabrice Bellard's avatar
Fabrice Bellard committed
3423
            if (url_exist(filename)) {
3424
                if (!using_stdin) {
3425 3426
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
                    fflush(stderr);
3427
                    if (!read_yesno()) {
3428
                        fprintf(stderr, "Not overwriting - exiting\n");
3429
                        av_exit(1);
3430
                    }
3431 3432
                }
                else {
3433
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3434
                    av_exit(1);
3435
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
3436 3437
            }
        }
3438

Fabrice Bellard's avatar
Fabrice Bellard committed
3439 3440 3441
        /* open the file */
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
            fprintf(stderr, "Could not open '%s'\n", filename);
3442
            av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
3443 3444 3445
        }
    }

3446 3447 3448 3449
    memset(ap, 0, sizeof(*ap));
    if (av_set_parameters(oc, ap) < 0) {
        fprintf(stderr, "%s: Invalid encoding parameters\n",
                oc->filename);
3450
        av_exit(1);
3451 3452
    }

3453 3454
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3455
    oc->loop_output = loop_output;
3456
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3457

3458
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3459

Fabrice Bellard's avatar
Fabrice Bellard committed
3460
    /* reset some options */
3461 3462
    file_oformat = NULL;
    file_iformat = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
3463 3464
}

3465
/* same option as mencoder */
3466
static void opt_pass(const char *pass_str)
3467 3468 3469 3470 3471
{
    int pass;
    pass = atoi(pass_str);
    if (pass != 1 && pass != 2) {
        fprintf(stderr, "pass number can be only 1 or 2\n");
3472
        av_exit(1);
3473 3474 3475
    }
    do_pass = pass;
}
3476

3477
static int64_t getutime(void)
Fabrice Bellard's avatar
Fabrice Bellard committed
3478
{
3479
#if HAVE_GETRUSAGE
3480 3481 3482 3483
    struct rusage rusage;

    getrusage(RUSAGE_SELF, &rusage);
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3484
#elif HAVE_GETPROCESSTIMES
3485 3486 3487 3488 3489 3490
    HANDLE proc;
    FILETIME c, e, k, u;
    proc = GetCurrentProcess();
    GetProcessTimes(proc, &c, &e, &k, &u);
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
#else
Ramiro Polla's avatar
Ramiro Polla committed
3491
    return av_gettime();
Ramiro Polla's avatar
Ramiro Polla committed
3492
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
3493
}
Fabrice Bellard's avatar
Fabrice Bellard committed
3494

3495
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3496 3497 3498 3499 3500 3501 3502 3503 3504 3505
{
    int i;
    const char *p = str;
    for(i = 0;; i++) {
        dest[i] = atoi(p);
        if(i == 63)
            break;
        p = strchr(p, ',');
        if(!p) {
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3506
            av_exit(1);
3507 3508 3509 3510 3511
        }
        p++;
    }
}

3512
static void opt_inter_matrix(const char *arg)
3513 3514 3515 3516 3517
{
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(inter_matrix, arg);
}

3518
static void opt_intra_matrix(const char *arg)
3519 3520 3521 3522 3523
{
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(intra_matrix, arg);
}

3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539
/**
 * Trivial log callback.
 * Only suitable for show_help and similar since it lacks prefix handling.
 */
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
{
    vfprintf(stdout, fmt, vl);
}

static void show_help(void)
{
    av_log_set_callback(log_callback_help);
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
           "Hyper fast Audio and Video encoder\n");
    printf("\n");
    show_help_options(options, "Main options:\n",
3540
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3541 3542 3543
    show_help_options(options, "\nAdvanced options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
                      OPT_EXPERT);
3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561
    show_help_options(options, "\nVideo options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
                      OPT_VIDEO);
    show_help_options(options, "\nAdvanced Video options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
                      OPT_VIDEO | OPT_EXPERT);
    show_help_options(options, "\nAudio options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
                      OPT_AUDIO);
    show_help_options(options, "\nAdvanced Audio options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
                      OPT_AUDIO | OPT_EXPERT);
    show_help_options(options, "\nSubtitle options:\n",
                      OPT_SUBTITLE | OPT_GRAB,
                      OPT_SUBTITLE);
    show_help_options(options, "\nAudio/Video grab options:\n",
                      OPT_GRAB,
                      OPT_GRAB);
3562
    printf("\n");
3563
    av_opt_show(avcodec_opts[0], NULL);
3564
    printf("\n");
3565
    av_opt_show(avformat_opts, NULL);
3566
    printf("\n");
3567 3568 3569
    av_opt_show(sws_opts, NULL);
}

3570 3571 3572
static void opt_target(const char *arg)
{
    int norm = -1;
3573
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3574 3575 3576 3577 3578 3579 3580

    if(!strncmp(arg, "pal-", 4)) {
        norm = 0;
        arg += 4;
    } else if(!strncmp(arg, "ntsc-", 5)) {
        norm = 1;
        arg += 5;
3581 3582 3583
    } else if(!strncmp(arg, "film-", 5)) {
        norm = 2;
        arg += 5;
3584 3585 3586
    } else {
        int fr;
        /* Calculate FR via float to avoid int overflow */
3587
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3588 3589 3590 3591 3592 3593 3594 3595 3596 3597
        if(fr == 25000) {
            norm = 0;
        } else if((fr == 29970) || (fr == 23976)) {
            norm = 1;
        } else {
            /* Try to determine PAL/NTSC by peeking in the input files */
            if(nb_input_files) {
                int i, j;
                for(j = 0; j < nb_input_files; j++) {
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3598
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3599 3600
                        if(c->codec_type != CODEC_TYPE_VIDEO)
                            continue;
3601
                        fr = c->time_base.den * 1000 / c->time_base.num;
3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615
                        if(fr == 25000) {
                            norm = 0;
                            break;
                        } else if((fr == 29970) || (fr == 23976)) {
                            norm = 1;
                            break;
                        }
                    }
                    if(norm >= 0)
                        break;
                }
            }
        }
        if(verbose && norm >= 0)
3616
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3617 3618 3619
    }

    if(norm < 0) {
3620 3621
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3622
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3623
        av_exit(1);
3624 3625 3626 3627 3628 3629 3630 3631 3632
    }

    if(!strcmp(arg, "vcd")) {

        opt_video_codec("mpeg1video");
        opt_audio_codec("mp2");
        opt_format("vcd");

        opt_frame_size(norm ? "352x240" : "352x288");
3633
        opt_frame_rate(NULL, frame_rates[norm]);
3634
        opt_default("g", norm ? "18" : "15");
3635

3636
        opt_default("b", "1150000");
3637 3638
        opt_default("maxrate", "1150000");
        opt_default("minrate", "1150000");
3639
        opt_default("bufsize", "327680"); // 40*1024*8;
3640

3641
        opt_default("ab", "224000");
3642
        audio_sample_rate = 44100;
3643
        audio_channels = 2;
3644

3645
        opt_default("packetsize", "2324");
3646
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3647

3648 3649 3650 3651 3652 3653
        /* We have to offset the PTS, so that it is consistent with the SCR.
           SCR starts at 36000, but the first two packs contain only padding
           and the first pack from the other stream, respectively, may also have
           been written before.
           So the real data starts at SCR 36000+3*1200. */
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3654 3655 3656 3657
    } else if(!strcmp(arg, "svcd")) {

        opt_video_codec("mpeg2video");
        opt_audio_codec("mp2");
3658
        opt_format("svcd");
3659 3660

        opt_frame_size(norm ? "480x480" : "480x576");
3661
        opt_frame_rate(NULL, frame_rates[norm]);
3662
        opt_default("g", norm ? "18" : "15");
3663

3664
        opt_default("b", "2040000");
3665 3666
        opt_default("maxrate", "2516000");
        opt_default("minrate", "0"); //1145000;
3667
        opt_default("bufsize", "1835008"); //224*1024*8;
3668
        opt_default("flags", "+scan_offset");
3669

3670

3671
        opt_default("ab", "224000");
3672 3673
        audio_sample_rate = 44100;

3674
        opt_default("packetsize", "2324");
3675

3676 3677 3678 3679
    } else if(!strcmp(arg, "dvd")) {

        opt_video_codec("mpeg2video");
        opt_audio_codec("ac3");
3680
        opt_format("dvd");
3681 3682

        opt_frame_size(norm ? "720x480" : "720x576");
3683
        opt_frame_rate(NULL, frame_rates[norm]);
3684
        opt_default("g", norm ? "18" : "15");
3685

3686
        opt_default("b", "6000000");
3687 3688
        opt_default("maxrate", "9000000");
        opt_default("minrate", "0"); //1500000;
3689
        opt_default("bufsize", "1835008"); //224*1024*8;
3690

3691
        opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3692
        opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3693

3694
        opt_default("ab", "448000");
3695 3696
        audio_sample_rate = 48000;

3697
    } else if(!strncmp(arg, "dv", 2)) {
3698 3699 3700 3701

        opt_format("dv");

        opt_frame_size(norm ? "720x480" : "720x576");
3702 3703
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
                                             (norm ? "yuv411p" : "yuv420p"));
3704
        opt_frame_rate(NULL, frame_rates[norm]);
3705 3706 3707 3708

        audio_sample_rate = 48000;
        audio_channels = 2;

3709 3710
    } else {
        fprintf(stderr, "Unknown target: %s\n", arg);
3711
        av_exit(1);
3712 3713 3714
    }
}

3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731
static void opt_vstats_file (const char *arg)
{
    av_free (vstats_filename);
    vstats_filename=av_strdup (arg);
}

static void opt_vstats (void)
{
    char filename[40];
    time_t today2 = time(NULL);
    struct tm *today = localtime(&today2);

    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
             today->tm_sec);
    opt_vstats_file(filename);
}

3732
static int opt_bsf(const char *opt, const char *arg)
3733 3734 3735 3736 3737
{
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
    AVBitStreamFilterContext **bsfp;

    if(!bsfc){
Alex Beregszaszi's avatar
Alex Beregszaszi committed
3738
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3739
        av_exit(1);
3740 3741
    }

3742 3743 3744
    bsfp= *opt == 'v' ? &video_bitstream_filters :
          *opt == 'a' ? &audio_bitstream_filters :
                        &subtitle_bitstream_filters;
3745 3746 3747 3748
    while(*bsfp)
        bsfp= &(*bsfp)->next;

    *bsfp= bsfc;
3749 3750

    return 0;
3751 3752
}

Michael Niedermayer's avatar
Michael Niedermayer committed
3753 3754
static int opt_preset(const char *opt, const char *arg)
{
3755
    FILE *f=NULL;
3756
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3757
    int i;
3758 3759
    const char *base[2]= { getenv("HOME"),
                           FFMPEG_DATADIR,
3760
                         };
Michael Niedermayer's avatar
Michael Niedermayer committed
3761

3762 3763
    for(i=!base[0]; i<2 && !f; i++){
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3764
        f= fopen(filename, "r");
Michael Niedermayer's avatar
Michael Niedermayer committed
3765 3766 3767 3768
        if(!f){
            char *codec_name= *opt == 'v' ? video_codec_name :
                              *opt == 'a' ? audio_codec_name :
                                            subtitle_codec_name;
3769
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3770
            f= fopen(filename, "r");
Michael Niedermayer's avatar
Michael Niedermayer committed
3771
        }
3772
    }
3773 3774
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
              is_dos_path(arg))){
3775
        av_strlcpy(filename, arg, sizeof(filename));
3776
        f= fopen(filename, "r");
3777
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
3778 3779

    if(!f){
3780
        fprintf(stderr, "File for preset '%s' not found\n", arg);
Michael Niedermayer's avatar
Michael Niedermayer committed
3781 3782 3783 3784
        av_exit(1);
    }

    while(!feof(f)){
3785 3786 3787 3788 3789
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
        if(line[0] == '#' && !e)
            continue;
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
        if(e){
3790
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
Michael Niedermayer's avatar
Michael Niedermayer committed
3791 3792
            av_exit(1);
        }
3793 3794 3795 3796 3797 3798
        if(!strcmp(tmp, "acodec")){
            opt_audio_codec(tmp2);
        }else if(!strcmp(tmp, "vcodec")){
            opt_video_codec(tmp2);
        }else if(!strcmp(tmp, "scodec")){
            opt_subtitle_codec(tmp2);
3799
        }else if(opt_default(tmp, tmp2) < 0){
3800
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3801 3802
            av_exit(1);
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
3803 3804 3805 3806 3807 3808 3809
    }

    fclose(f);

    return 0;
}

3810
static const OptionDef options[] = {
3811
    /* main options */
Michael Niedermayer's avatar
Michael Niedermayer committed
3812 3813
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3814
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3815
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
Fabrice Bellard's avatar
Fabrice Bellard committed
3816 3817 3818
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3819
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3820
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3821
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3822
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3823 3824
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3825
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3826 3827
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3828
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3829
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
Fabrice Bellard's avatar
Fabrice Bellard committed
3830
      "add timings for benchmarking" },
3831
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3832
      "dump each input packet" },
3833
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3834
      "when dumping packets, also dump the payload" },
Fabrice Bellard's avatar
Fabrice Bellard committed
3835
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3836
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3837
    { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3838
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3839
    { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "logging level number or string" },
3840
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3841
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3842 3843
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3844
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3845
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3846
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3847
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3848
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3849
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3850
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3851
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3852 3853

    /* video options */
3854 3855
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3856
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3857
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3858 3859
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3860
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3861 3862 3863 3864
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3865 3866 3867 3868 3869
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3870 3871
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
Måns Rullgård's avatar
Måns Rullgård committed
3872
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3873
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
Fabrice Bellard's avatar
Fabrice Bellard committed
3874
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3875
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3876
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3877
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3878 3879
      "use same video quality as source (implies VBR)" },
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
Stefano Sabatini's avatar
Stefano Sabatini committed
3880
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3881
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3882 3883
      "deinterlace pictures" },
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3884 3885
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3886 3887
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3888
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3889
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3890
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3891
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3892
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3893
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3894 3895

    /* audio options */
3896
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3897
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3898
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3899 3900
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3901 3902
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3903
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3904
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3905 3906
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3907
    { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3908

3909
    /* subtitle options */
3910
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3911 3912 3913
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3914
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3915

3916 3917 3918
    /* grab options */
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3919
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3920 3921

    /* muxer options */
3922 3923
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3924

3925 3926 3927
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3928

3929 3930 3931
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
Michael Niedermayer's avatar
Michael Niedermayer committed
3932

3933
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
Fabrice Bellard's avatar
Fabrice Bellard committed
3934 3935 3936
    { NULL, },
};

3937 3938 3939 3940 3941
int main(int argc, char **argv)
{
    int i;
    int64_t ti;

Luca Abeni's avatar
Luca Abeni committed
3942 3943
    avcodec_register_all();
    avdevice_register_all();
3944 3945
    av_register_all();

Martin Storsjö's avatar
Martin Storsjö committed
3946
#if HAVE_ISATTY
3947 3948
    if(isatty(STDIN_FILENO))
        url_set_interrupt_cb(decode_interrupt_cb);
Martin Storsjö's avatar
Martin Storsjö committed
3949
#endif
3950

3951
    for(i=0; i<CODEC_TYPE_NB; i++){
3952
        avcodec_opts[i]= avcodec_alloc_context2(i);
3953
    }
3954
    avformat_opts = avformat_alloc_context();
3955 3956
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);

3957
    show_banner();
3958 3959 3960 3961 3962 3963

    /* parse options */
    parse_options(argc, argv, options, opt_output_file);

    /* file converter / grab */
    if (nb_output_files <= 0) {
3964
        fprintf(stderr, "At least one output file must be specified\n");
3965
        av_exit(1);
3966 3967 3968
    }

    if (nb_input_files == 0) {
3969
        fprintf(stderr, "At least one input file must be specified\n");
3970
        av_exit(1);
3971 3972 3973
    }

    ti = getutime();
3974 3975 3976
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
                  stream_maps, nb_stream_maps) < 0)
        av_exit(1);
3977 3978 3979 3980 3981
    ti = getutime() - ti;
    if (do_benchmark) {
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
    }

3982
    return av_exit(0);
3983
}