ffmpeg.c 169 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 23 24 25 26 27
#include "config.h"
#include <ctype.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <errno.h>
28
#include <signal.h>
29
#include <limits.h>
30
#include <unistd.h>
31 32 33
#include "libavformat/avformat.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
34
#include "libavutil/opt.h"
35
#include "libavcodec/audioconvert.h"
36 37 38
#include "libavutil/audioconvert.h"
#include "libavutil/parseutils.h"
#include "libavutil/samplefmt.h"
39
#include "libavutil/colorspace.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/intreadwrite.h"
42
#include "libavutil/dict.h"
43
#include "libavutil/mathematics.h"
44
#include "libavutil/pixdesc.h"
45
#include "libavutil/avstring.h"
46
#include "libavutil/libm.h"
47
#include "libavformat/os_support.h"
Michael Niedermayer's avatar
Michael Niedermayer committed
48
#include "libswresample/swresample.h"
49

50 51
#include "libavformat/ffm.h" // not public API

52
#if CONFIG_AVFILTER
53
# include "libavfilter/avcodec.h"
54 55
# include "libavfilter/avfilter.h"
# include "libavfilter/avfiltergraph.h"
56
# include "libavfilter/buffersink.h"
57 58 59
# include "libavfilter/vsrc_buffer.h"
#endif

60
#if HAVE_SYS_RESOURCE_H
61
#include <sys/types.h>
62
#include <sys/time.h>
63
#include <sys/resource.h>
64
#elif HAVE_GETPROCESSTIMES
65 66
#include <windows.h>
#endif
67 68 69 70
#if HAVE_GETPROCESSMEMORYINFO
#include <windows.h>
#include <psapi.h>
#endif
71

72
#if HAVE_SYS_SELECT_H
73 74 75
#include <sys/select.h>
#endif

76 77 78 79 80 81
#if HAVE_TERMIOS_H
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <termios.h>
#elif HAVE_KBHIT
82
#include <conio.h>
Fabrice Bellard's avatar
Fabrice Bellard committed
83
#endif
84
#include <time.h>
Fabrice Bellard's avatar
Fabrice Bellard committed
85

Fabrice Bellard's avatar
Fabrice Bellard committed
86 87
#include "cmdutils.h"

88
#include "libavutil/avassert.h"
89

90
const char program_name[] = "ffmpeg";
91
const int program_birth_year = 2000;
92

Fabrice Bellard's avatar
Fabrice Bellard committed
93
/* select an input stream for an output stream */
94
typedef struct StreamMap {
95
    int disabled;           /** 1 is this mapping is disabled by a negative map */
Fabrice Bellard's avatar
Fabrice Bellard committed
96 97
    int file_index;
    int stream_index;
98 99
    int sync_file_index;
    int sync_stream_index;
100
} StreamMap;
Fabrice Bellard's avatar
Fabrice Bellard committed
101

102 103 104
/**
 * select an input file for an output file
 */
105
typedef struct MetadataMap {
106 107 108
    int  file;      ///< file index
    char type;      ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
    int  index;     ///< stream/chapter/program number
109
} MetadataMap;
110

111
static const OptionDef options[];
Fabrice Bellard's avatar
Fabrice Bellard committed
112

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

115
static int frame_bits_per_raw_sample = 0;
116
static int video_discard = 0;
117
static int same_quant = 0;
118
static int do_deinterlace = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
119
static int intra_dc_precision = 8;
120
static int loop_input = 0;
121
static int loop_output = AVFMT_NOOUTPUTLOOP;
122
static int qp_hist = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
123
static int intra_only = 0;
124 125 126
static const char *video_codec_name    = NULL;
static const char *audio_codec_name    = NULL;
static const char *subtitle_codec_name = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
127 128

static int file_overwrite = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
129
static int do_benchmark = 0;
130
static int do_hex_dump = 0;
131
static int do_pkt_dump = 0;
132
static int do_pass = 0;
133
static const char *pass_logfilename_prefix;
134
static int video_sync_method= -1;
135
static int audio_sync_method= 0;
136
static float audio_drift_threshold= 0.1;
137
static int copy_ts= 0;
138
static int copy_tb= 0;
139
static int opt_shortest = 0;
140
static char *vstats_filename;
141
static FILE *vstats_file;
142
static int copy_initial_nonkeyframes = 0;
143

144
static int audio_volume = 256;
145

146
static int exit_on_error = 0;
147
static int using_stdin = 0;
148
static int run_as_daemon  = 0;
149
static volatile int received_nb_signals = 0;
150 151 152
static int64_t video_size = 0;
static int64_t audio_size = 0;
static int64_t extra_size = 0;
153 154
static int nb_frames_dup = 0;
static int nb_frames_drop = 0;
155
static int input_sync;
156

157
static float dts_delta_threshold = 10;
158

159
static int print_stats = 1;
160

161 162
static uint8_t *audio_buf;
static uint8_t *audio_out;
163
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
164

165
static void *samples;
166 167
static uint8_t *input_tmp= NULL;

Stefano Sabatini's avatar
Stefano Sabatini committed
168
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
Fabrice Bellard's avatar
Fabrice Bellard committed
169

170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
typedef struct InputStream {
    int file_index;
    AVStream *st;
    int discard;             /* true if stream data should be discarded */
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
    AVCodec *dec;

    int64_t       start;     /* time when read started */
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
                                is not defined */
    int64_t       pts;       /* current pts */
    double ts_scale;
    int is_start;            /* is 1 at the start and after a discontinuity */
    int showed_multi_packet_warning;
    AVDictionary *opts;
} InputStream;

typedef struct InputFile {
    AVFormatContext *ctx;
    int eof_reached;      /* true if eof reached */
190
    int ist_index;        /* index of first stream in input_streams */
191 192
    int buffer_size;      /* current total buffer size */
    int64_t ts_offset;
193
    int nb_streams;       /* number of stream that ffmpeg is aware of; may be different
194
                             from ctx.nb_streams if new streams appear during av_read_frame() */
195
    int rate_emu;
196
} InputFile;
197

198
typedef struct OutputStream {
Fabrice Bellard's avatar
Fabrice Bellard committed
199 200
    int file_index;          /* file index */
    int index;               /* stream index in the output file */
201
    int source_index;        /* InputStream index */
Fabrice Bellard's avatar
Fabrice Bellard committed
202
    AVStream *st;            /* stream in the output file */
203 204 205 206
    int encoding_needed;     /* true if encoding needed for this stream */
    int frame_number;
    /* input pts and corresponding output pts
       for A/V sync */
207
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
208
    struct InputStream *sync_ist; /* input stream to sync against */
209
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
210
    AVBitStreamFilterContext *bitstream_filters;
211
    AVCodec *enc;
212
    int64_t max_frames;
213

Fabrice Bellard's avatar
Fabrice Bellard committed
214
    /* video only */
215
    int video_resample;
216
    AVFrame resample_frame;              /* temporary frame for image resampling */
217 218
    struct SwsContext *img_resample_ctx; /* for image resampling */
    int resample_height;
219
    int resample_width;
220
    int resample_pix_fmt;
221
    AVRational frame_rate;
222 223
    int force_fps;
    int top_field_first;
224

225
    float frame_aspect_ratio;
226

227 228 229 230 231
    /* forced key frames */
    int64_t *forced_kf_pts;
    int forced_kf_count;
    int forced_kf_index;

Fabrice Bellard's avatar
Fabrice Bellard committed
232 233
    /* audio only */
    int audio_resample;
234 235 236
    int resample_sample_fmt;
    int resample_channels;
    int resample_sample_rate;
237
    float rematrix_volume;
238
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
239
    FILE *logfile;
240

Michael Niedermayer's avatar
Michael Niedermayer committed
241 242
    struct SwrContext *swr;

243 244 245 246 247 248 249
#if CONFIG_AVFILTER
    AVFilterContext *output_video_filter;
    AVFilterContext *input_video_filter;
    AVFilterBufferRef *picref;
    char *avfilter;
    AVFilterGraph *graph;
#endif
250

251
   int64_t sws_flags;
252
   AVDictionary *opts;
253
   int is_past_recording_time;
254
   int stream_copy;
255
} OutputStream;
Fabrice Bellard's avatar
Fabrice Bellard committed
256 257


258 259 260 261 262 263
#if HAVE_TERMIOS_H

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

264 265 266
typedef struct OutputFile {
    AVFormatContext *ctx;
    AVDictionary *opts;
267
    int ost_index;       /* index of the first stream in output_streams */
268
    int64_t recording_time; /* desired length of the resulting file in microseconds */
269
    int64_t start_time;     /* start time in microseconds */
270
    uint64_t limit_filesize;
271 272
} OutputFile;

273
static InputStream *input_streams = NULL;
274
static int         nb_input_streams = 0;
275
static InputFile   *input_files   = NULL;
276 277
static int         nb_input_files   = 0;

278 279
static OutputStream *output_streams = NULL;
static int        nb_output_streams = 0;
280 281 282
static OutputFile   *output_files   = NULL;
static int        nb_output_files   = 0;

283 284 285 286 287
typedef struct OptionsContext {
    /* input/output options */
    int64_t start_time;
    const char *format;

288 289
    SpecifierOpt *codec_names;
    int        nb_codec_names;
290 291
    SpecifierOpt *audio_channels;
    int        nb_audio_channels;
292 293
    SpecifierOpt *audio_sample_rate;
    int        nb_audio_sample_rate;
294 295
    SpecifierOpt *rematrix_volume;
    int        nb_rematrix_volume;
296 297 298 299 300 301
    SpecifierOpt *frame_rates;
    int        nb_frame_rates;
    SpecifierOpt *frame_sizes;
    int        nb_frame_sizes;
    SpecifierOpt *frame_pix_fmts;
    int        nb_frame_pix_fmts;
302

303 304
    /* input options */
    int64_t input_ts_offset;
305 306 307 308
    int rate_emu;

    SpecifierOpt *ts_scale;
    int        nb_ts_scale;
309 310 311 312

    /* output options */
    StreamMap *stream_maps;
    int     nb_stream_maps;
313 314 315 316 317 318 319 320
    /* first item specifies output metadata, second is input */
    MetadataMap (*meta_data_maps)[2];
    int nb_meta_data_maps;
    int metadata_global_manual;
    int metadata_streams_manual;
    int metadata_chapters_manual;

    int chapters_input_file;
321 322 323

    int64_t recording_time;
    uint64_t limit_filesize;
324 325 326
    float mux_preload;
    float mux_max_delay;

327 328 329 330 331
    int video_disable;
    int audio_disable;
    int subtitle_disable;
    int data_disable;

332 333 334 335
    /* indexed by output file stream index */
    int   *streamid_map;
    int nb_streamid_map;

336 337 338 339 340 341
    SpecifierOpt *metadata;
    int        nb_metadata;
    SpecifierOpt *max_frames;
    int        nb_max_frames;
    SpecifierOpt *bitstream_filters;
    int        nb_bitstream_filters;
342 343
    SpecifierOpt *codec_tags;
    int        nb_codec_tags;
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
    SpecifierOpt *sample_fmts;
    int        nb_sample_fmts;
    SpecifierOpt *qscale;
    int        nb_qscale;
    SpecifierOpt *forced_key_frames;
    int        nb_forced_key_frames;
    SpecifierOpt *force_fps;
    int        nb_force_fps;
    SpecifierOpt *frame_aspect_ratios;
    int        nb_frame_aspect_ratios;
    SpecifierOpt *rc_overrides;
    int        nb_rc_overrides;
    SpecifierOpt *intra_matrices;
    int        nb_intra_matrices;
    SpecifierOpt *inter_matrices;
    int        nb_inter_matrices;
    SpecifierOpt *top_field_first;
    int        nb_top_field_first;
362 363
    SpecifierOpt *presets;
    int        nb_presets;
364 365 366 367
#if CONFIG_AVFILTER
    SpecifierOpt *filters;
    int        nb_filters;
#endif
368 369
} OptionsContext;

370 371 372 373 374 375 376 377 378 379 380 381
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
{\
    int i, ret;\
    for (i = 0; i < o->nb_ ## name; i++) {\
        char *spec = o->name[i].specifier;\
        if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
            outvar = o->name[i].u.type;\
        else if (ret < 0)\
            exit_program(1);\
    }\
}

382
static void reset_options(OptionsContext *o, int is_input)
383 384
{
    const OptionDef *po = options;
385
    OptionsContext bak= *o;
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406

    /* all OPT_SPEC and OPT_STRING can be freed in generic way */
    while (po->name) {
        void *dst = (uint8_t*)o + po->u.off;

        if (po->flags & OPT_SPEC) {
            SpecifierOpt **so = dst;
            int i, *count = (int*)(so + 1);
            for (i = 0; i < *count; i++) {
                av_freep(&(*so)[i].specifier);
                if (po->flags & OPT_STRING)
                    av_freep(&(*so)[i].u.str);
            }
            av_freep(so);
            *count = 0;
        } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
            av_freep(dst);
        po++;
    }

    av_freep(&o->stream_maps);
407
    av_freep(&o->meta_data_maps);
408
    av_freep(&o->streamid_map);
409 410 411

    memset(o, 0, sizeof(*o));

412 413
    if(is_input) o->recording_time = bak.recording_time;
    else         o->recording_time = INT64_MAX;
414 415 416
    o->mux_max_delay  = 0.7;
    o->limit_filesize = UINT64_MAX;
    o->chapters_input_file = INT_MAX;
417 418 419 420 421

    uninit_opts();
    init_opts();
}

422 423
#if CONFIG_AVFILTER

424
static int configure_video_filters(InputStream *ist, OutputStream *ost)
425
{
426
    AVFilterContext *last_filter, *filter;
427 428 429
    /** filter graph containing all filters including input & output */
    AVCodecContext *codec = ost->st->codec;
    AVCodecContext *icodec = ist->st->codec;
430
    enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
431
    AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
432
    AVRational sample_aspect_ratio;
433
    char args[255];
434
    int ret;
435

436
    ost->graph = avfilter_graph_alloc();
437

438 439 440 441 442 443 444 445 446
    if (ist->st->sample_aspect_ratio.num){
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
    }else
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;

    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
             sample_aspect_ratio.num, sample_aspect_ratio.den);

447 448
    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
                                       "src", args, NULL, ost->graph);
449
    if (ret < 0)
450
        return ret;
451
#if FF_API_OLD_VSINK_API
452 453
    ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
                                       "out", NULL, pix_fmts, ost->graph);
454 455 456 457 458 459
#else
    buffersink_params->pixel_fmts = pix_fmts;
    ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
                                       "out", NULL, buffersink_params, ost->graph);
#endif
    av_freep(&buffersink_params);
460
    if (ret < 0)
461
        return ret;
462
    last_filter = ost->input_video_filter;
463

464
    if (codec->width  != icodec->width || codec->height != icodec->height) {
465
        snprintf(args, 255, "%d:%d:flags=0x%X",
466 467
                 codec->width,
                 codec->height,
468
                 (unsigned)ost->sws_flags);
469
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
470
                                                NULL, args, NULL, ost->graph)) < 0)
471 472 473
            return ret;
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
            return ret;
474
        last_filter = filter;
475 476
    }

477
    snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
478
    ost->graph->scale_sws_opts = av_strdup(args);
479

480
    if (ost->avfilter) {
481 482
        AVFilterInOut *outputs = avfilter_inout_alloc();
        AVFilterInOut *inputs  = avfilter_inout_alloc();
483 484

        outputs->name    = av_strdup("in");
485
        outputs->filter_ctx = last_filter;
486 487 488 489
        outputs->pad_idx = 0;
        outputs->next    = NULL;

        inputs->name    = av_strdup("out");
490
        inputs->filter_ctx = ost->output_video_filter;
491 492 493
        inputs->pad_idx = 0;
        inputs->next    = NULL;

494
        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
495
            return ret;
496
        av_freep(&ost->avfilter);
497
    } else {
498
        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
499
            return ret;
500 501
    }

502
    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
503
        return ret;
504

505 506
    codec->width  = ost->output_video_filter->inputs[0]->w;
    codec->height = ost->output_video_filter->inputs[0]->h;
507
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
508
        ost->frame_aspect_ratio ? // overridden by the -aspect cli option
509
        av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
510
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
511 512 513 514 515

    return 0;
}
#endif /* CONFIG_AVFILTER */

Fabrice Bellard's avatar
Fabrice Bellard committed
516 517
static void term_exit(void)
{
518
    av_log(NULL, AV_LOG_QUIET, "%s", "");
519
#if HAVE_TERMIOS_H
520
    if(!run_as_daemon)
521
        tcsetattr (0, TCSANOW, &oldtty);
522
#endif
523
}
Fabrice Bellard's avatar
Fabrice Bellard committed
524

525
static volatile int received_sigterm = 0;
526

527
static void sigterm_handler(int sig)
528 529
{
    received_sigterm = sig;
530
    received_nb_signals++;
531 532 533
    term_exit();
}

Fabrice Bellard's avatar
Fabrice Bellard committed
534 535
static void term_init(void)
{
536
#if HAVE_TERMIOS_H
537
    if(!run_as_daemon){
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
    struct termios tty;

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

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

    tcsetattr (0, TCSANOW, &tty);
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
555
    }
556 557
#endif

558 559
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
Måns Rullgård's avatar
Måns Rullgård committed
560 561 562
#ifdef SIGXCPU
    signal(SIGXCPU, sigterm_handler);
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
563 564 565 566 567
}

/* read a key without blocking */
static int read_key(void)
{
568
    unsigned char ch;
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
#if HAVE_TERMIOS_H
    int n = 1;
    struct timeval tv;
    fd_set rfds;

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

        return n;
    }
#elif HAVE_KBHIT
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
#    if HAVE_PEEKNAMEDPIPE
    static int is_pipe;
    static HANDLE input_handle;
    DWORD dw, nchars;
    if(!input_handle){
        input_handle = GetStdHandle(STD_INPUT_HANDLE);
        is_pipe = !GetConsoleMode(input_handle, &dw);
    }

    if (stdin->_cnt > 0) {
        read(0, &ch, 1);
        return ch;
    }
    if (is_pipe) {
        /* When running under a GUI, you will end here. */
        if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
            return -1;
        //Read it
        if(nchars != 0) {
            read(0, &ch, 1);
            return ch;
        }else{
            return -1;
        }
    }
#    endif
613 614
    if(kbhit())
        return(getch());
615
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
616 617 618
    return -1;
}

619 620
static int decode_interrupt_cb(void)
{
621
    return received_nb_signals > 1;
622 623
}

624
void exit_program(int ret)
625 626 627 628 629
{
    int i;

    /* close files */
    for(i=0;i<nb_output_files;i++) {
630
        AVFormatContext *s = output_files[i].ctx;
631
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
632
            avio_close(s->pb);
633
        avformat_free_context(s);
634
        av_dict_free(&output_files[i].opts);
635
    }
636
    for(i=0;i<nb_input_files;i++) {
637
        av_close_input_file(input_files[i].ctx);
638
    }
639 640
    for (i = 0; i < nb_input_streams; i++)
        av_dict_free(&input_streams[i].opts);
641 642 643 644 645

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

646 647
    av_freep(&input_streams);
    av_freep(&input_files);
648
    av_freep(&output_streams);
649
    av_freep(&output_files);
650

651
    uninit_opts();
652 653
    av_free(audio_buf);
    av_free(audio_out);
654
    allocated_audio_buf_size= allocated_audio_out_size= 0;
655
    av_free(samples);
656

657 658 659 660
#if CONFIG_AVFILTER
    avfilter_uninit();
#endif

661 662
    av_freep(&input_tmp);

663
    if (received_sigterm) {
664 665
        av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
               (int) received_sigterm);
666 667 668
        exit (255);
    }

669
    exit(ret); /* not all OS-es handle main() return value */
670 671
}

672 673 674 675
static void assert_avoptions(AVDictionary *m)
{
    AVDictionaryEntry *t;
    if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
676
        av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
677
        exit_program(1);
678 679 680
    }
}

681 682 683 684 685 686
static void assert_codec_experimental(AVCodecContext *c, int encoder)
{
    const char *codec_string = encoder ? "encoder" : "decoder";
    AVCodec *codec;
    if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
        c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
687
        av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
688 689
                "results.\nAdd '-strict experimental' if you want to use it.\n",
                codec_string, c->codec->name);
690
        codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
691
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
692
            av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
693
                   codec_string, codec->name);
694
        exit_program(1);
695 696 697
    }
}

698 699 700
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
{
    if(codec && codec->sample_fmts){
701
        const enum AVSampleFormat *p= codec->sample_fmts;
702 703 704 705
        for(; *p!=-1; p++){
            if(*p == st->codec->sample_fmt)
                break;
        }
706
        if (*p == -1) {
707 708
            if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
                av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
709
            if(av_get_sample_fmt_name(st->codec->sample_fmt))
710 711 712 713 714
            av_log(NULL, AV_LOG_WARNING,
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
                   av_get_sample_fmt_name(st->codec->sample_fmt),
                   codec->name,
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
715
            st->codec->sample_fmt = codec->sample_fmts[0];
716
        }
717 718 719
    }
}

720 721 722 723
static void choose_sample_rate(AVStream *st, AVCodec *codec)
{
    if(codec && codec->supported_samplerates){
        const int *p= codec->supported_samplerates;
724
        int best=0;
725 726 727 728 729 730 731 732
        int best_dist=INT_MAX;
        for(; *p; p++){
            int dist= abs(st->codec->sample_rate - *p);
            if(dist < best_dist){
                best_dist= dist;
                best= *p;
            }
        }
733 734 735
        if(best_dist){
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
        }
736 737 738 739
        st->codec->sample_rate= best;
    }
}

740 741 742 743
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
{
    if(codec && codec->pix_fmts){
        const enum PixelFormat *p= codec->pix_fmts;
744 745 746 747 748 749 750
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
            if(st->codec->codec_id==CODEC_ID_MJPEG){
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
            }
        }
751 752 753 754
        for(; *p!=-1; p++){
            if(*p == st->codec->pix_fmt)
                break;
        }
755
        if (*p == -1) {
756
            if(st->codec->pix_fmt != PIX_FMT_NONE)
757 758 759 760 761
                av_log(NULL, AV_LOG_WARNING,
                        "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
                        av_pix_fmt_descriptors[st->codec->pix_fmt].name,
                        codec->name,
                        av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
762
            st->codec->pix_fmt = codec->pix_fmts[0];
763
        }
764 765 766
    }
}

767
static double get_sync_ipts(const OutputStream *ost)
768
{
769
    const InputStream *ist = ost->sync_ist;
770 771
    OutputFile *of = &output_files[ost->file_index];
    return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
772 773
}

774 775
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
{
776 777
    int ret;

778 779 780 781 782
    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,
783
                                          pkt->flags & AV_PKT_FLAG_KEY);
784
        if(a>0){
785 786
            av_free_packet(pkt);
            new_pkt.destruct= av_destruct_packet;
787
        } else if(a<0){
788 789 790
            av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
                   bsfc->filter->name, pkt->stream_index,
                   avctx->codec ? avctx->codec->name : "copy");
791
            print_error("", a);
792
            if (exit_on_error)
793
                exit_program(1);
794 795 796 797 798 799
        }
        *pkt= new_pkt;

        bsfc= bsfc->next;
    }

800 801 802
    ret= av_interleaved_write_frame(s, pkt);
    if(ret < 0){
        print_error("av_interleaved_write_frame()", ret);
803
        exit_program(1);
804
    }
805 806
}

807
static void do_audio_out(AVFormatContext *s,
808 809
                         OutputStream *ost,
                         InputStream *ist,
Fabrice Bellard's avatar
Fabrice Bellard committed
810 811
                         unsigned char *buf, int size)
{
812
    uint8_t *buftmp;
813
    int64_t audio_out_size, audio_buf_size;
814
    int64_t allocated_for_size= size;
815

816
    int size_out, frame_bytes, ret, resample_changed;
817
    AVCodecContext *enc= ost->st->codec;
818
    AVCodecContext *dec= ist->st->codec;
819 820
    int osize = av_get_bytes_per_sample(enc->sample_fmt);
    int isize = av_get_bytes_per_sample(dec->sample_fmt);
821 822
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);

823 824
need_realloc:
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
825
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
Vitor Sessak's avatar
Vitor Sessak committed
826
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
827
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
828 829 830 831 832 833 834 835
    audio_buf_size*= osize*enc->channels;

    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
    if(coded_bps > 8*osize)
        audio_out_size= audio_out_size * coded_bps / (8*osize);
    audio_out_size += FF_MIN_BUFFER_SIZE;

    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
836
        av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
837
        exit_program(1);
838
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
839

840 841
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
842
    if (!audio_buf || !audio_out){
843
        av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
844
        exit_program(1);
845
    }
846

Michael Niedermayer's avatar
Michael Niedermayer committed
847 848
    if (enc->channels != dec->channels
     || enc->sample_fmt != dec->sample_fmt)
849 850
        ost->audio_resample = 1;

851 852 853 854
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
                       ost->resample_channels    != dec->channels   ||
                       ost->resample_sample_rate != dec->sample_rate;

Michael Niedermayer's avatar
Michael Niedermayer committed
855
    if ((ost->audio_resample && !ost->swr) || resample_changed) {
856 857
        if (resample_changed) {
            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
858
                   ist->file_index, ist->st->index,
859 860 861 862 863
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
            ost->resample_sample_fmt  = dec->sample_fmt;
            ost->resample_channels    = dec->channels;
            ost->resample_sample_rate = dec->sample_rate;
Michael Niedermayer's avatar
Michael Niedermayer committed
864
            swr_free(&ost->swr);
865
        }
866 867 868
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
        if (audio_sync_method <= 1 &&
            ost->resample_sample_fmt  == enc->sample_fmt &&
869 870
            ost->resample_channels    == enc->channels   &&
            ost->resample_sample_rate == enc->sample_rate) {
Michael Niedermayer's avatar
Michael Niedermayer committed
871
            //ost->swr = NULL;
872 873
            ost->audio_resample = 0;
        } else {
Michael Niedermayer's avatar
Michael Niedermayer committed
874 875 876 877
            ost->swr = swr_alloc2(ost->swr,
                                  enc->channel_layout, enc->sample_fmt, enc->sample_rate,
                                  dec->channel_layout, dec->sample_fmt, dec->sample_rate,
                                  0, NULL);
878
            av_set_double(ost->swr, "rmvol", ost->rematrix_volume);
Michael Niedermayer's avatar
Michael Niedermayer committed
879 880 881 882
            av_set_int(ost->swr, "ich", dec->channels);
            av_set_int(ost->swr, "och", enc->channels);
            if(audio_sync_method>1) av_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE);
            if(ost->swr && swr_init(ost->swr) < 0){
883
                av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
884 885 886 887
                swr_free(&ost->swr);
            }

            if (!ost->swr) {
888
                av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
Stefano Sabatini's avatar
Stefano Sabatini committed
889 890
                        dec->channels, dec->sample_rate,
                        enc->channels, enc->sample_rate);
891
                exit_program(1);
Stefano Sabatini's avatar
Stefano Sabatini committed
892
            }
893
        }
894 895
    }

Michael Niedermayer's avatar
Michael Niedermayer committed
896
    av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
897

898
    if(audio_sync_method){
899
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
900 901
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
        double idelta= delta*dec->sample_rate / enc->sample_rate;
902
        int byte_delta= ((int)idelta)*2*dec->channels;
903

904 905
        //FIXME resample delay
        if(fabs(delta) > 50){
906
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
907
                if(byte_delta < 0){
908
                    byte_delta= FFMAX(byte_delta, -size);
909 910
                    size += byte_delta;
                    buf  -= byte_delta;
911
                    av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
912 913 914 915 916 917
                    if(!size)
                        return;
                    ist->is_start=0;
                }else{
                    input_tmp= av_realloc(input_tmp, byte_delta + size);

918 919 920 921 922
                    if(byte_delta > allocated_for_size - size){
                        allocated_for_size= byte_delta + (int64_t)size;
                        goto need_realloc;
                    }
                    ist->is_start=0;
923 924 925 926 927

                    memset(input_tmp, 0, byte_delta);
                    memcpy(input_tmp + byte_delta, buf, size);
                    buf= input_tmp;
                    size += byte_delta;
928
                    av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
929 930
                }
            }else if(audio_sync_method>1){
931
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
932
                av_assert0(ost->audio_resample);
933 934
                av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
                       delta, comp, enc->sample_rate);
935
//                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));
Michael Niedermayer's avatar
Michael Niedermayer committed
936
                swr_compensate(ost->swr, comp, enc->sample_rate);
937
            }
938
        }
939
    }else
940
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
941
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
Fabrice Bellard's avatar
Fabrice Bellard committed
942 943 944

    if (ost->audio_resample) {
        buftmp = audio_buf;
Michael Niedermayer's avatar
Michael Niedermayer committed
945 946
        size_out = swr_convert(ost->swr, (      uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
                                         (const uint8_t*[]){buf   }, size / (dec->channels * isize));
947
        size_out = size_out * enc->channels * osize;
Fabrice Bellard's avatar
Fabrice Bellard committed
948 949 950 951 952
    } else {
        buftmp = buf;
        size_out = size;
    }

Michael Niedermayer's avatar
Michael Niedermayer committed
953
    av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
954

Fabrice Bellard's avatar
Fabrice Bellard committed
955
    /* now encode as many frames as possible */
956
    if (enc->frame_size > 1) {
Fabrice Bellard's avatar
Fabrice Bellard committed
957
        /* output resampled raw samples */
958
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
959
            av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
960
            exit_program(1);
961
        }
962
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
Fabrice Bellard's avatar
Fabrice Bellard committed
963

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

966
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
967 968 969
            AVPacket pkt;
            av_init_packet(&pkt);

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

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

974
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
975
                                       (short *)audio_buf);
976
            if (ret < 0) {
977
                av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
978
                exit_program(1);
979
            }
980
            audio_size += ret;
981 982 983
            pkt.stream_index= ost->index;
            pkt.data= audio_out;
            pkt.size= ret;
984
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
985
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
986
            pkt.flags |= AV_PKT_FLAG_KEY;
987
            write_frame(s, &pkt, enc, ost->bitstream_filters);
988

989
            ost->sync_opts += enc->frame_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
990 991
        }
    } else {
992 993
        AVPacket pkt;
        av_init_packet(&pkt);
994

995
        ost->sync_opts += size_out / (osize * enc->channels);
996

997
        /* output a pcm frame */
998 999 1000
        /* determine the size of the coded buffer */
        size_out /= osize;
        if (coded_bps)
1001
            size_out = size_out*coded_bps/8;
1002

1003
        if(size_out > audio_out_size){
1004
            av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1005
            exit_program(1);
1006 1007
        }

1008
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1009
        ret = avcodec_encode_audio(enc, audio_out, size_out,
1010
                                   (short *)buftmp);
1011
        if (ret < 0) {
1012
            av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1013
            exit_program(1);
1014
        }
1015
        audio_size += ret;
1016 1017 1018
        pkt.stream_index= ost->index;
        pkt.data= audio_out;
        pkt.size= ret;
1019
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1020
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1021
        pkt.flags |= AV_PKT_FLAG_KEY;
1022
        write_frame(s, &pkt, enc, ost->bitstream_filters);
Fabrice Bellard's avatar
Fabrice Bellard committed
1023 1024 1025
    }
}

1026
static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1027 1028 1029 1030
{
    AVCodecContext *dec;
    AVPicture *picture2;
    AVPicture picture_tmp;
1031
    uint8_t *buf = 0;
1032

1033
    dec = ist->st->codec;
1034 1035

    /* deinterlace : must be done before any resize */
1036
    if (do_deinterlace) {
1037 1038 1039 1040 1041 1042 1043
        int size;

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

1045 1046 1047
        picture2 = &picture_tmp;
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);

Ramiro Polla's avatar
Ramiro Polla committed
1048 1049 1050
        if(avpicture_deinterlace(picture2, picture,
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
            /* if error, do not deinterlace */
1051
            av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
Ramiro Polla's avatar
Ramiro Polla committed
1052 1053 1054 1055
            av_free(buf);
            buf = NULL;
            picture2 = picture;
        }
1056 1057 1058 1059 1060 1061 1062 1063 1064
    } else {
        picture2 = picture;
    }

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

1065
static void do_subtitle_out(AVFormatContext *s,
1066 1067
                            OutputStream *ost,
                            InputStream *ist,
1068 1069 1070 1071
                            AVSubtitle *sub,
                            int64_t pts)
{
    static uint8_t *subtitle_out = NULL;
1072
    int subtitle_out_max_size = 1024 * 1024;
1073 1074 1075 1076 1077
    int subtitle_out_size, nb, i;
    AVCodecContext *enc;
    AVPacket pkt;

    if (pts == AV_NOPTS_VALUE) {
1078
        av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1079
        if (exit_on_error)
1080
            exit_program(1);
1081 1082 1083
        return;
    }

1084
    enc = ost->st->codec;
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098

    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++) {
1099
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1100 1101 1102 1103
        // 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;
1104
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1105
                                                    subtitle_out_max_size, sub);
1106
        if (subtitle_out_size < 0) {
1107
            av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1108
            exit_program(1);
1109
        }
1110

1111 1112 1113 1114
        av_init_packet(&pkt);
        pkt.stream_index = ost->index;
        pkt.data = subtitle_out;
        pkt.size = subtitle_out_size;
1115
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1116 1117 1118 1119 1120 1121 1122 1123
        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;
        }
1124
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1125 1126 1127
    }
}

1128
static int bit_buffer_size= 1024*256;
1129
static uint8_t *bit_buffer= NULL;
1130

1131 1132 1133 1134 1135
static void do_video_resample(OutputStream *ost,
                              InputStream *ist,
                              AVFrame *in_picture,
                              AVFrame **out_picture)
{
1136
#if CONFIG_AVFILTER
1137
    *out_picture = in_picture;
1138
#else
1139 1140
    AVCodecContext *dec = ist->st->codec;
    AVCodecContext *enc = ost->st->codec;
1141 1142 1143
    int resample_changed = ost->resample_width   != dec->width  ||
                           ost->resample_height  != dec->height ||
                           ost->resample_pix_fmt != dec->pix_fmt;
1144

1145
    *out_picture = in_picture;
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
    if (resample_changed) {
        av_log(NULL, AV_LOG_INFO,
               "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
               ist->file_index, ist->st->index,
               ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
               dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));
        ost->resample_width   = dec->width;
        ost->resample_height  = dec->height;
        ost->resample_pix_fmt = dec->pix_fmt;
    }

    ost->video_resample = dec->width   != enc->width  ||
                          dec->height  != enc->height ||
                          dec->pix_fmt != enc->pix_fmt;

    if (ost->video_resample) {
        *out_picture = &ost->resample_frame;
        if (!ost->img_resample_ctx || resample_changed) {
            /* initialize the destination picture */
            if (!ost->resample_frame.data[0]) {
                avcodec_get_frame_defaults(&ost->resample_frame);
                if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
                                    enc->width, enc->height)) {
1169
                    av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1170 1171 1172 1173 1174 1175 1176 1177 1178
                    exit_program(1);
                }
            }
            /* initialize a new scaler context */
            sws_freeContext(ost->img_resample_ctx);
            ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
                                                   enc->width, enc->height, enc->pix_fmt,
                                                   ost->sws_flags, NULL, NULL, NULL);
            if (ost->img_resample_ctx == NULL) {
1179
                av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
                exit_program(1);
            }
        }
        sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
              0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
    }
#endif
}


1190
static void do_video_out(AVFormatContext *s,
1191 1192
                         OutputStream *ost,
                         InputStream *ist,
1193
                         AVFrame *in_picture,
1194
                         int *frame_size, float quality)
Fabrice Bellard's avatar
Fabrice Bellard committed
1195
{
1196
    int nb_frames, i, ret, format_video_sync;
1197
    AVFrame *final_picture;
1198
    AVCodecContext *enc;
1199
    double sync_ipts;
1200
    double duration = 0;
1201

1202
    enc = ost->st->codec;
Fabrice Bellard's avatar
Fabrice Bellard committed
1203

1204 1205 1206 1207 1208 1209 1210 1211
    if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
        duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
        if(ist->st->avg_frame_rate.num)
            duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));

        duration /= av_q2d(enc->time_base);
    }

1212 1213
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);

1214 1215 1216
    /* by default, we output a single frame */
    nb_frames = 1;

1217 1218
    *frame_size = 0;

1219 1220 1221 1222 1223
    format_video_sync = video_sync_method;
    if (format_video_sync < 0)
        format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;

    if (format_video_sync) {
1224
        double vdelta = sync_ipts - ost->sync_opts + duration;
1225 1226 1227
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
        if (vdelta < -1.1)
            nb_frames = 0;
1228
        else if (format_video_sync == 2) {
1229 1230 1231
            if(vdelta<=-0.6){
                nb_frames=0;
            }else if(vdelta>0.6)
1232
                ost->sync_opts= lrintf(sync_ipts);
1233
        }else if (vdelta > 1.1)
1234
            nb_frames = lrintf(vdelta);
1235
//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);
1236 1237
        if (nb_frames == 0){
            ++nb_frames_drop;
1238
            av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1239
        }else if (nb_frames > 1) {
1240
            nb_frames_dup += nb_frames - 1;
1241
            av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1242 1243
        }
    }else
1244
        ost->sync_opts= lrintf(sync_ipts);
1245

1246
    nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1247
    if (nb_frames <= 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
1248
        return;
1249

1250
    do_video_resample(ost, ist, in_picture, &final_picture);
1251

Fabrice Bellard's avatar
Fabrice Bellard committed
1252
    /* duplicates frame if needed */
1253
    for(i=0;i<nb_frames;i++) {
1254 1255 1256 1257
        AVPacket pkt;
        av_init_packet(&pkt);
        pkt.stream_index= ost->index;

1258 1259
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
            /* raw pictures are written as AVPicture structure to
1260
               avoid any copies. We support temporarily the older
1261
               method. */
1262 1263
            enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
            enc->coded_frame->top_field_first  = in_picture->top_field_first;
1264 1265
            pkt.data= (uint8_t *)final_picture;
            pkt.size=  sizeof(AVPicture);
1266
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1267
            pkt.flags |= AV_PKT_FLAG_KEY;
1268

1269
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1270
        } else {
1271
            AVFrame big_picture;
1272 1273

            big_picture= *final_picture;
1274 1275 1276
            /* better than nothing: use input picture interlaced
               settings */
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1277
            if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1278
                if (ost->top_field_first == -1)
1279 1280
                    big_picture.top_field_first = in_picture->top_field_first;
                else
1281
                    big_picture.top_field_first = !!ost->top_field_first;
1282
            }
1283

1284
            /* handles same_quant here. This is not correct because it may
Fabrice Bellard's avatar
Fabrice Bellard committed
1285
               not be a global option */
1286
            big_picture.quality = quality;
1287
            if (!enc->me_threshold)
1288
                big_picture.pict_type = 0;
1289
//            big_picture.pts = AV_NOPTS_VALUE;
1290 1291
            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);
1292
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1293 1294
            if (ost->forced_kf_index < ost->forced_kf_count &&
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1295
                big_picture.pict_type = AV_PICTURE_TYPE_I;
1296 1297
                ost->forced_kf_index++;
            }
1298
            ret = avcodec_encode_video(enc,
1299
                                       bit_buffer, bit_buffer_size,
Michael Niedermayer's avatar
Michael Niedermayer committed
1300
                                       &big_picture);
1301
            if (ret < 0) {
1302
                av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1303
                exit_program(1);
1304
            }
1305

1306
            if(ret>0){
1307
                pkt.data= bit_buffer;
1308
                pkt.size= ret;
1309
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1310
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1311
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1312 1313
   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);*/
1314

1315
                if(enc->coded_frame->key_frame)
1316
                    pkt.flags |= AV_PKT_FLAG_KEY;
1317
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1318
                *frame_size = ret;
1319
                video_size += ret;
1320 1321
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
                //        enc->frame_number-1, ret, enc->pict_type);
1322 1323 1324 1325
                /* if two pass, output log */
                if (ost->logfile && enc->stats_out) {
                    fprintf(ost->logfile, "%s", enc->stats_out);
                }
1326
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
1327
        }
1328
        ost->sync_opts++;
1329
        ost->frame_number++;
Fabrice Bellard's avatar
Fabrice Bellard committed
1330 1331 1332
    }
}

1333 1334
static double psnr(double d)
{
1335
    return -10.0*log(d)/log(10.0);
1336 1337
}

1338
static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1339
                           int frame_size)
1340 1341 1342 1343
{
    AVCodecContext *enc;
    int frame_number;
    double ti1, bitrate, avg_bitrate;
1344

1345
    /* this is executed just the first time do_video_stats is called */
1346 1347 1348
    if (!vstats_file) {
        vstats_file = fopen(vstats_filename, "w");
        if (!vstats_file) {
1349
            perror("fopen");
1350
            exit_program(1);
1351 1352 1353
        }
    }

1354
    enc = ost->st->codec;
1355
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1356
        frame_number = ost->frame_number;
1357
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1358
        if (enc->flags&CODEC_FLAG_PSNR)
1359
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1360

1361
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1362
        /* compute pts value */
1363
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1364 1365
        if (ti1 < 0.01)
            ti1 = 0.01;
1366

1367
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1368
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1369
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1370
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1371
        fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1372
    }
1373 1374
}

1375
static void print_report(OutputFile *output_files,
1376
                         OutputStream *ost_table, int nb_ostreams,
1377
                         int is_last_report, int64_t timer_start, int64_t cur_time)
1378 1379
{
    char buf[1024];
1380
    OutputStream *ost;
1381
    AVFormatContext *oc;
1382
    int64_t total_size;
1383 1384
    AVCodecContext *enc;
    int frame_number, vid, i;
1385 1386
    double bitrate;
    int64_t pts = INT64_MAX;
1387
    static int64_t last_time = -1;
1388
    static int qp_histogram[52];
1389
    int hours, mins, secs, us;
1390

1391 1392
    if (!print_stats && !is_last_report)
        return;
1393

1394 1395 1396 1397
    if (!is_last_report) {
        if (last_time == -1) {
            last_time = cur_time;
            return;
1398
        }
1399 1400 1401 1402 1403
        if ((cur_time - last_time) < 500000)
            return;
        last_time = cur_time;
    }

1404

1405
    oc = output_files[0].ctx;
1406

1407 1408
    total_size = avio_size(oc->pb);
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1409
        total_size= avio_tell(oc->pb);
1410

1411 1412 1413
    buf[0] = '\0';
    vid = 0;
    for(i=0;i<nb_ostreams;i++) {
1414
        float q = -1;
1415
        ost = &ost_table[i];
1416
        enc = ost->st->codec;
1417
        if (!ost->stream_copy && enc->coded_frame)
1418
            q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1419
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1420
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1421
        }
1422
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1423
            float t = (cur_time-timer_start) / 1000000.0;
1424

1425
            frame_number = ost->frame_number;
1426
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
Michael Niedermayer's avatar
Michael Niedermayer committed
1427
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1428
            if(is_last_report)
1429
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1430
            if(qp_hist){
1431
                int j;
1432
                int qp = lrintf(q);
1433
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1434 1435 1436 1437
                    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)));
            }
1438 1439 1440 1441 1442
            if (enc->flags&CODEC_FLAG_PSNR){
                int j;
                double error, error_sum=0;
                double scale, scale_sum=0;
                char type[3]= {'Y','U','V'};
1443
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
                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;
1455
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1456
                }
1457
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1458
            }
1459 1460 1461
            vid = 1;
        }
        /* compute min output value */
1462 1463
        pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
                                      ost->st->time_base, AV_TIME_BASE_Q));
1464
    }
1465

1466 1467 1468 1469 1470 1471
    secs = pts / AV_TIME_BASE;
    us = pts % AV_TIME_BASE;
    mins = secs / 60;
    secs %= 60;
    hours = mins / 60;
    mins %= 60;
1472

1473
    bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1474

1475 1476 1477 1478 1479 1480 1481
    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
             "size=%8.0fkB time=", total_size / 1024.0);
    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
             "%02d:%02d:%02d.%02d ", hours, mins, secs,
             (100 * us) / AV_TIME_BASE);
    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
             "bitrate=%6.1fkbits/s", bitrate);
1482

1483 1484 1485
    if (nb_frames_dup || nb_frames_drop)
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
                nb_frames_dup, nb_frames_drop);
1486

1487
    av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
1488 1489

    fflush(stderr);
1490

1491
    if (is_last_report) {
1492
        int64_t raw= audio_size + video_size + extra_size;
1493 1494 1495 1496 1497 1498
        av_log(NULL, AV_LOG_INFO, "\n");
        av_log(NULL, AV_LOG_INFO, "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
1499 1500
        );
    }
1501 1502
}

1503
static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1504 1505 1506 1507 1508 1509 1510
{
    int fill_char = 0x00;
    if (sample_fmt == AV_SAMPLE_FMT_U8)
        fill_char = 0x80;
    memset(buf, fill_char, size);
}

1511
static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1512 1513 1514 1515
{
    int i, ret;

    for (i = 0; i < nb_ostreams; i++) {
1516 1517 1518 1519
        OutputStream   *ost = &ost_table[i];
        AVCodecContext *enc = ost->st->codec;
        AVFormatContext *os = output_files[ost->file_index].ctx;

1520
        if (!ost->encoding_needed)
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
            continue;

        if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
            continue;
        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
            continue;

        for(;;) {
            AVPacket pkt;
            int fifo_bytes;
            av_init_packet(&pkt);
            pkt.stream_index= ost->index;

            switch (ost->st->codec->codec_type) {
            case AVMEDIA_TYPE_AUDIO:
                fifo_bytes = av_fifo_size(ost->fifo);
                ret = 0;
                /* encode any samples remaining in fifo */
                if (fifo_bytes > 0) {
                    int osize = av_get_bytes_per_sample(enc->sample_fmt);
                    int fs_tmp = enc->frame_size;

                    av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
                    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 (allocated_audio_buf_size < frame_bytes)
1549
                            exit_program(1);
1550
                        generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1551 1552
                    }

1553 1554 1555 1556 1557 1558 1559
                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
                    pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
                                              ost->st->time_base.num, enc->sample_rate);
                    enc->frame_size = fs_tmp;
                }
                if (ret <= 0) {
                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1560
                }
1561
                if (ret < 0) {
1562
                    av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1563 1564 1565 1566 1567 1568 1569 1570
                    exit_program(1);
                }
                audio_size += ret;
                pkt.flags |= AV_PKT_FLAG_KEY;
                break;
            case AVMEDIA_TYPE_VIDEO:
                ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
                if (ret < 0) {
1571
                    av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
                    exit_program(1);
                }
                video_size += ret;
                if(enc->coded_frame && enc->coded_frame->key_frame)
                    pkt.flags |= AV_PKT_FLAG_KEY;
                if (ost->logfile && enc->stats_out) {
                    fprintf(ost->logfile, "%s", enc->stats_out);
                }
                break;
            default:
                ret=-1;
1583
            }
1584 1585 1586 1587 1588 1589 1590 1591

            if (ret <= 0)
                break;
            pkt.data = bit_buffer;
            pkt.size = ret;
            if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
            write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1592 1593 1594 1595
        }
    }
}

1596
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1597
static int output_packet(InputStream *ist, int ist_index,
1598
                         OutputStream *ost_table, int nb_ostreams,
1599
                         const AVPacket *pkt)
1600 1601
{
    AVFormatContext *os;
1602
    OutputStream *ost;
1603
    int ret = 0, i;
1604
    int got_output;
1605
    void *buffer_to_free = NULL;
1606
    static unsigned int samples_size= 0;
1607
    AVSubtitle subtitle, *subtitle_to_free;
1608
    int64_t pkt_pts = AV_NOPTS_VALUE;
1609
#if CONFIG_AVFILTER
1610
    int frame_available;
1611
#endif
1612
    float quality = 0;
1613

1614
    AVPacket avpkt;
1615
    int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1616

1617 1618 1619
    if(ist->next_pts == AV_NOPTS_VALUE)
        ist->next_pts= ist->pts;

1620 1621
    if (pkt == NULL) {
        /* EOF handling */
1622
        av_init_packet(&avpkt);
1623 1624
        avpkt.data = NULL;
        avpkt.size = 0;
1625
        goto handle_eof;
1626 1627
    } else {
        avpkt = *pkt;
1628 1629
    }

1630 1631
    if(pkt->dts != AV_NOPTS_VALUE)
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1632 1633
    if(pkt->pts != AV_NOPTS_VALUE)
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1634

1635
    //while we have more to decode or while the decoder did output something on EOF
1636
    while (avpkt.size > 0 || (!pkt && got_output)) {
1637 1638
        uint8_t *data_buf, *decoded_data_buf;
        int data_size, decoded_data_size;
1639
        AVFrame *decoded_frame, *filtered_frame;
1640
    handle_eof:
1641
        ist->pts= ist->next_pts;
1642

1643 1644 1645
        if(avpkt.size && avpkt.size != pkt->size)
            av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
                   "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1646
            ist->showed_multi_packet_warning=1;
1647

1648
        /* decode the packet if needed */
1649
        decoded_frame    = filtered_frame = NULL;
1650 1651 1652 1653
        decoded_data_buf = NULL; /* fail safe */
        decoded_data_size= 0;
        data_buf  = avpkt.data;
        data_size = avpkt.size;
1654
        subtitle_to_free = NULL;
1655
        if (ist->decoding_needed) {
1656
            switch(ist->st->codec->codec_type) {
1657
            case AVMEDIA_TYPE_AUDIO:{
1658 1659
                if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
                    samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1660 1661 1662
                    av_free(samples);
                    samples= av_malloc(samples_size);
                }
1663
                decoded_data_size= samples_size;
1664 1665
                    /* XXX: could avoid copy if PCM 16 bits with same
                       endianness as CPU */
1666
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1667
                                            &avpkt);
1668
                if (ret < 0)
1669
                    return ret;
1670 1671
                avpkt.data += ret;
                avpkt.size -= ret;
1672
                data_size   = ret;
1673
                got_output  = decoded_data_size > 0;
1674
                /* Some bug in mpeg audio decoder gives */
1675
                /* decoded_data_size < 0, it seems they are overflows */
1676
                if (!got_output) {
1677 1678 1679
                    /* no audio frame */
                    continue;
                }
1680 1681
                decoded_data_buf = (uint8_t *)samples;
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1682
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
Michael Niedermayer's avatar
Michael Niedermayer committed
1683
                break;}
1684
            case AVMEDIA_TYPE_VIDEO:
1685 1686
                    if (!(decoded_frame = avcodec_alloc_frame()))
                        return AVERROR(ENOMEM);
1687 1688
                    avpkt.pts = pkt_pts;
                    avpkt.dts = ist->pts;
1689
                    pkt_pts = AV_NOPTS_VALUE;
1690

1691
                    ret = avcodec_decode_video2(ist->st->codec,
1692 1693
                                                decoded_frame, &got_output, &avpkt);
                    quality = same_quant ? decoded_frame->quality : 0;
1694
                    if (ret < 0)
1695
                        goto fail;
1696
                    if (!got_output) {
1697
                        /* no picture yet */
1698
                        av_freep(&decoded_frame);
1699 1700
                        goto discard_packet;
                    }
1701
                    ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
1702
                    if (ist->st->codec->time_base.num != 0) {
1703
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1704
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1705
                                          ist->st->codec->time_base.num * ticks) /
1706
                            ist->st->codec->time_base.den;
1707
                    }
1708
                    avpkt.size = 0;
1709
                    buffer_to_free = NULL;
1710
                    pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1711
                    break;
1712
            case AVMEDIA_TYPE_SUBTITLE:
1713
                ret = avcodec_decode_subtitle2(ist->st->codec,
1714
                                               &subtitle, &got_output, &avpkt);
1715
                if (ret < 0)
1716
                    return ret;
1717
                if (!got_output) {
1718
                    goto discard_packet;
1719
                }
1720
                subtitle_to_free = &subtitle;
1721
                avpkt.size = 0;
1722 1723
                break;
            default:
1724
                return -1;
1725 1726
            }
        } else {
1727
            switch(ist->st->codec->codec_type) {
1728
            case AVMEDIA_TYPE_AUDIO:
1729
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1730
                    ist->st->codec->sample_rate;
1731
                break;
1732
            case AVMEDIA_TYPE_VIDEO:
1733
                if (ist->st->codec->time_base.num != 0) {
1734
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1735
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1736
                                      ist->st->codec->time_base.num * ticks) /
1737
                        ist->st->codec->time_base.den;
1738
                }
1739
                break;
1740
            }
1741
            avpkt.size = 0;
1742
        }
1743

1744 1745
#if CONFIG_AVFILTER
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1746 1747 1748
        for(i=0;i<nb_ostreams;i++) {
            OutputFile *of = &output_files[ost_table[i].file_index];
            if (of->start_time == 0 || ist->pts >= of->start_time) {
1749
                ost = &ost_table[i];
1750
                if (ost->input_video_filter && ost->source_index == ist_index) {
1751 1752 1753
                    if (!decoded_frame->sample_aspect_ratio.num)
                        decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
                    decoded_frame->pts = ist->pts;
1754

1755
                    av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1756 1757 1758 1759 1760
                }
            }
        }
#endif

1761
        // preprocess audio (volume)
1762
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1763
            if (audio_volume != 256) {
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814
                switch (ist->st->codec->sample_fmt) {
                case AV_SAMPLE_FMT_U8:
                {
                    uint8_t *volp = samples;
                    for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
                        int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
                        *volp++ = av_clip_uint8(v);
                    }
                    break;
                }
                case AV_SAMPLE_FMT_S16:
                {
                    int16_t *volp = samples;
                    for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
                        int v = ((*volp) * audio_volume + 128) >> 8;
                        *volp++ = av_clip_int16(v);
                    }
                    break;
                }
                case AV_SAMPLE_FMT_S32:
                {
                    int32_t *volp = samples;
                    for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
                        int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
                        *volp++ = av_clipl_int32(v);
                    }
                    break;
                }
                case AV_SAMPLE_FMT_FLT:
                {
                    float *volp = samples;
                    float scale = audio_volume / 256.f;
                    for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
                        *volp++ *= scale;
                    }
                    break;
                }
                case AV_SAMPLE_FMT_DBL:
                {
                    double *volp = samples;
                    double scale = audio_volume / 256.;
                    for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
                        *volp++ *= scale;
                    }
                    break;
                }
                default:
                    av_log(NULL, AV_LOG_FATAL,
                           "Audio volume adjustment on sample format %s is not supported.\n",
                           av_get_sample_fmt_name(ist->st->codec->sample_fmt));
                    exit_program(1);
1815 1816
                }
            }
1817
        }
1818

1819
        /* frame rate emulation */
1820
        if (input_files[ist->file_index].rate_emu) {
1821
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1822 1823 1824 1825 1826 1827
            int64_t now = av_gettime() - ist->start;
            if (pts > now)
                usleep(pts - now);
        }
        /* if output time reached then transcode raw format,
           encode packets and output them */
1828
        for (i = 0; i < nb_ostreams; i++) {
Anton Khirnov's avatar
Anton Khirnov committed
1829 1830
            OutputFile *of = &output_files[ost_table[i].file_index];
            int frame_size;
1831

Anton Khirnov's avatar
Anton Khirnov committed
1832 1833 1834
            ost = &ost_table[i];
            if (ost->source_index != ist_index)
                continue;
1835

Anton Khirnov's avatar
Anton Khirnov committed
1836 1837
            if (of->start_time && ist->pts < of->start_time)
                continue;
1838

Anton Khirnov's avatar
Anton Khirnov committed
1839 1840 1841 1842 1843 1844
            if (of->recording_time != INT64_MAX &&
                av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
                              (AVRational){1, 1000000}) >= 0) {
                ost->is_past_recording_time = 1;
                continue;
            }
1845

1846
#if CONFIG_AVFILTER
Anton Khirnov's avatar
Anton Khirnov committed
1847 1848 1849 1850 1851
            frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
                !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
            while (frame_available) {
                if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
                    AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1852
                    if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
Anton Khirnov's avatar
Anton Khirnov committed
1853
                        goto cont;
1854 1855 1856 1857 1858
                    if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
                        ret = AVERROR(ENOMEM);
                        goto fail;
                    }
                    *filtered_frame= *decoded_frame; //for me_threshold
Anton Khirnov's avatar
Anton Khirnov committed
1859
                    if (ost->picref) {
1860
                        avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
Anton Khirnov's avatar
Anton Khirnov committed
1861
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1862
                    }
Anton Khirnov's avatar
Anton Khirnov committed
1863
                }
1864 1865
#else
                filtered_frame = decoded_frame;
1866
#endif
Anton Khirnov's avatar
Anton Khirnov committed
1867
                os = output_files[ost->file_index].ctx;
1868

Anton Khirnov's avatar
Anton Khirnov committed
1869 1870
                /* set the input output pts pairs */
                //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1871

Anton Khirnov's avatar
Anton Khirnov committed
1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
                if (ost->encoding_needed) {
                    av_assert0(ist->decoding_needed);
                    switch(ost->st->codec->codec_type) {
                    case AVMEDIA_TYPE_AUDIO:
                        do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
                        break;
                    case AVMEDIA_TYPE_VIDEO:
#if CONFIG_AVFILTER
                        if (ost->picref->video && !ost->frame_aspect_ratio)
                            ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
#endif
1883 1884
                        do_video_out(os, ost, ist, filtered_frame, &frame_size,
                                     same_quant ? quality : ost->st->codec->global_quality);
Anton Khirnov's avatar
Anton Khirnov committed
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
                        if (vstats_filename && frame_size)
                            do_video_stats(os, ost, frame_size);
                        break;
                    case AVMEDIA_TYPE_SUBTITLE:
                        do_subtitle_out(os, ost, ist, &subtitle,
                                        pkt->pts);
                        break;
                    default:
                        abort();
                    }
                } else {
                    AVPicture pict;
                    AVPacket opkt;
                    int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
                    av_init_packet(&opkt);

                    if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1902
#if !CONFIG_AVFILTER
Anton Khirnov's avatar
Anton Khirnov committed
1903
                        continue;
1904
#else
Anton Khirnov's avatar
Anton Khirnov committed
1905
                        goto cont;
1906
#endif
1907

Anton Khirnov's avatar
Anton Khirnov committed
1908 1909 1910 1911 1912 1913 1914 1915
                    /* no reencoding needed : output the packet directly */
                    /* force the input stream PTS */

                    if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
                        audio_size += data_size;
                    else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
                        video_size += data_size;
                        ost->sync_opts++;
1916
                    }
Anton Khirnov's avatar
Anton Khirnov committed
1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955

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

                    if (pkt->dts == AV_NOPTS_VALUE)
                        opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
                    else
                        opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
                    opkt.dts -= ost_tb_start_time;

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

                    //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
                    if(   ost->st->codec->codec_id != CODEC_ID_H264
                       && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
                       && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
                       ) {
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
                            opkt.destruct= av_destruct_packet;
                    } else {
                        opkt.data = data_buf;
                        opkt.size = data_size;
                    }

                    if (os->oformat->flags & AVFMT_RAWPICTURE) {
                        /* store AVPicture in AVPacket, as expected by the output format */
                        avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
                        opkt.data = (uint8_t *)&pict;
                        opkt.size = sizeof(AVPicture);
                        opkt.flags |= AV_PKT_FLAG_KEY;
                    }
                    write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
                    ost->st->codec->frame_number++;
                    ost->frame_number++;
                    av_free_packet(&opkt);
1956
                }
Anton Khirnov's avatar
Anton Khirnov committed
1957 1958 1959 1960 1961
#if CONFIG_AVFILTER
                cont:
                frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
                                   ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
                avfilter_unref_buffer(ost->picref);
1962
            }
1963
            av_freep(&filtered_frame);
Anton Khirnov's avatar
Anton Khirnov committed
1964 1965
#endif
        }
1966

1967
fail:
1968 1969 1970
        av_free(buffer_to_free);
        /* XXX: allocate the subtitles in the codec ? */
        if (subtitle_to_free) {
1971
            avsubtitle_free(subtitle_to_free);
1972
            subtitle_to_free = NULL;
1973
        }
1974 1975 1976
        av_freep(&decoded_frame);
        if (ret < 0)
            return ret;
1977
    }
1978
 discard_packet:
1979

1980 1981 1982
    return 0;
}

1983
static void print_sdp(OutputFile *output_files, int n)
1984 1985
{
    char sdp[2048];
1986 1987 1988 1989 1990 1991 1992
    int i;
    AVFormatContext **avc = av_malloc(sizeof(*avc)*n);

    if (!avc)
        exit_program(1);
    for (i = 0; i < n; i++)
        avc[i] = output_files[i].ctx;
1993

1994
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1995
    printf("SDP:\n%s\n", sdp);
Luca Barbato's avatar
Luca Barbato committed
1996
    fflush(stdout);
1997
    av_freep(&avc);
1998
}
1999

2000 2001 2002 2003 2004 2005 2006
static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
                             char *error, int error_len)
{
    InputStream *ist = &input_streams[ist_index];
    if (ist->decoding_needed) {
        AVCodec *codec = ist->dec;
        if (!codec) {
2007
            snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
2008 2009 2010 2011
                    avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
            return AVERROR(EINVAL);
        }
        if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2012
            snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
                    ist->file_index, ist->st->index);
            return AVERROR(EINVAL);
        }
        assert_codec_experimental(ist->st->codec, 0);
        assert_avoptions(ist->opts);
    }

    ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
    ist->next_pts = AV_NOPTS_VALUE;
    ist->is_start = 1;

    return 0;
}

2027 2028
static int transcode_init(OutputFile *output_files, int nb_output_files,
                          InputFile  *input_files,  int nb_input_files)
Fabrice Bellard's avatar
Fabrice Bellard committed
2029
{
2030
    int ret = 0, i, j, k;
2031
    AVFormatContext *os;
Fabrice Bellard's avatar
Fabrice Bellard committed
2032
    AVCodecContext *codec, *icodec;
2033
    OutputStream *ost;
2034
    InputStream *ist;
2035
    char error[1024];
2036
    int want_sdp = 1;
2037

2038 2039 2040 2041 2042 2043 2044
    /* init framerate emulation */
    for (i = 0; i < nb_input_files; i++) {
        InputFile *ifile = &input_files[i];
        if (ifile->rate_emu)
            for (j = 0; j < ifile->nb_streams; j++)
                input_streams[j + ifile->ist_index].start = av_gettime();
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
2045 2046 2047

    /* output stream init */
    for(i=0;i<nb_output_files;i++) {
2048
        os = output_files[i].ctx;
2049
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2050
            av_dump_format(os, i, os->filename, 1);
2051
            av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2052
            return AVERROR(EINVAL);
2053
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
2054 2055 2056
    }

    /* for each output stream, we compute the right encoding parameters */
2057 2058
    for (i = 0; i < nb_output_streams; i++) {
        ost = &output_streams[i];
2059
        os = output_files[ost->file_index].ctx;
2060
        ist = &input_streams[ost->source_index];
Fabrice Bellard's avatar
Fabrice Bellard committed
2061

2062 2063
        codec = ost->st->codec;
        icodec = ist->st->codec;
Fabrice Bellard's avatar
Fabrice Bellard committed
2064

2065
        ost->st->disposition = ist->st->disposition;
2066
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2067
        codec->chroma_sample_location = icodec->chroma_sample_location;
2068

2069
        if (ost->stream_copy) {
2070 2071
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;

2072
            if (extra_size > INT_MAX) {
2073
                return AVERROR(EINVAL);
2074
            }
2075

2076 2077 2078
            /* if stream_copy is selected, no need to decode or encode */
            codec->codec_id = icodec->codec_id;
            codec->codec_type = icodec->codec_type;
2079 2080 2081

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

2087
            codec->bit_rate = icodec->bit_rate;
2088 2089
            codec->rc_max_rate    = icodec->rc_max_rate;
            codec->rc_buffer_size = icodec->rc_buffer_size;
2090
            codec->extradata= av_mallocz(extra_size);
2091
            if (!codec->extradata) {
2092
                return AVERROR(ENOMEM);
2093
            }
2094
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2095
            codec->extradata_size= icodec->extradata_size;
2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112

            codec->time_base = ist->st->time_base;
            if(!strcmp(os->oformat->name, "avi")) {
                if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
                    codec->time_base = icodec->time_base;
                    codec->time_base.num *= icodec->ticks_per_frame;
                    codec->time_base.den *= 2;
                }
            } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
                if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
                    codec->time_base = icodec->time_base;
                    codec->time_base.num *= icodec->ticks_per_frame;
                }
            }
            av_reduce(&codec->time_base.num, &codec->time_base.den,
                        codec->time_base.num, codec->time_base.den, INT_MAX);

2113
            switch(codec->codec_type) {
2114
            case AVMEDIA_TYPE_AUDIO:
2115
                if(audio_volume != 256) {
2116
                    av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2117
                    exit_program(1);
2118
                }
2119
                codec->channel_layout = icodec->channel_layout;
2120 2121
                codec->sample_rate = icodec->sample_rate;
                codec->channels = icodec->channels;
2122
                codec->frame_size = icodec->frame_size;
2123
                codec->audio_service_type = icodec->audio_service_type;
2124
                codec->block_align= icodec->block_align;
2125 2126
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
                    codec->block_align= 0;
2127 2128
                if(codec->codec_id == CODEC_ID_AC3)
                    codec->block_align= 0;
2129
                break;
2130
            case AVMEDIA_TYPE_VIDEO:
2131
                codec->pix_fmt = icodec->pix_fmt;
2132 2133
                codec->width = icodec->width;
                codec->height = icodec->height;
2134
                codec->has_b_frames = icodec->has_b_frames;
2135 2136 2137 2138 2139 2140 2141
                if (!codec->sample_aspect_ratio.num) {
                    codec->sample_aspect_ratio =
                    ost->st->sample_aspect_ratio =
                        ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
                        ist->st->codec->sample_aspect_ratio.num ?
                        ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
                }
2142
                break;
2143
            case AVMEDIA_TYPE_SUBTITLE:
2144 2145
                codec->width = icodec->width;
                codec->height = icodec->height;
2146
                break;
2147
            case AVMEDIA_TYPE_DATA:
2148
            case AVMEDIA_TYPE_ATTACHMENT:
2149
                break;
2150
            default:
2151
                abort();
2152 2153
            }
        } else {
2154 2155
            if (!ost->enc)
                ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2156 2157
            ist->decoding_needed = 1;
            ost->encoding_needed = 1;
2158
            switch(codec->codec_type) {
2159
            case AVMEDIA_TYPE_AUDIO:
2160
                ost->fifo= av_fifo_alloc(1024);
2161
                if (!ost->fifo) {
2162
                    return AVERROR(ENOMEM);
2163
                }
2164
                if (!codec->sample_rate)
2165
                    codec->sample_rate = icodec->sample_rate;
2166
                choose_sample_rate(ost->st, ost->enc);
2167
                codec->time_base = (AVRational){1, codec->sample_rate};
2168 2169 2170
                if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
                    codec->sample_fmt = icodec->sample_fmt;
                choose_sample_fmt(ost->st, ost->enc);
2171
                if (!codec->channels) {
2172
                    codec->channels = icodec->channels;
2173 2174
                    codec->channel_layout = icodec->channel_layout;
                }
2175 2176
                if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
                    codec->channel_layout = 0;
2177
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
2178 2179
                ost->audio_resample |=    codec->sample_fmt     != icodec->sample_fmt
                                       || codec->channel_layout != icodec->channel_layout;
2180
                icodec->request_channels = codec->channels;
2181 2182 2183
                ost->resample_sample_fmt  = icodec->sample_fmt;
                ost->resample_sample_rate = icodec->sample_rate;
                ost->resample_channels    = icodec->channels;
2184
                break;
2185
            case AVMEDIA_TYPE_VIDEO:
2186 2187 2188 2189
                if (codec->pix_fmt == PIX_FMT_NONE)
                    codec->pix_fmt = icodec->pix_fmt;
                choose_pixel_fmt(ost->st, ost->enc);

2190
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2191
                    av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2192
                    exit_program(1);
2193
                }
2194 2195 2196 2197 2198 2199

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

2200 2201 2202
                ost->video_resample = codec->width   != icodec->width  ||
                                      codec->height  != icodec->height ||
                                      codec->pix_fmt != icodec->pix_fmt;
2203
                if (ost->video_resample) {
2204
                    codec->bits_per_raw_sample= frame_bits_per_raw_sample;
Fabrice Bellard's avatar
Fabrice Bellard committed
2205
                }
2206

2207 2208
                ost->resample_height = icodec->height;
                ost->resample_width  = icodec->width;
2209
                ost->resample_pix_fmt= icodec->pix_fmt;
2210

2211 2212
                if (!ost->frame_rate.num)
                    ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2213
                if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2214 2215
                    int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
                    ost->frame_rate = ost->enc->supported_framerates[idx];
2216 2217
                }
                codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2218 2219 2220 2221 2222
                if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
                   && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
                    av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
                                               "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
                }
2223 2224 2225 2226
                for (j = 0; j < ost->forced_kf_count; j++)
                    ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
                                                         AV_TIME_BASE_Q,
                                                         codec->time_base);
2227

2228
#if CONFIG_AVFILTER
2229
                if (configure_video_filters(ist, ost)) {
2230
                    av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2231 2232 2233
                    exit(1);
                }
#endif
2234
                break;
2235
            case AVMEDIA_TYPE_SUBTITLE:
2236
                break;
2237
            default:
2238
                abort();
2239
                break;
Fabrice Bellard's avatar
Fabrice Bellard committed
2240
            }
2241
            /* two pass mode */
2242
            if (codec->codec_id != CODEC_ID_H264 &&
2243 2244 2245
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                char logfilename[1024];
                FILE *f;
2246 2247

                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2248 2249
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
                         i);
2250
                if (codec->flags & CODEC_FLAG_PASS2) {
2251 2252 2253
                    char  *logbuffer;
                    size_t logbuffer_size;
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2254 2255
                        av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
                               logfilename);
2256
                        exit_program(1);
2257 2258
                    }
                    codec->stats_in = logbuffer;
2259
                }
2260 2261 2262 2263 2264 2265 2266 2267 2268
                if (codec->flags & CODEC_FLAG_PASS1) {
                    f = fopen(logfilename, "wb");
                    if (!f) {
                        av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
                               logfilename, strerror(errno));
                        exit_program(1);
                    }
                    ost->logfile = f;
                }
2269 2270
            }
        }
2271
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2272
            /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2273
            int size= codec->width * codec->height;
2274
            bit_buffer_size= FFMAX(bit_buffer_size, 7*size + 10000);
2275
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
2276 2277
    }

2278 2279
    if (!bit_buffer)
        bit_buffer = av_malloc(bit_buffer_size);
2280
    if (!bit_buffer) {
2281 2282
        av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
               bit_buffer_size);
2283
        return AVERROR(ENOMEM);
2284 2285
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
2286
    /* open each encoder */
2287 2288
    for (i = 0; i < nb_output_streams; i++) {
        ost = &output_streams[i];
Fabrice Bellard's avatar
Fabrice Bellard committed
2289
        if (ost->encoding_needed) {
2290
            AVCodec *codec = ost->enc;
2291
            AVCodecContext *dec = input_streams[ost->source_index].st->codec;
Fabrice Bellard's avatar
Fabrice Bellard committed
2292
            if (!codec) {
2293 2294
                snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
                         avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2295 2296
                ret = AVERROR(EINVAL);
                goto dump_format;
Fabrice Bellard's avatar
Fabrice Bellard committed
2297
            }
2298 2299 2300 2301 2302 2303 2304 2305 2306
            if (dec->subtitle_header) {
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
                if (!ost->st->codec->subtitle_header) {
                    ret = AVERROR(ENOMEM);
                    goto dump_format;
                }
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
            }
2307
            if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2308
                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
2309
                        ost->file_index, ost->index);
2310 2311
                ret = AVERROR(EINVAL);
                goto dump_format;
Fabrice Bellard's avatar
Fabrice Bellard committed
2312
            }
2313
            assert_codec_experimental(ost->st->codec, 1);
2314
            assert_avoptions(ost->opts);
2315 2316
            if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
                av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2317
                                             " It takes bits/s as argument, not kbits/s\n");
2318
            extra_size += ost->st->codec->extradata_size;
2319 2320 2321

            if (ost->st->codec->me_threshold)
                input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
Fabrice Bellard's avatar
Fabrice Bellard committed
2322 2323 2324
        }
    }

2325 2326
    /* init input streams */
    for (i = 0; i < nb_input_streams; i++)
2327
        if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2328
            goto dump_format;
2329

2330 2331 2332 2333 2334 2335 2336 2337 2338 2339
    /* discard unused programs */
    for (i = 0; i < nb_input_files; i++) {
        InputFile *ifile = &input_files[i];
        for (j = 0; j < ifile->ctx->nb_programs; j++) {
            AVProgram *p = ifile->ctx->programs[j];
            int discard  = AVDISCARD_ALL;

            for (k = 0; k < p->nb_stream_indexes; k++)
                if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
                    discard = AVDISCARD_DEFAULT;
2340 2341
                    break;
                }
2342
            p->discard = discard;
Fabrice Bellard's avatar
Fabrice Bellard committed
2343 2344 2345 2346
        }
    }

    /* open files and write file headers */
2347 2348 2349
    for (i = 0; i < nb_output_files; i++) {
        os = output_files[i].ctx;
        if (avformat_write_header(os, &output_files[i].opts) < 0) {
2350
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2351
            ret = AVERROR(EINVAL);
2352
            goto dump_format;
2353
        }
2354 2355
//        assert_avoptions(output_files[i].opts);
        if (strcmp(os->oformat->name, "rtp")) {
2356 2357 2358
            want_sdp = 0;
        }
    }
2359 2360 2361 2362 2363

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

    /* dump the stream mapping */
2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
    av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
    for (i = 0; i < nb_output_streams; i++) {
        ost = &output_streams[i];
        av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d -> #%d.%d",
               input_streams[ost->source_index].file_index,
               input_streams[ost->source_index].st->index,
               ost->file_index,
               ost->index);
        if (ost->sync_ist != &input_streams[ost->source_index])
            av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
                   ost->sync_ist->file_index,
                   ost->sync_ist->st->index);
2380
        if (ost->stream_copy)
2381 2382 2383 2384 2385 2386
            av_log(NULL, AV_LOG_INFO, " (copy)");
        else
            av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
                   input_streams[ost->source_index].dec->name : "?",
                   ost->enc ? ost->enc->name : "?");
        av_log(NULL, AV_LOG_INFO, "\n");
2387 2388 2389
    }

    if (ret) {
2390
        av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2391
        return ret;
2392 2393
    }

2394 2395
    if (want_sdp) {
        print_sdp(output_files, nb_output_files);
Fabrice Bellard's avatar
Fabrice Bellard committed
2396 2397
    }

2398 2399 2400 2401 2402 2403
    return 0;
}

/*
 * The following code is the main loop of the file converter
 */
2404 2405
static int transcode(OutputFile *output_files, int nb_output_files,
                     InputFile  *input_files,  int nb_input_files)
2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422
{
    int ret, i;
    AVFormatContext *is, *os;
    OutputStream *ost;
    InputStream *ist;
    uint8_t *no_packet;
    int no_packet_count=0;
    int64_t timer_start;
    int key;

    if (!(no_packet = av_mallocz(nb_input_files)))
        exit_program(1);

    ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
    if (ret < 0)
        goto fail;

2423
    if (!using_stdin) {
2424
        av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2425
        avio_set_interrupt_cb(decode_interrupt_cb);
2426
    }
2427

2428
    timer_start = av_gettime();
2429

2430
    for(; received_sigterm == 0;) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2431 2432
        int file_index, ist_index;
        AVPacket pkt;
2433
        int64_t ipts_min;
2434
        double opts_min;
2435
        int64_t cur_time= av_gettime();
2436

2437
        ipts_min= INT64_MAX;
2438
        opts_min= 1e100;
2439
        /* if 'q' pressed, exits */
2440
        if (!using_stdin) {
2441
            static int64_t last_time;
2442
            if (received_nb_signals)
2443
                break;
2444
            /* read_key() returns 0 on EOF */
2445 2446 2447 2448 2449
            if(cur_time - last_time >= 100000 && !run_as_daemon){
                key =  read_key();
                last_time = cur_time;
            }else
                key = -1;
2450 2451
            if (key == 'q')
                break;
2452 2453
            if (key == '+') av_log_set_level(av_log_get_level()+10);
            if (key == '-') av_log_set_level(av_log_get_level()-10);
2454 2455 2456 2457 2458 2459 2460 2461 2462 2463
            if (key == 's') qp_hist     ^= 1;
            if (key == 'h'){
                if (do_hex_dump){
                    do_hex_dump = do_pkt_dump = 0;
                } else if(do_pkt_dump){
                    do_hex_dump = 1;
                } else
                    do_pkt_dump = 1;
                av_log_set_level(AV_LOG_DEBUG);
            }
2464
#if CONFIG_AVFILTER
2465
            if (key == 'c' || key == 'C'){
2466 2467
                char buf[4096], target[64], command[256], arg[256] = {0};
                double time;
2468
                int k, n = 0;
2469
                fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2470 2471 2472 2473 2474
                i = 0;
                while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
                    if (k > 0)
                        buf[i++] = k;
                buf[i] = 0;
2475 2476 2477 2478
                if (k > 0 &&
                    (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
                    av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
                           target, time, command, arg);
2479
                    for (i = 0; i < nb_output_streams; i++) {
2480
                        ost = &output_streams[i];
2481 2482 2483 2484 2485 2486 2487
                        if (ost->graph) {
                            if (time < 0) {
                                ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
                                                                  key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
                                fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
                            } else {
                                ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2488
                            }
2489 2490
                        }
                    }
2491
                } else {
2492 2493 2494
                    av_log(NULL, AV_LOG_ERROR,
                           "Parse error, at least 3 arguments were expected, "
                           "only %d given in string '%s'\n", n, buf);
2495 2496
                }
            }
2497
#endif
2498 2499 2500
            if (key == 'd' || key == 'D'){
                int debug=0;
                if(key == 'D') {
2501
                    debug = input_streams[0].st->codec->debug<<1;
2502 2503 2504 2505 2506
                    if(!debug) debug = 1;
                    while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
                        debug += debug;
                }else
                    scanf("%d", &debug);
2507 2508
                for(i=0;i<nb_input_streams;i++) {
                    input_streams[i].st->codec->debug = debug;
2509
                }
2510 2511
                for(i=0;i<nb_output_streams;i++) {
                    ost = &output_streams[i];
2512 2513 2514 2515 2516
                    ost->st->codec->debug = debug;
                }
                if(debug) av_log_set_level(AV_LOG_DEBUG);
                fprintf(stderr,"debug=%d\n", debug);
            }
2517 2518 2519 2520 2521
            if (key == '?'){
                fprintf(stderr, "key    function\n"
                                "?      show this help\n"
                                "+      increase verbosity\n"
                                "-      decrease verbosity\n"
2522
                                "c      Send command to filtergraph\n"
2523
                                "D      cycle through available debug modes\n"
2524 2525 2526 2527 2528
                                "h      dump packets/hex press to cycle through the 3 states\n"
                                "q      quit\n"
                                "s      Show QP histogram\n"
                );
            }
2529
        }
2530

2531 2532
        /* select the stream that we must read now by looking at the
           smallest output pts */
Fabrice Bellard's avatar
Fabrice Bellard committed
2533
        file_index = -1;
2534
        for (i = 0; i < nb_output_streams; i++) {
2535
            OutputFile *of;
2536 2537
            int64_t ipts;
            double  opts;
2538
            ost = &output_streams[i];
2539
            of = &output_files[ost->file_index];
2540
            os = output_files[ost->file_index].ctx;
2541
            ist = &input_streams[ost->source_index];
2542 2543
            if (ost->is_past_recording_time || no_packet[ist->file_index] ||
                (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2544
                continue;
2545
            opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2546
            ipts = ist->pts;
2547
            if (!input_files[ist->file_index].eof_reached){
2548 2549 2550 2551 2552 2553 2554 2555
                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
2556
            }
2557 2558
            if (ost->frame_number >= ost->max_frames) {
                int j;
2559 2560
                for (j = 0; j < of->ctx->nb_streams; j++)
                    output_streams[of->ost_index + j].is_past_recording_time = 1;
2561
                continue;
2562
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
2563 2564
        }
        /* if none, if is finished */
2565
        if (file_index < 0) {
2566 2567
            if(no_packet_count){
                no_packet_count=0;
2568
                memset(no_packet, 0, nb_input_files);
2569
                usleep(10000);
2570 2571
                continue;
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
2572
            break;
2573 2574
        }

2575
        /* read a frame from it and output it in the fifo */
2576
        is = input_files[file_index].ctx;
2577
        ret= av_read_frame(is, &pkt);
2578
        if(ret == AVERROR(EAGAIN)){
2579 2580
            no_packet[file_index]=1;
            no_packet_count++;
2581
            continue;
2582
        }
2583
        if (ret < 0) {
2584
            input_files[file_index].eof_reached = 1;
Alex Beregszaszi's avatar
Alex Beregszaszi committed
2585 2586 2587 2588
            if (opt_shortest)
                break;
            else
                continue;
Fabrice Bellard's avatar
Fabrice Bellard committed
2589
        }
2590

2591
        no_packet_count=0;
2592
        memset(no_packet, 0, nb_input_files);
2593

2594
        if (do_pkt_dump) {
2595 2596
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
                             is->streams[pkt.stream_index]);
2597
        }
2598 2599
        /* the following test is needed in case new streams appear
           dynamically in stream : we ignore them */
2600
        if (pkt.stream_index >= input_files[file_index].nb_streams)
2601
            goto discard_packet;
2602 2603
        ist_index = input_files[file_index].ist_index + pkt.stream_index;
        ist = &input_streams[ist_index];
2604 2605
        if (ist->discard)
            goto discard_packet;
Fabrice Bellard's avatar
Fabrice Bellard committed
2606

2607
        if (pkt.dts != AV_NOPTS_VALUE)
2608
            pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2609
        if (pkt.pts != AV_NOPTS_VALUE)
2610
            pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2611

2612 2613 2614 2615
        if(pkt.pts != AV_NOPTS_VALUE)
            pkt.pts *= ist->ts_scale;
        if(pkt.dts != AV_NOPTS_VALUE)
            pkt.dts *= ist->ts_scale;
2616

2617
//        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2618 2619
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2620 2621
            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;
2622 2623 2624 2625
            if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
                (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
                 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
                pkt_dts+1<ist->pts)&& !copy_ts){
2626
                input_files[ist->file_index].ts_offset -= delta;
2627 2628
                av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
                       delta, input_files[ist->file_index].ts_offset);
2629 2630 2631
                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);
2632 2633 2634
            }
        }

2635
        //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2636
        if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2637

2638 2639
            av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
                   ist->file_index, ist->st->index);
2640
            if (exit_on_error)
2641
                exit_program(1);
2642
            av_free_packet(&pkt);
2643
            continue;
Michael Niedermayer's avatar
Michael Niedermayer committed
2644
        }
2645

2646
    discard_packet:
Fabrice Bellard's avatar
Fabrice Bellard committed
2647
        av_free_packet(&pkt);
2648

2649
        /* dump report by using the output first video and audio streams */
2650
        print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
Fabrice Bellard's avatar
Fabrice Bellard committed
2651
    }
2652 2653

    /* at the end of stream, we must flush the decoder buffers */
2654 2655
    for (i = 0; i < nb_input_streams; i++) {
        ist = &input_streams[i];
2656
        if (ist->decoding_needed) {
2657
            output_packet(ist, i, output_streams, nb_output_streams, NULL);
2658 2659
        }
    }
2660
    flush_encoders(output_streams, nb_output_streams);
2661

2662
    term_exit();
Fabrice Bellard's avatar
Fabrice Bellard committed
2663

2664 2665
    /* write the trailer if needed and close file */
    for(i=0;i<nb_output_files;i++) {
2666
        os = output_files[i].ctx;
2667 2668 2669
        av_write_trailer(os);
    }

2670
    /* dump report by using the first video and audio streams */
2671
    print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2672

Fabrice Bellard's avatar
Fabrice Bellard committed
2673
    /* close each encoder */
2674 2675
    for (i = 0; i < nb_output_streams; i++) {
        ost = &output_streams[i];
Fabrice Bellard's avatar
Fabrice Bellard committed
2676
        if (ost->encoding_needed) {
2677 2678
            av_freep(&ost->st->codec->stats_in);
            avcodec_close(ost->st->codec);
Fabrice Bellard's avatar
Fabrice Bellard committed
2679
        }
2680 2681 2682
#if CONFIG_AVFILTER
        avfilter_graph_free(&ost->graph);
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
2683
    }
2684

Fabrice Bellard's avatar
Fabrice Bellard committed
2685
    /* close each decoder */
2686 2687
    for (i = 0; i < nb_input_streams; i++) {
        ist = &input_streams[i];
Fabrice Bellard's avatar
Fabrice Bellard committed
2688
        if (ist->decoding_needed) {
2689
            avcodec_close(ist->st->codec);
Fabrice Bellard's avatar
Fabrice Bellard committed
2690 2691 2692 2693
        }
    }

    /* finished ! */
2694
    ret = 0;
2695

2696
 fail:
2697
    av_freep(&bit_buffer);
2698
    av_freep(&no_packet);
Fabrice Bellard's avatar
Fabrice Bellard committed
2699

2700 2701 2702
    if (output_streams) {
        for (i = 0; i < nb_output_streams; i++) {
            ost = &output_streams[i];
Fabrice Bellard's avatar
Fabrice Bellard committed
2703
            if (ost) {
2704
                if (ost->stream_copy)
2705
                    av_freep(&ost->st->codec->extradata);
2706 2707 2708 2709
                if (ost->logfile) {
                    fclose(ost->logfile);
                    ost->logfile = NULL;
                }
2710
                av_fifo_free(ost->fifo); /* works even if fifo is not
2711
                                             initialized but set to zero */
2712
                av_freep(&ost->st->codec->subtitle_header);
2713
                av_free(ost->resample_frame.data[0]);
2714
                av_free(ost->forced_kf_pts);
Fabrice Bellard's avatar
Fabrice Bellard committed
2715
                if (ost->video_resample)
2716
                    sws_freeContext(ost->img_resample_ctx);
Michael Niedermayer's avatar
Michael Niedermayer committed
2717
                swr_free(&ost->swr);
2718
                av_dict_free(&ost->opts);
Fabrice Bellard's avatar
Fabrice Bellard committed
2719 2720 2721 2722 2723 2724
            }
        }
    }
    return ret;
}

2725
static int opt_frame_crop(const char *opt, const char *arg)
2726
{
2727
    av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2728
    return AVERROR(EINVAL);
2729 2730
}

2731 2732
static int opt_pad(const char *opt, const char *arg)
{
2733
    av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2734
    return -1;
2735 2736
}

2737
static double parse_frame_aspect_ratio(const char *arg)
2738 2739 2740 2741
{
    int x = 0, y = 0;
    double ar = 0;
    const char *p;
2742
    char *end;
2743

2744 2745
    p = strchr(arg, ':');
    if (p) {
2746 2747 2748
        x = strtol(arg, &end, 10);
        if (end == p)
            y = strtol(end+1, &end, 10);
2749 2750
        if (x > 0 && y > 0)
            ar = (double)x / (double)y;
2751
    } else
2752
        ar = strtod(arg, NULL);
2753 2754

    if (!ar) {
2755
        av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2756
        exit_program(1);
2757
    }
2758
    return ar;
Fabrice Bellard's avatar
Fabrice Bellard committed
2759 2760
}

2761
static int opt_video_channel(const char *opt, const char *arg)
2762
{
2763
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2764
    return opt_default("channel", arg);
2765 2766
}

2767
static int opt_video_standard(const char *opt, const char *arg)
2768
{
2769
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2770
    return opt_default("standard", arg);
2771 2772
}

2773
static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2774
{
2775 2776
    audio_codec_name = arg;
    return parse_option(o, "codec:a", arg, options);
Fabrice Bellard's avatar
Fabrice Bellard committed
2777 2778
}

2779
static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2780
{
2781 2782
    video_codec_name = arg;
    return parse_option(o, "codec:v", arg, options);
2783 2784
}

2785
static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2786
{
2787 2788
    subtitle_codec_name = arg;
    return parse_option(o, "codec:s", arg, options);
2789 2790
}

2791
static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2792
{
2793
    return parse_option(o, "codec:d", arg, options);
2794 2795
}

2796
static int opt_map(OptionsContext *o, const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2797
{
2798 2799 2800 2801 2802
    StreamMap *m = NULL;
    int i, negative = 0, file_idx;
    int sync_file_idx = -1, sync_stream_idx;
    char *p, *sync;
    char *map;
Fabrice Bellard's avatar
Fabrice Bellard committed
2803

2804 2805 2806 2807 2808
    if (*arg == '-') {
        negative = 1;
        arg++;
    }
    map = av_strdup(arg);
Fabrice Bellard's avatar
Fabrice Bellard committed
2809

2810 2811 2812 2813 2814
    /* parse sync stream first, just pick first matching stream */
    if (sync = strchr(map, ',')) {
        *sync = 0;
        sync_file_idx = strtol(sync + 1, &sync, 0);
        if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2815
            av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2816 2817 2818 2819
            exit_program(1);
        }
        if (*sync)
            sync++;
2820
        for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2821 2822 2823 2824 2825
            if (check_stream_specifier(input_files[sync_file_idx].ctx,
                                       input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
                sync_stream_idx = i;
                break;
            }
2826
        if (i == input_files[sync_file_idx].nb_streams) {
2827
            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2828 2829 2830 2831
                                       "match any streams.\n", arg);
            exit_program(1);
        }
    }
Juanjo's avatar
Juanjo committed
2832

2833 2834 2835

    file_idx = strtol(map, &p, 0);
    if (file_idx >= nb_input_files || file_idx < 0) {
2836
        av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2837
        exit_program(1);
2838
    }
2839 2840
    if (negative)
        /* disable some already defined maps */
2841 2842
        for (i = 0; i < o->nb_stream_maps; i++) {
            m = &o->stream_maps[i];
2843 2844 2845 2846 2847 2848
            if (check_stream_specifier(input_files[m->file_index].ctx,
                                       input_files[m->file_index].ctx->streams[m->stream_index],
                                       *p == ':' ? p + 1 : p) > 0)
                m->disabled = 1;
        }
    else
2849
        for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2850 2851 2852
            if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
                        *p == ':' ? p + 1 : p) <= 0)
                continue;
2853 2854 2855
            o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
                                        &o->nb_stream_maps, o->nb_stream_maps + 1);
            m = &o->stream_maps[o->nb_stream_maps - 1];
2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869

            m->file_index   = file_idx;
            m->stream_index = i;

            if (sync_file_idx >= 0) {
                m->sync_file_index   = sync_file_idx;
                m->sync_stream_index = sync_stream_idx;
            } else {
                m->sync_file_index   = file_idx;
                m->sync_stream_index = i;
            }
        }

    if (!m) {
2870
        av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2871 2872 2873 2874
        exit_program(1);
    }

    av_freep(&map);
2875
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2876 2877
}

2878
static void parse_meta_type(char *arg, char *type, int *index)
2879
{
2880 2881
    if (*arg) {
        *type = *arg;
2882 2883 2884 2885 2886 2887
        switch (*arg) {
        case 'g':
            break;
        case 's':
        case 'c':
        case 'p':
2888 2889
            if (*(++arg) == ':')
                *index = strtol(++arg, NULL, 0);
2890 2891
            break;
        default:
2892
            av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2893
            exit_program(1);
2894 2895 2896 2897 2898
        }
    } else
        *type = 'g';
}

2899
static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2900
{
2901
    MetadataMap *m, *m1;
2902
    char *p;
2903

2904 2905
    o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
                                   &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2906

2907
    m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2908
    m->file = strtol(arg, &p, 0);
2909
    parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2910

2911
    m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2912
    if (p = strchr(opt, ':'))
2913
        parse_meta_type(p + 1, &m1->type, &m1->index);
2914 2915
    else
        m1->type = 'g';
2916

2917
    if (m->type == 'g' || m1->type == 'g')
2918
        o->metadata_global_manual = 1;
2919
    if (m->type == 's' || m1->type == 's')
2920
        o->metadata_streams_manual = 1;
2921
    if (m->type == 'c' || m1->type == 'c')
2922
        o->metadata_chapters_manual = 1;
2923 2924

    return 0;
2925 2926
}

2927
static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2928
{
2929
    av_log(NULL, AV_LOG_WARNING, "-map_meta_data is deprecated and will be removed soon. "
2930
                    "Use -map_metadata instead.\n");
2931
    return opt_map_metadata(o, opt, arg);
2932 2933
}

2934
static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2935
{
2936 2937 2938 2939
    char buf[128];
    int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
    struct tm time = *gmtime((time_t*)&recording_timestamp);
    strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2940
    parse_option(o, "metadata", buf, options);
2941 2942 2943

    av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
                                 "tag instead.\n", opt);
2944
    return 0;
2945 2946
}

2947
static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2948 2949 2950 2951 2952 2953 2954 2955
{
    const char *codec_string = encoder ? "encoder" : "decoder";
    AVCodec *codec;

    codec = encoder ?
        avcodec_find_encoder_by_name(name) :
        avcodec_find_decoder_by_name(name);
    if(!codec) {
2956
        av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2957 2958 2959
        exit_program(1);
    }
    if(codec->type != type) {
2960
        av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2961 2962
        exit_program(1);
    }
2963
    return codec;
2964 2965
}

2966
static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2967 2968 2969
{
    char *codec_name = NULL;

2970
    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2971 2972 2973 2974 2975 2976
    if (codec_name) {
        AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
        st->codec->codec_id = codec->id;
        return codec;
    } else
        return avcodec_find_decoder(st->codec->codec_id);
2977
}
2978

2979 2980 2981 2982
/**
 * Add all the streams from the given input file to the global
 * list of input streams.
 */
2983
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2984
{
2985
    int i, rfps, rfps_base;
2986
    char *next, *codec_tag = NULL;
2987 2988 2989 2990 2991

    for (i = 0; i < ic->nb_streams; i++) {
        AVStream *st = ic->streams[i];
        AVCodecContext *dec = st->codec;
        InputStream *ist;
2992
        double scale = 1.0;
2993 2994 2995 2996 2997 2998 2999 3000

        input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
        ist = &input_streams[nb_input_streams - 1];
        ist->st = st;
        ist->file_index = nb_input_files;
        ist->discard = 1;
        ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);

3001 3002
        MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
        ist->ts_scale = scale;
3003

3004 3005 3006 3007 3008 3009 3010 3011
        MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
        if (codec_tag) {
            uint32_t tag = strtol(codec_tag, &next, 0);
            if (*next)
                tag = AV_RL32(codec_tag);
            st->codec->codec_tag = tag;
        }

3012
        ist->dec = choose_decoder(o, ic, st);
3013 3014 3015 3016 3017

        switch (dec->codec_type) {
        case AVMEDIA_TYPE_AUDIO:
            if(!ist->dec)
                ist->dec = avcodec_find_decoder(dec->codec_id);
3018
            if(o->audio_disable)
3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031
                st->discard= AVDISCARD_ALL;
            break;
        case AVMEDIA_TYPE_VIDEO:
            if(!ist->dec)
                ist->dec = avcodec_find_decoder(dec->codec_id);
            rfps      = ic->streams[i]->r_frame_rate.num;
            rfps_base = ic->streams[i]->r_frame_rate.den;
            if (dec->lowres) {
                dec->flags |= CODEC_FLAG_EMU_EDGE;
            }

            if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {

3032 3033 3034
                av_log(NULL, AV_LOG_INFO,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
                       i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
                       (float)rfps / rfps_base, rfps, rfps_base);
3035 3036
            }

3037
            if (o->video_disable)
3038 3039 3040 3041 3042 3043 3044 3045 3046
                st->discard= AVDISCARD_ALL;
            else if(video_discard)
                st->discard= video_discard;
            break;
        case AVMEDIA_TYPE_DATA:
            break;
        case AVMEDIA_TYPE_SUBTITLE:
            if(!ist->dec)
                ist->dec = avcodec_find_decoder(dec->codec_id);
3047
            if(o->subtitle_disable)
3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058
                st->discard = AVDISCARD_ALL;
            break;
        case AVMEDIA_TYPE_ATTACHMENT:
        case AVMEDIA_TYPE_UNKNOWN:
            break;
        default:
            abort();
        }
    }
}

3059
static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
Fabrice Bellard's avatar
Fabrice Bellard committed
3060 3061
{
    AVFormatContext *ic;
3062
    AVInputFormat *file_iformat = NULL;
3063
    int err, i, ret;
3064
    int64_t timestamp;
3065
    uint8_t buf[128];
3066 3067
    AVDictionary **opts;
    int orig_nb_streams;                     // number of streams before avformat_find_stream_info
Fabrice Bellard's avatar
Fabrice Bellard committed
3068

3069 3070
    if (o->format) {
        if (!(file_iformat = av_find_input_format(o->format))) {
3071
            av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3072
            exit_program(1);
3073
        }
3074 3075
    }

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

3079
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3080
                    !strcmp(filename, "/dev/stdin");
3081

Fabrice Bellard's avatar
Fabrice Bellard committed
3082
    /* get default parameters from command line */
3083
    ic = avformat_alloc_context();
3084 3085
    if (!ic) {
        print_error(filename, AVERROR(ENOMEM));
3086
        exit_program(1);
3087
    }
3088 3089
    if (o->nb_audio_sample_rate) {
        snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3090 3091
        av_dict_set(&format_opts, "sample_rate", buf, 0);
    }
3092 3093
    if (o->nb_audio_channels) {
        snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3094 3095
        av_dict_set(&format_opts, "channels", buf, 0);
    }
3096 3097
    if (o->nb_frame_rates) {
        av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3098
    }
3099 3100
    if (o->nb_frame_sizes) {
        av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3101
    }
3102 3103
    if (o->nb_frame_pix_fmts)
        av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3104

3105 3106 3107 3108 3109 3110
    ic->video_codec_id   = video_codec_name ?
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
    ic->audio_codec_id   = audio_codec_name ?
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
    ic->subtitle_codec_id= subtitle_codec_name ?
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3111
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3112

Carl Eugen Hoyos's avatar
Carl Eugen Hoyos committed
3113 3114 3115 3116 3117
    if (loop_input) {
        av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
        ic->loop_input = loop_input;
    }

3118
    /* open the input file with generic libav function */
3119
    err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
Fabrice Bellard's avatar
Fabrice Bellard committed
3120
    if (err < 0) {
3121
        print_error(filename, err);
3122
        exit_program(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
3123
    }
3124 3125
    assert_avoptions(format_opts);

3126 3127
    /* apply forced codec ids */
    for (i = 0; i < ic->nb_streams; i++)
3128
        choose_decoder(o, ic, ic->streams[i]);
3129

3130
    /* Set AVCodecContext options for avformat_find_stream_info */
3131
    opts = setup_find_stream_info_opts(ic, codec_opts);
3132
    orig_nb_streams = ic->nb_streams;
3133

3134 3135
    /* If not enough info to get the stream parameters, we decode the
       first frames to get it. (used in mpeg case for example) */
3136
    ret = avformat_find_stream_info(ic, opts);
3137 3138
    if (ret < 0) {
        av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3139
        av_close_input_file(ic);
3140
        exit_program(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
3141 3142
    }

3143
    timestamp = o->start_time;
3144 3145 3146 3147
    /* add the stream start time */
    if (ic->start_time != AV_NOPTS_VALUE)
        timestamp += ic->start_time;

3148
    /* if seeking requested, we execute it */
3149
    if (o->start_time != 0) {
3150
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3151
        if (ret < 0) {
3152 3153
            av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
                   filename, (double)timestamp / AV_TIME_BASE);
3154 3155 3156
        }
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
3157
    /* update the current parameters so that they match the one of the input stream */
3158
    add_input_streams(o, ic);
3159

Fabrice Bellard's avatar
Fabrice Bellard committed
3160
    /* dump the file content */
3161
    av_dump_format(ic, nb_input_files, filename, 0);
3162

3163 3164 3165
    input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
    input_files[nb_input_files - 1].ctx        = ic;
    input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3166
    input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3167
    input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
Michael Niedermayer's avatar
Michael Niedermayer committed
3168
    input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3169

3170 3171 3172
    for (i = 0; i < orig_nb_streams; i++)
        av_dict_free(&opts[i]);
    av_freep(&opts);
3173

3174
    reset_options(o, 1);
3175
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
3176 3177
}

3178
static void parse_forced_key_frames(char *kf, OutputStream *ost)
3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193
{
    char *p;
    int n = 1, i;

    for (p = kf; *p; p++)
        if (*p == ',')
            n++;
    ost->forced_kf_count = n;
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
    if (!ost->forced_kf_pts) {
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
        exit_program(1);
    }
    for (i = 0; i < n; i++) {
        p = i ? strchr(p, ',') + 1 : kf;
3194
        ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3195 3196 3197
    }
}

3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237
static uint8_t *get_line(AVIOContext *s)
{
    AVIOContext *line;
    uint8_t *buf;
    char c;

    if (avio_open_dyn_buf(&line) < 0) {
        av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
        exit_program(1);
    }

    while ((c = avio_r8(s)) && c != '\n')
        avio_w8(line, c);
    avio_w8(line, 0);
    avio_close_dyn_buf(line, &buf);

    return buf;
}

static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
{
    int i, ret = 1;
    char filename[1000];
    const char *base[3] = { getenv("AVCONV_DATADIR"),
                            getenv("HOME"),
                            AVCONV_DATADIR,
                            };

    for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
        if (!base[i])
            continue;
        if (codec_name) {
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
                     i != 1 ? "" : "/.avconv", codec_name, preset_name);
            ret = avio_open(s, filename, AVIO_FLAG_READ);
        }
        if (ret) {
            snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
                     i != 1 ? "" : "/.avconv", preset_name);
            ret = avio_open(s, filename, AVIO_FLAG_READ);
3238 3239
        }
    }
3240
    return ret;
3241 3242
}

3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259
static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
{
    char *codec_name = NULL;

    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
    if (!codec_name) {
        ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
                                                  NULL, ost->st->codec->codec_type);
        ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
    } else if (!strcmp(codec_name, "copy"))
        ost->stream_copy = 1;
    else {
        ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
        ost->st->codec->codec_id = ost->enc->id;
    }
}

3260
static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3261 3262
{
    OutputStream *ost;
3263
    AVStream *st = avformat_new_stream(oc, NULL);
3264
    int idx      = oc->nb_streams - 1, ret = 0;
3265
    int64_t max_frames = INT64_MAX;
3266
    char *bsf = NULL, *next, *codec_tag = NULL;
3267
    AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3268
    double qscale = -1;
3269 3270
    char *buf = NULL, *arg = NULL, *preset = NULL;
    AVIOContext *s = NULL;
3271 3272

    if (!st) {
3273
        av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3274 3275 3276
        exit_program(1);
    }

3277 3278 3279
    if (oc->nb_streams - 1 < o->nb_streamid_map)
        st->id = o->streamid_map[oc->nb_streams - 1];

3280 3281 3282
    output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
                                nb_output_streams + 1);
    ost = &output_streams[nb_output_streams - 1];
3283
    ost->file_index = nb_output_files;
3284 3285 3286
    ost->index = idx;
    ost->st    = st;
    st->codec->codec_type = type;
3287
    choose_encoder(o, oc, ost);
3288 3289 3290 3291 3292 3293 3294
    if (ost->enc) {
        ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
    }

    avcodec_get_context_defaults3(st->codec, ost->enc);
    st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy

3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319
    MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
    if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
        do  {
            buf = get_line(s);
            if (!buf[0] || buf[0] == '#') {
                av_free(buf);
                continue;
            }
            if (!(arg = strchr(buf, '='))) {
                av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
                exit_program(1);
            }
            *arg++ = 0;
            av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
            av_free(buf);
        } while (!s->eof_reached);
        avio_close(s);
    }
    if (ret) {
        av_log(NULL, AV_LOG_FATAL,
               "Preset %s specified for stream %d:%d, but could not be opened.\n",
               preset, ost->file_index, ost->index);
        exit_program(1);
    }

3320 3321 3322 3323 3324 3325 3326 3327
    MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
    ost->max_frames = max_frames;

    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
    while (bsf) {
        if (next = strchr(bsf, ','))
            *next++ = 0;
        if (!(bsfc = av_bitstream_filter_init(bsf))) {
3328
            av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3329
            exit_program(1);
3330
        }
3331 3332 3333 3334 3335 3336 3337
        if (bsfc_prev)
            bsfc_prev->next = bsfc;
        else
            ost->bitstream_filters = bsfc;

        bsfc_prev = bsfc;
        bsf       = next;
3338
    }
3339

3340 3341 3342 3343 3344 3345
    MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
    if (codec_tag) {
        uint32_t tag = strtol(codec_tag, &next, 0);
        if (*next)
            tag = AV_RL32(codec_tag);
        st->codec->codec_tag = tag;
3346
    }
3347

3348 3349 3350 3351 3352
    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
    if (qscale >= 0 || same_quant) {
        st->codec->flags |= CODEC_FLAG_QSCALE;
        st->codec->global_quality = FF_QP2LAMBDA * qscale;
    }
3353

3354 3355
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
        st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3356

3357
    av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3358 3359 3360
    return ost;
}

3361 3362 3363 3364 3365 3366 3367 3368 3369 3370
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
{
    int i;
    const char *p = str;
    for(i = 0;; i++) {
        dest[i] = atoi(p);
        if(i == 63)
            break;
        p = strchr(p, ',');
        if(!p) {
3371
            av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3372 3373 3374 3375 3376
            exit_program(1);
        }
        p++;
    }
}
3377

3378
static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
Fabrice Bellard's avatar
Fabrice Bellard committed
3379 3380
{
    AVStream *st;
3381
    OutputStream *ost;
3382
    AVCodecContext *video_enc;
3383

3384
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3385
    st  = ost->st;
3386
    video_enc = st->codec;
3387

3388
    if (!ost->stream_copy) {
3389 3390 3391 3392 3393 3394 3395 3396
        const char *p = NULL;
        char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
        char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
        char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
        int i, force_fps = 0, top_field_first = -1;

        MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
        if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3397
            av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3398 3399
            exit_program(1);
        }
3400

3401 3402
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
        if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3403
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3404 3405
            exit_program(1);
        }
3406

3407 3408 3409
        MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
        if (frame_aspect_ratio)
            ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3410

3411
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3412 3413
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3414
            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3415 3416
            exit_program(1);
        }
3417
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3418

3419
        if (intra_only)
3420
            video_enc->gop_size = 0;
3421 3422 3423
        MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
        if (intra_matrix) {
            if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3424
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3425 3426 3427 3428 3429 3430 3431
                exit_program(1);
            }
            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
        }
        MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
        if (inter_matrix) {
            if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3432
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3433 3434 3435
                exit_program(1);
            }
            parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3436 3437
        }

3438
        MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3439 3440 3441 3442
        for(i=0; p; i++){
            int start, end, q;
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
            if(e!=3){
3443
                av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3444
                exit_program(1);
3445
            }
3446
            /* FIXME realloc failure */
3447 3448
            video_enc->rc_override=
                av_realloc(video_enc->rc_override,
3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463
                           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;
3464 3465
        if (!video_enc->rc_initial_buffer_occupancy)
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3466 3467 3468 3469
        video_enc->intra_dc_precision= intra_dc_precision - 8;

        /* two pass mode */
        if (do_pass) {
3470
            if (do_pass & 1) {
3471
                video_enc->flags |= CODEC_FLAG_PASS1;
3472 3473
            }
            if (do_pass & 2) {
3474 3475 3476
                video_enc->flags |= CODEC_FLAG_PASS2;
            }
        }
3477

3478
        MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3479
        if (forced_key_frames)
3480
            parse_forced_key_frames(forced_key_frames, ost);
3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492

        MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
        ost->force_fps = force_fps;

        MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
        ost->top_field_first = top_field_first;

#if CONFIG_AVFILTER
        MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
        if (filters)
            ost->avfilter = av_strdup(filters);
#endif
3493 3494
    }

3495
    return ost;
3496 3497
}

3498
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3499 3500
{
    AVStream *st;
3501
    OutputStream *ost;
3502
    AVCodecContext *audio_enc;
3503

3504
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3505
    st  = ost->st;
3506

3507
    audio_enc = st->codec;
3508
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3509

3510
    if (!ost->stream_copy) {
3511
        char *sample_fmt = NULL;
3512

3513 3514
        MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);

3515 3516 3517
        MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
        if (sample_fmt &&
            (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3518
            av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3519
            exit_program(1);
3520
        }
3521 3522

        MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3523 3524 3525

        ost->rematrix_volume=1.0;
        MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3526
    }
3527 3528

    return ost;
3529 3530
}

3531
static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3532
{
3533
    OutputStream *ost;
3534

3535
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3536
    if (!ost->stream_copy) {
3537
        av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3538
        exit_program(1);
3539 3540
    }

3541 3542
    return ost;
}
3543

3544 3545 3546
static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
{
    OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3547
    ost->stream_copy = 1;
3548
    return ost;
3549 3550
}

3551
static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3552 3553
{
    AVStream *st;
3554
    OutputStream *ost;
3555
    AVCodecContext *subtitle_enc;
3556

3557
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3558 3559
    st  = ost->st;
    subtitle_enc = st->codec;
3560

3561
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3562

3563
    return ost;
3564 3565
}

3566
/* arg format is "output-stream-index:streamid-value". */
3567
static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3568 3569 3570 3571 3572
{
    int idx;
    char *p;
    char idx_str[16];

3573
    av_strlcpy(idx_str, arg, sizeof(idx_str));
3574 3575
    p = strchr(idx_str, ':');
    if (!p) {
3576 3577 3578
        av_log(NULL, AV_LOG_FATAL,
               "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
               arg, opt);
3579
        exit_program(1);
3580 3581
    }
    *p++ = '\0';
3582
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3583 3584
    o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
    o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3585
    return 0;
3586
}
3587

3588
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3589
{
3590 3591
    AVFormatContext *is = ifile->ctx;
    AVFormatContext *os = ofile->ctx;
3592 3593 3594 3595
    int i;

    for (i = 0; i < is->nb_chapters; i++) {
        AVChapter *in_ch = is->chapters[i], *out_ch;
3596
        int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3597
                                      AV_TIME_BASE_Q, in_ch->time_base);
3598 3599
        int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
                           av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615


        if (in_ch->end < ts_off)
            continue;
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
            break;

        out_ch = av_mallocz(sizeof(AVChapter));
        if (!out_ch)
            return AVERROR(ENOMEM);

        out_ch->id        = in_ch->id;
        out_ch->time_base = in_ch->time_base;
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);

3616
        if (copy_metadata)
3617 3618 3619
            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);

        os->nb_chapters++;
3620
        os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3621 3622 3623 3624 3625 3626 3627
        if (!os->chapters)
            return AVERROR(ENOMEM);
        os->chapters[os->nb_chapters - 1] = out_ch;
    }
    return 0;
}

3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640
static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
{
    int i, err;
    AVFormatContext *ic = NULL;

    err = avformat_open_input(&ic, filename, NULL, NULL);
    if (err < 0)
        return err;
    /* copy stream format */
    for(i=0;i<ic->nb_streams;i++) {
        AVStream *st;
        OutputStream *ost;
        AVCodec *codec;
3641
        AVCodecContext *avctx;
3642 3643 3644 3645

        codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
        ost   = new_output_stream(o, s, codec->type);
        st    = ost->st;
3646
        avctx = st->codec;
3647 3648 3649 3650 3651

        // FIXME: a more elegant solution is needed
        memcpy(st, ic->streams[i], sizeof(AVStream));
        st->info = av_malloc(sizeof(*st->info));
        memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3652
        st->codec= avctx;
3653 3654
        avcodec_copy_context(st->codec, ic->streams[i]->codec);

3655
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3656
            choose_sample_fmt(st, codec);
3657
        else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3658 3659 3660 3661 3662 3663 3664
            choose_pixel_fmt(st, codec);
    }

    av_close_input_file(ic);
    return 0;
}

3665
static void opt_output_file(void *optctx, const char *filename)
3666
{
3667
    OptionsContext *o = optctx;
3668
    AVFormatContext *oc;
3669
    int i, err;
3670
    AVOutputFormat *file_oformat;
3671 3672
    OutputStream *ost;
    InputStream  *ist;
Fabrice Bellard's avatar
Fabrice Bellard committed
3673 3674 3675 3676

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

3677
    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3678
    if (!oc) {
3679
        print_error(filename, err);
3680
        exit_program(1);
3681
    }
3682
    file_oformat= oc->oformat;
Fabrice Bellard's avatar
Fabrice Bellard committed
3683

3684
    if (!strcmp(file_oformat->name, "ffm") &&
3685
        av_strstart(filename, "http:", NULL)) {
3686
        int j;
Fabrice Bellard's avatar
Fabrice Bellard committed
3687 3688
        /* special case for files sent to ffserver: we get the stream
           parameters from ffserver */
3689
        int err = read_ffserver_streams(o, oc, filename);
3690 3691
        if (err < 0) {
            print_error(filename, err);
3692
            exit_program(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
3693
        }
3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705
        for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
            ost = &output_streams[j];
            for (i = 0; i < nb_input_streams; i++) {
                ist = &input_streams[i];
                if(ist->st->codec->codec_type == ost->st->codec->codec_type){
                    ost->sync_ist= ist;
                    ost->source_index= i;
                    ist->discard = 0;
                    break;
                }
            }
        }
3706
    } else if (!o->nb_stream_maps) {
3707 3708 3709
        /* pick the "best" stream of each type */
#define NEW_STREAM(type, index)\
        if (index >= 0) {\
3710
            ost = new_ ## type ## _stream(o, oc);\
3711 3712 3713 3714 3715 3716
            ost->source_index = index;\
            ost->sync_ist     = &input_streams[index];\
            input_streams[index].discard = 0;\
        }

        /* video: highest resolution */
3717
        if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730
            int area = 0, idx = -1;
            for (i = 0; i < nb_input_streams; i++) {
                ist = &input_streams[i];
                if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
                    ist->st->codec->width * ist->st->codec->height > area) {
                    area = ist->st->codec->width * ist->st->codec->height;
                    idx = i;
                }
            }
            NEW_STREAM(video, idx);
        }

        /* audio: most channels */
3731
        if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744
            int channels = 0, idx = -1;
            for (i = 0; i < nb_input_streams; i++) {
                ist = &input_streams[i];
                if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
                    ist->st->codec->channels > channels) {
                    channels = ist->st->codec->channels;
                    idx = i;
                }
            }
            NEW_STREAM(audio, idx);
        }

        /* subtitles: pick first */
3745
        if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3746 3747 3748 3749 3750 3751 3752
            for (i = 0; i < nb_input_streams; i++)
                if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
                    NEW_STREAM(subtitle, i);
                    break;
                }
        }
        /* do something with data? */
Fabrice Bellard's avatar
Fabrice Bellard committed
3753
    } else {
3754 3755
        for (i = 0; i < o->nb_stream_maps; i++) {
            StreamMap *map = &o->stream_maps[i];
3756

3757 3758
            if (map->disabled)
                continue;
3759 3760

            ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3761 3762 3763 3764 3765 3766 3767
            if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
                continue;
            if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
                continue;
            if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
                continue;

3768
            switch (ist->st->codec->codec_type) {
3769 3770 3771 3772
            case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
            case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
            case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
            case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3773
            case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3774
            default:
3775
                av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3776 3777 3778 3779 3780 3781 3782 3783 3784
                       map->file_index, map->stream_index);
                exit_program(1);
            }

            ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
            ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
                                           map->sync_stream_index];
            ist->discard = 0;
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
3785 3786
    }

3787 3788
    output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
    output_files[nb_output_files - 1].ctx       = oc;
3789
    output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3790 3791 3792
    output_files[nb_output_files - 1].recording_time = o->recording_time;
    output_files[nb_output_files - 1].start_time     = o->start_time;
    output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3793
    av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
3794

3795
    /* check filename in case of an image number is expected */
3796
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3797
        if (!av_filename_number_test(oc->filename)) {
3798
            print_error(oc->filename, AVERROR(EINVAL));
3799
            exit_program(1);
3800
        }
3801 3802
    }

3803
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
3804
        /* test if it already exists to avoid loosing precious files */
3805
        if (!file_overwrite &&
Fabrice Bellard's avatar
Fabrice Bellard committed
3806
            (strchr(filename, ':') == NULL ||
3807
             filename[1] == ':' ||
3808
             av_strstart(filename, "file:", NULL))) {
3809
            if (avio_check(filename, 0) == 0) {
3810
                if (!using_stdin) {
3811 3812
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
                    fflush(stderr);
3813 3814 3815
                    term_exit();
                    if (!read_yesno()) {
                        av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3816
                        exit_program(1);
3817
                    }
3818
                    term_init();
3819 3820
                }
                else {
3821
                    av_log(0, AV_LOG_FATAL,"File '%s' already exists. Exiting.\n", filename);
3822
                    exit_program(1);
3823
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
3824 3825
            }
        }
3826

Fabrice Bellard's avatar
Fabrice Bellard committed
3827
        /* open the file */
3828
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3829
            print_error(filename, err);
3830
            exit_program(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
3831 3832 3833
        }
    }

3834 3835 3836 3837 3838
    if (o->mux_preload) {
        uint8_t buf[64];
        snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
        av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
    }
3839
    oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3840

3841 3842 3843 3844
    if (loop_output >= 0) {
        av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
        oc->loop_output = loop_output;
    }
3845

3846
    /* copy chapters */
3847 3848
    if (o->chapters_input_file >= nb_input_files) {
        if (o->chapters_input_file == INT_MAX) {
3849
            /* copy chapters from the first input file that has them*/
3850
            o->chapters_input_file = -1;
3851 3852
            for (i = 0; i < nb_input_files; i++)
                if (input_files[i].ctx->nb_chapters) {
3853
                    o->chapters_input_file = i;
3854 3855 3856
                    break;
                }
        } else {
3857
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3858
                   o->chapters_input_file);
3859 3860 3861
            exit_program(1);
        }
    }
3862 3863
    if (o->chapters_input_file >= 0)
        copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3864
                      !o->metadata_chapters_manual);
3865

3866
    /* copy metadata */
3867
    for (i = 0; i < o->nb_meta_data_maps; i++) {
3868 3869 3870 3871 3872 3873
        AVFormatContext *files[2];
        AVDictionary    **meta[2];
        int j;

#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
        if ((index) < 0 || (index) >= (nb_elems)) {\
3874
            av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3875 3876 3877 3878
                     (desc), (index));\
            exit_program(1);\
        }

3879
        int in_file_index = o->meta_data_maps[i][1].file;
3880 3881 3882 3883 3884 3885 3886 3887
        if (in_file_index < 0)
            continue;
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")

        files[0] = oc;
        files[1] = input_files[in_file_index].ctx;

        for (j = 0; j < 2; j++) {
3888
            MetadataMap *map = &o->meta_data_maps[i][j];
3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905

            switch (map->type) {
            case 'g':
                meta[j] = &files[j]->metadata;
                break;
            case 's':
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
                meta[j] = &files[j]->streams[map->index]->metadata;
                break;
            case 'c':
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
                meta[j] = &files[j]->chapters[map->index]->metadata;
                break;
            case 'p':
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
                meta[j] = &files[j]->programs[map->index]->metadata;
                break;
3906 3907
            default:
                abort();
3908 3909 3910 3911 3912 3913 3914
            }
        }

        av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
    }

    /* copy global metadata by default */
3915
    if (!o->metadata_global_manual && nb_input_files){
3916 3917
        av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
                     AV_DICT_DONT_OVERWRITE);
3918 3919 3920
        if(o->recording_time != INT64_MAX)
            av_dict_set(&oc->metadata, "duration", NULL, 0);
    }
3921
    if (!o->metadata_streams_manual)
3922 3923 3924
        for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
            InputStream *ist = &input_streams[output_streams[i].source_index];
            av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3925 3926
        }

3927 3928 3929 3930 3931 3932 3933 3934
    /* process manually set metadata */
    for (i = 0; i < o->nb_metadata; i++) {
        AVDictionary **m;
        char type, *val;
        int index = 0;

        val = strchr(o->metadata[i].u.str, '=');
        if (!val) {
3935
            av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947
                   o->metadata[i].u.str);
            exit_program(1);
        }
        *val++ = 0;

        parse_meta_type(o->metadata[i].specifier, &type, &index);
        switch (type) {
        case 'g':
            m = &oc->metadata;
            break;
        case 's':
            if (index < 0 || index >= oc->nb_streams) {
3948
                av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3949 3950
                exit_program(1);
            }
3951
            m = &oc->streams[index]->metadata;
3952 3953 3954
            break;
        case 'c':
            if (index < 0 || index >= oc->nb_chapters) {
3955
                av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3956 3957
                exit_program(1);
            }
3958
            m = &oc->chapters[index]->metadata;
3959 3960
            break;
        default:
3961
            av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3962 3963 3964 3965 3966
            exit_program(1);
        }

        av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
    }
3967

3968
    reset_options(o, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
3969 3970
}

3971
/* same option as mencoder */
3972
static int opt_pass(const char *opt, const char *arg)
3973
{
3974
    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
3975
    return 0;
3976
}
3977

3978
static int64_t getutime(void)
Fabrice Bellard's avatar
Fabrice Bellard committed
3979
{
3980
#if HAVE_GETRUSAGE
3981 3982 3983 3984
    struct rusage rusage;

    getrusage(RUSAGE_SELF, &rusage);
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3985
#elif HAVE_GETPROCESSTIMES
3986 3987 3988 3989 3990 3991
    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
3992
    return av_gettime();
Ramiro Polla's avatar
Ramiro Polla committed
3993
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
3994
}
Fabrice Bellard's avatar
Fabrice Bellard committed
3995

3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013
static int64_t getmaxrss(void)
{
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
    struct rusage rusage;
    getrusage(RUSAGE_SELF, &rusage);
    return (int64_t)rusage.ru_maxrss * 1024;
#elif HAVE_GETPROCESSMEMORYINFO
    HANDLE proc;
    PROCESS_MEMORY_COUNTERS memcounters;
    proc = GetCurrentProcess();
    memcounters.cb = sizeof(memcounters);
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
    return memcounters.PeakPagefileUsage;
#else
    return 0;
#endif
}

4014
static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4015
{
4016
    return parse_option(o, "q:a", arg, options);
4017 4018
}

4019
static void show_usage(void)
4020
{
4021
    printf("Hyper fast Audio and Video encoder\n");
4022
    printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4023
    printf("\n");
4024 4025
}

4026
static int opt_help(const char *opt, const char *arg)
4027
{
4028
    int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4029 4030
    av_log_set_callback(log_callback_help);
    show_usage();
4031
    show_help_options(options, "Main options:\n",
4032
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4033 4034 4035
    show_help_options(options, "\nAdvanced options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
                      OPT_EXPERT);
4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053
    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);
4054
    printf("\n");
4055 4056 4057
    show_help_children(avcodec_get_class(), flags);
    show_help_children(avformat_get_class(), flags);
    show_help_children(sws_get_class(), flags);
4058

4059
    return 0;
4060 4061
}

4062
static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4063
{
4064
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4065
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4066 4067

    if(!strncmp(arg, "pal-", 4)) {
4068
        norm = PAL;
4069 4070
        arg += 4;
    } else if(!strncmp(arg, "ntsc-", 5)) {
4071
        norm = NTSC;
4072
        arg += 5;
4073
    } else if(!strncmp(arg, "film-", 5)) {
4074
        norm = FILM;
4075
        arg += 5;
4076
    } else {
4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087
        /* Try to determine PAL/NTSC by peeking in the input files */
        if(nb_input_files) {
            int i, j, fr;
            for (j = 0; j < nb_input_files; j++) {
                for (i = 0; i < input_files[j].nb_streams; i++) {
                    AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
                    if(c->codec_type != AVMEDIA_TYPE_VIDEO)
                        continue;
                    fr = c->time_base.den * 1000 / c->time_base.num;
                    if(fr == 25000) {
                        norm = PAL;
4088
                        break;
4089 4090
                    } else if((fr == 29970) || (fr == 23976)) {
                        norm = NTSC;
4091
                        break;
4092
                    }
4093
                }
4094 4095
                if(norm != UNKNOWN)
                    break;
4096 4097
            }
        }
4098 4099
        if (norm != UNKNOWN)
            av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4100 4101
    }

4102
    if(norm == UNKNOWN) {
4103 4104 4105
        av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
        av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
        av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4106
        exit_program(1);
4107 4108 4109
    }

    if(!strcmp(arg, "vcd")) {
4110 4111
        opt_video_codec(o, "c:v", "mpeg1video");
        opt_audio_codec(o, "c:a", "mp2");
4112
        parse_option(o, "f", "vcd", options);
4113

4114 4115
        parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
        parse_option(o, "r", frame_rates[norm], options);
4116
        opt_default("g", norm == PAL ? "15" : "18");
4117

4118
        opt_default("b", "1150000");
4119 4120
        opt_default("maxrate", "1150000");
        opt_default("minrate", "1150000");
4121
        opt_default("bufsize", "327680"); // 40*1024*8;
4122

4123
        opt_default("b:a", "224000");
4124
        parse_option(o, "ar", "44100", options);
4125
        parse_option(o, "ac", "2", options);
4126

4127
        opt_default("packetsize", "2324");
4128
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4129

4130 4131 4132 4133 4134
        /* 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. */
4135
        o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4136 4137
    } else if(!strcmp(arg, "svcd")) {

4138 4139
        opt_video_codec(o, "c:v", "mpeg2video");
        opt_audio_codec(o, "c:a", "mp2");
4140
        parse_option(o, "f", "svcd", options);
4141

4142 4143 4144
        parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
        parse_option(o, "r", frame_rates[norm], options);
        parse_option(o, "pix_fmt", "yuv420p", options);
4145
        opt_default("g", norm == PAL ? "15" : "18");
4146

4147
        opt_default("b", "2040000");
4148 4149
        opt_default("maxrate", "2516000");
        opt_default("minrate", "0"); //1145000;
4150
        opt_default("bufsize", "1835008"); //224*1024*8;
4151
        opt_default("flags", "+scan_offset");
4152

4153

4154
        opt_default("b:a", "224000");
4155
        parse_option(o, "ar", "44100", options);
4156

4157
        opt_default("packetsize", "2324");
4158

4159 4160
    } else if(!strcmp(arg, "dvd")) {

4161 4162
        opt_video_codec(o, "c:v", "mpeg2video");
        opt_audio_codec(o, "c:a", "ac3");
4163
        parse_option(o, "f", "dvd", options);
4164

4165 4166 4167
        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
        parse_option(o, "r", frame_rates[norm], options);
        parse_option(o, "pix_fmt", "yuv420p", options);
4168
        opt_default("g", norm == PAL ? "15" : "18");
4169

4170
        opt_default("b", "6000000");
4171 4172
        opt_default("maxrate", "9000000");
        opt_default("minrate", "0"); //1500000;
4173
        opt_default("bufsize", "1835008"); //224*1024*8;
4174

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

4178
        opt_default("b:a", "448000");
4179
        parse_option(o, "ar", "48000", options);
4180

4181
    } else if(!strncmp(arg, "dv", 2)) {
4182

4183
        parse_option(o, "f", "dv", options);
4184

4185 4186 4187 4188
        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
        parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
                          norm == PAL ? "yuv420p" : "yuv411p", options);
        parse_option(o, "r", frame_rates[norm], options);
4189

4190
        parse_option(o, "ar", "48000", options);
4191
        parse_option(o, "ac", "2", options);
4192

4193
    } else {
4194
        av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4195
        return AVERROR(EINVAL);
4196
    }
4197
    return 0;
4198 4199
}

4200
static int opt_vstats_file(const char *opt, const char *arg)
4201 4202 4203
{
    av_free (vstats_filename);
    vstats_filename=av_strdup (arg);
4204
    return 0;
4205 4206
}

4207
static int opt_vstats(const char *opt, const char *arg)
4208 4209 4210 4211 4212 4213 4214
{
    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);
4215
    return opt_vstats_file(opt, filename);
4216 4217
}

4218
static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4219
{
4220 4221
    return parse_option(o, "frames:v", arg, options);
}
4222

4223 4224 4225 4226
static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
{
    return parse_option(o, "frames:a", arg, options);
}
4227

4228 4229 4230
static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
{
    return parse_option(o, "frames:d", arg, options);
4231 4232
}

4233
static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4234 4235 4236
{
    FILE *f=NULL;
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4237 4238 4239
    const char *codec_name = *opt == 'v' ? video_codec_name :
                             *opt == 'a' ? audio_codec_name :
                                           subtitle_codec_name;
4240 4241

    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4242
        if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4243
            av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4244
        }else
4245
            av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4246 4247 4248 4249 4250 4251 4252 4253 4254
        exit_program(1);
    }

    while(!feof(f)){
        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){
4255
            av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4256 4257 4258
            exit_program(1);
        }
        if(!strcmp(tmp, "acodec")){
4259
            opt_audio_codec(o, tmp, tmp2);
4260
        }else if(!strcmp(tmp, "vcodec")){
4261
            opt_video_codec(o, tmp, tmp2);
4262
        }else if(!strcmp(tmp, "scodec")){
4263
            opt_subtitle_codec(o, tmp, tmp2);
4264
        }else if(!strcmp(tmp, "dcodec")){
4265
            opt_data_codec(o, tmp, tmp2);
4266
        }else if(opt_default(tmp, tmp2) < 0){
4267
            av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4268 4269 4270 4271 4272 4273 4274 4275 4276
            exit_program(1);
        }
    }

    fclose(f);

    return 0;
}

4277
static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4278 4279 4280
{
}

4281
static int opt_passlogfile(const char *opt, const char *arg)
4282 4283
{
    pass_logfilename_prefix = arg;
4284
#if CONFIG_LIBX264_ENCODER
4285
    return opt_default("passlogfile", arg);
4286 4287 4288
#else
    return 0;
#endif
4289 4290
}

4291 4292
static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
{
4293 4294 4295 4296 4297
    char *s= av_malloc(strlen(opt)+2);
    snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
    return parse_option(o, s, arg, options);
}

4298 4299 4300
static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
{
    if(!strcmp(opt, "b")){
4301
        av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4302 4303 4304 4305 4306
        return parse_option(o, av_strdup("b:v"), arg, options);
    }
    return opt_default(opt, arg);
}

4307 4308 4309 4310
static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
{
    return parse_option(o, "filter:v", arg, options);
}
4311

4312
#define OFFSET(x) offsetof(OptionsContext, x)
4313
static const OptionDef options[] = {
4314
    /* main options */
4315
#include "cmdutils_common_opts.h"
4316 4317
    { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
    { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
Fabrice Bellard's avatar
Fabrice Bellard committed
4318
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4319 4320
    { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
    { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4321
    { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4322
    { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4323
    { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4324
      "outfile[,metadata]:infile[,metadata]" },
4325
    { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4326
      "outfile[,metadata]:infile[,metadata]" },
4327
    { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4328 4329 4330 4331
    { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
    { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
    { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
    { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4332 4333 4334 4335
    { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
    { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
    { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
    { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4336
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
Fabrice Bellard's avatar
Fabrice Bellard committed
4337
      "add timings for benchmarking" },
4338
    { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4339
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4340
      "dump each input packet" },
4341
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4342
      "when dumping packets, also dump the payload" },
4343
    { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4344 4345
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
    { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4346
    { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4347 4348
    { "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", "" },
4349
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4350
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4351
    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4352
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4353
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4354
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4355
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4356
    { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4357
    { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4358 4359 4360 4361 4362
    { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
#if CONFIG_AVFILTER
    { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
#endif
4363
    { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4364 4365

    /* video options */
4366
    { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4367 4368 4369 4370
    { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
    { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
    { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4371
    { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4372 4373 4374 4375 4376 4377 4378 4379 4380
    { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4381
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4382
    { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
Måns Rullgård's avatar
Måns Rullgård committed
4383
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4384
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4385
    { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4386
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4387
    { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
Lou Logan's avatar
Lou Logan committed
4388
      "use same quantizer as source (implies VBR)" },
4389
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4390
    { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4391
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4392
      "deinterlace pictures" },
4393 4394
    { "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" },
4395
#if CONFIG_AVFILTER
4396
    { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4397
#endif
4398 4399 4400
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4401
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4402
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4403
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4404 4405 4406
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
    { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
4407
    { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4408 4409

    /* audio options */
4410
    { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4411 4412
    { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
    { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4413 4414
    { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
    { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4415
    { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4416
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4417
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4418
    { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4419
    { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4420

4421
    /* subtitle options */
4422
    { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4423
    { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4424
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4425

4426
    /* grab options */
4427 4428
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4429
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4430 4431

    /* muxer options */
4432 4433
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4434

4435
    { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4436 4437
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4438

4439 4440 4441 4442
    { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
    { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
    { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
    { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4443
    /* data codec support */
4444
    { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
Michael Niedermayer's avatar
Michael Niedermayer committed
4445

4446
    { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
Fabrice Bellard's avatar
Fabrice Bellard committed
4447 4448 4449
    { NULL, },
};

4450 4451
int main(int argc, char **argv)
{
4452
    OptionsContext o = { 0 };
4453 4454
    int64_t ti;

4455
    reset_options(&o, 0);
4456

4457
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4458
    parse_loglevel(argc, argv, options);
4459

4460
    if(argc>1 && !strcmp(argv[1], "-d")){
4461
        run_as_daemon=1;
4462 4463 4464 4465 4466
        av_log_set_callback(log_callback_null);
        argc--;
        argv++;
    }

Luca Abeni's avatar
Luca Abeni committed
4467
    avcodec_register_all();
4468
#if CONFIG_AVDEVICE
Luca Abeni's avatar
Luca Abeni committed
4469
    avdevice_register_all();
4470 4471 4472
#endif
#if CONFIG_AVFILTER
    avfilter_register_all();
4473
#endif
4474 4475
    av_register_all();

Martin Storsjö's avatar
Martin Storsjö committed
4476
#if HAVE_ISATTY
4477
    if(isatty(STDIN_FILENO))
4478
        avio_set_interrupt_cb(decode_interrupt_cb);
Martin Storsjö's avatar
Martin Storsjö committed
4479
#endif
4480

4481
    show_banner();
4482

4483 4484
    term_init();

4485
    /* parse options */
4486
    parse_options(&o, argc, argv, options, opt_output_file);
4487

4488 4489
    if(nb_output_files <= 0 && nb_input_files == 0) {
        show_usage();
4490
        av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4491
        exit_program(1);
4492
    }
4493

4494 4495
    /* file converter / grab */
    if (nb_output_files <= 0) {
4496
        av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4497
        exit_program(1);
4498 4499 4500
    }

    if (nb_input_files == 0) {
4501
        av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4502
        exit_program(1);
4503 4504 4505
    }

    ti = getutime();
4506
    if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4507
        exit_program(1);
4508 4509
    ti = getutime() - ti;
    if (do_benchmark) {
4510 4511
        int maxrss = getmaxrss() / 1024;
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4512 4513
    }

4514 4515
    exit_program(0);
    return 0;
4516
}