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

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

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

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

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

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

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

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

71 72
#undef exit

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

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

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

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

#define MAX_FILES 20

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

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

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

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

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

static int intra_only = 0;
static int audio_sample_rate = 44100;
154
static int64_t channel_layout = 0;
155 156
#define QSCALE_NONE -99999
static float audio_qscale = QSCALE_NONE;
Fabrice Bellard's avatar
Fabrice Bellard committed
157 158
static int audio_disable = 0;
static int audio_channels = 1;
159
static char  *audio_codec_name = NULL;
160
static int audio_codec_tag = 0;
161 162
static char *audio_language = NULL;

163
static int subtitle_disable = 0;
164
static char *subtitle_codec_name = NULL;
165
static char *subtitle_language = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
166

167 168
static float mux_preload= 0.5;
static float mux_max_delay= 0.7;
169

170
static int64_t recording_time = INT64_MAX;
171
static int64_t start_time = 0;
172
static int64_t rec_timestamp = 0;
173
static int64_t input_ts_offset = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
174 175 176 177 178
static int file_overwrite = 0;
static char *str_title = NULL;
static char *str_author = NULL;
static char *str_copyright = NULL;
static char *str_comment = NULL;
179
static char *str_genre = NULL;
180
static char *str_album = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
181
static int do_benchmark = 0;
182
static int do_hex_dump = 0;
183
static int do_pkt_dump = 0;
184
static int do_psnr = 0;
185
static int do_pass = 0;
Stefano Sabatini's avatar
Stefano Sabatini committed
186
static char *pass_logfilename_prefix = NULL;
187 188
static int audio_stream_copy = 0;
static int video_stream_copy = 0;
189
static int subtitle_stream_copy = 0;
190
static int video_sync_method= -1;
191
static int audio_sync_method= 0;
192
static float audio_drift_threshold= 0.1;
193
static int copy_ts= 0;
194
static int opt_shortest = 0;
195
static int video_global_header = 0;
196
static char *vstats_filename;
197
static FILE *vstats_file;
198
static int opt_programid = 0;
199
static int copy_initial_nonkeyframes = 0;
200

201 202
static int rate_emu = 0;

203
static int  video_channel = 0;
204
static char *video_standard;
205

206
static int audio_volume = 256;
207

208
static int exit_on_error = 0;
209
static int using_stdin = 0;
210
static int using_vhook = 0;
211
static int verbose = 1;
212
static int thread_count= 1;
213
static int q_pressed = 0;
214 215 216
static int64_t video_size = 0;
static int64_t audio_size = 0;
static int64_t extra_size = 0;
217 218
static int nb_frames_dup = 0;
static int nb_frames_drop = 0;
219
static int input_sync;
220
static uint64_t limit_filesize = 0;
221
static int force_fps = 0;
222

223
static int pgmyuv_compatibility_hack=0;
224
static float dts_delta_threshold = 10;
225

226
static unsigned int sws_flags = SWS_BICUBIC;
227

Benoit Fouet's avatar
Benoit Fouet committed
228
static int64_t timer_start;
229

230 231
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
232
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
233
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
234

Stefano Sabatini's avatar
Stefano Sabatini committed
235
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
Fabrice Bellard's avatar
Fabrice Bellard committed
236

237 238
struct AVInputStream;

Fabrice Bellard's avatar
Fabrice Bellard committed
239 240 241 242 243
typedef struct AVOutputStream {
    int file_index;          /* file index */
    int index;               /* stream index in the output file */
    int source_index;        /* AVInputStream index */
    AVStream *st;            /* stream in the output file */
244 245 246 247
    int encoding_needed;     /* true if encoding needed for this stream */
    int frame_number;
    /* input pts and corresponding output pts
       for A/V sync */
248 249
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
    struct AVInputStream *sync_ist; /* input stream to sync against */
250
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
Fabrice Bellard's avatar
Fabrice Bellard committed
251
    /* video only */
252
    int video_resample;
253
    AVFrame pict_tmp;      /* temporary image for resampling */
254 255
    struct SwsContext *img_resample_ctx; /* for image resampling */
    int resample_height;
256

257
    int video_crop;
258 259
    int topBand;             /* cropping area sizes */
    int leftBand;
260

261
    int video_pad;
262 263 264 265
    int padtop;              /* padding area sizes */
    int padbottom;
    int padleft;
    int padright;
266

Fabrice Bellard's avatar
Fabrice Bellard committed
267 268 269
    /* audio only */
    int audio_resample;
    ReSampleContext *resample; /* for audio resampling */
270 271
    int reformat_pair;
    AVAudioConvert *reformat_ctx;
272
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
273
    FILE *logfile;
Fabrice Bellard's avatar
Fabrice Bellard committed
274 275 276 277 278 279 280 281
} AVOutputStream;

typedef struct AVInputStream {
    int file_index;
    int index;
    AVStream *st;
    int discard;             /* true if stream data should be discarded */
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
282
    int64_t sample_index;      /* current sample */
283 284

    int64_t       start;     /* time when read started */
285 286
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
                                is not defined */
287
    int64_t       pts;       /* current pts */
288
    int is_start;            /* is 1 at the start and after a discontinuity */
Fabrice Bellard's avatar
Fabrice Bellard committed
289 290 291 292 293 294
} AVInputStream;

typedef struct AVInputFile {
    int eof_reached;      /* true if eof reached */
    int ist_index;        /* index of first stream in ist_table */
    int buffer_size;      /* current total buffer size */
295
    int nb_streams;       /* nb streams we are aware of */
Fabrice Bellard's avatar
Fabrice Bellard committed
296 297
} AVInputFile;

298
#if HAVE_TERMIOS_H
Fabrice Bellard's avatar
Fabrice Bellard committed
299

Fabrice Bellard's avatar
Fabrice Bellard committed
300 301
/* init terminal so that we can grab keys */
static struct termios oldtty;
302
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
303 304 305

static void term_exit(void)
{
306
#if HAVE_TERMIOS_H
Fabrice Bellard's avatar
Fabrice Bellard committed
307
    tcsetattr (0, TCSANOW, &oldtty);
308
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
309 310
}

311 312 313 314 315 316 317 318 319
static volatile sig_atomic_t received_sigterm = 0;

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

Fabrice Bellard's avatar
Fabrice Bellard committed
320 321
static void term_init(void)
{
322
#if HAVE_TERMIOS_H
Fabrice Bellard's avatar
Fabrice Bellard committed
323 324 325 326 327 328 329 330 331 332 333 334 335
    struct termios tty;

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
337
    tcsetattr (0, TCSANOW, &tty);
338 339
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
340

341 342 343 344 345
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
    /*
    register a function to be called at normal program termination
    */
Fabrice Bellard's avatar
Fabrice Bellard committed
346
    atexit(term_exit);
347
#if CONFIG_BEOS_NETSERVER
348 349
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
350 351 352 353 354
}

/* read a key without blocking */
static int read_key(void)
{
355
#if HAVE_TERMIOS_H
356
    int n = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
357
    unsigned char ch;
358
#if !CONFIG_BEOS_NETSERVER
359
    struct timeval tv;
Fabrice Bellard's avatar
Fabrice Bellard committed
360 361 362 363 364 365 366
    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);
367
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
368
    if (n > 0) {
369 370
        n = read(0, &ch, 1);
        if (n == 1)
Fabrice Bellard's avatar
Fabrice Bellard committed
371
            return ch;
372 373

        return n;
Fabrice Bellard's avatar
Fabrice Bellard committed
374
    }
375
#elif HAVE_CONIO_H
376 377
    if(kbhit())
        return(getch());
378
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
379 380 381
    return -1;
}

382 383 384 385 386
static int decode_interrupt_cb(void)
{
    return q_pressed || (q_pressed = read_key() == 'q');
}

387
static int av_exit(int ret)
388 389 390 391 392 393 394 395
{
    int i;

    /* close files */
    for(i=0;i<nb_output_files;i++) {
        /* maybe av_close_output_file ??? */
        AVFormatContext *s = output_files[i];
        int j;
396
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
397 398
            url_fclose(s->pb);
        for(j=0;j<s->nb_streams;j++) {
399
            av_metadata_free(&s->streams[j]->metadata);
400 401 402
            av_free(s->streams[j]->codec);
            av_free(s->streams[j]);
        }
403 404 405 406 407 408 409
        for(j=0;j<s->nb_programs;j++) {
            av_metadata_free(&s->programs[j]->metadata);
        }
        for(j=0;j<s->nb_chapters;j++) {
            av_metadata_free(&s->chapters[j]->metadata);
        }
        av_metadata_free(&s->metadata);
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
        av_free(s);
    }
    for(i=0;i<nb_input_files;i++)
        av_close_input_file(input_files[i]);

    av_free(intra_matrix);
    av_free(inter_matrix);

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

    av_free(opt_names);

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

    av_free(video_standard);

430
#if CONFIG_POWERPC_PERF
431
    void powerpc_display_perf_report(void);
432 433 434 435 436 437 438 439 440 441
    powerpc_display_perf_report();
#endif /* CONFIG_POWERPC_PERF */

    if (received_sigterm) {
        fprintf(stderr,
            "Received signal %d: terminating.\n",
            (int) received_sigterm);
        exit (255);
    }

442 443
    exit(ret); /* not all OS-es handle main() return value */
    return ret;
444 445
}

446
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
Fabrice Bellard's avatar
Fabrice Bellard committed
447
{
448
    int i, err;
Fabrice Bellard's avatar
Fabrice Bellard committed
449
    AVFormatContext *ic;
450
    int nopts = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
451

452 453 454
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
    if (err < 0)
        return err;
Fabrice Bellard's avatar
Fabrice Bellard committed
455 456 457 458
    /* copy stream format */
    s->nb_streams = ic->nb_streams;
    for(i=0;i<ic->nb_streams;i++) {
        AVStream *st;
Michael Niedermayer's avatar
Michael Niedermayer committed
459

460
        // FIXME: a more elegant solution is needed
461
        st = av_mallocz(sizeof(AVStream));
Fabrice Bellard's avatar
Fabrice Bellard committed
462
        memcpy(st, ic->streams[i], sizeof(AVStream));
463 464
        st->codec = avcodec_alloc_context();
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
Fabrice Bellard's avatar
Fabrice Bellard committed
465
        s->streams[i] = st;
466 467 468 469 470 471

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

472 473 474 475 476
        if(!st->codec->thread_count)
            st->codec->thread_count = 1;
        if(st->codec->thread_count>1)
            avcodec_thread_init(st->codec, st->codec->thread_count);

477 478
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
            nopts = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
479 480
    }

481 482 483
    if (!nopts)
        s->timestamp = av_gettime();

Fabrice Bellard's avatar
Fabrice Bellard committed
484 485 486 487
    av_close_input_file(ic);
    return 0;
}

488 489 490 491
static double
get_sync_ipts(const AVOutputStream *ost)
{
    const AVInputStream *ist = ost->sync_ist;
492
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
493 494
}

495
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
496 497
    int ret;

498 499 500 501 502 503
    while(bsfc){
        AVPacket new_pkt= *pkt;
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
                                          &new_pkt.data, &new_pkt.size,
                                          pkt->data, pkt->size,
                                          pkt->flags & PKT_FLAG_KEY);
504
        if(a>0){
505 506
            av_free_packet(pkt);
            new_pkt.destruct= av_destruct_packet;
507
        } else if(a<0){
508 509 510
            fprintf(stderr, "%s failed for stream %d, codec %s",
                    bsfc->filter->name, pkt->stream_index,
                    avctx->codec ? avctx->codec->name : "copy");
511
            print_error("", a);
512 513
            if (exit_on_error)
                av_exit(1);
514 515 516 517 518 519
        }
        *pkt= new_pkt;

        bsfc= bsfc->next;
    }

520 521 522
    ret= av_interleaved_write_frame(s, pkt);
    if(ret < 0){
        print_error("av_interleaved_write_frame()", ret);
523
        av_exit(1);
524
    }
525 526
}

527
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
Fabrice Bellard's avatar
Fabrice Bellard committed
528

529 530
static void do_audio_out(AVFormatContext *s,
                         AVOutputStream *ost,
Fabrice Bellard's avatar
Fabrice Bellard committed
531 532 533
                         AVInputStream *ist,
                         unsigned char *buf, int size)
{
534
    uint8_t *buftmp;
535 536
    static uint8_t *audio_buf = NULL;
    static uint8_t *audio_out = NULL;
537
    static uint8_t *audio_out2 = NULL;
Michael Niedermayer's avatar
Michael Niedermayer committed
538
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
539

Fabrice Bellard's avatar
Fabrice Bellard committed
540
    int size_out, frame_bytes, ret;
541
    AVCodecContext *enc= ost->st->codec;
542
    AVCodecContext *dec= ist->st->codec;
543 544
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
Fabrice Bellard's avatar
Fabrice Bellard committed
545

546 547 548 549
    /* SC: dynamic allocation of buffers */
    if (!audio_buf)
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
    if (!audio_out)
Michael Niedermayer's avatar
Michael Niedermayer committed
550
        audio_out = av_malloc(audio_out_size);
551 552 553
    if (!audio_buf || !audio_out)
        return;               /* Should signal an error ! */

554 555 556 557
    if (enc->channels != dec->channels)
        ost->audio_resample = 1;

    if (ost->audio_resample && !ost->resample) {
558 559 560 561
        if (dec->sample_fmt != SAMPLE_FMT_S16) {
            fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");
            av_exit(1);
        }
562 563 564 565 566 567
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
                                            enc->sample_rate, dec->sample_rate);
        if (!ost->resample) {
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
                    dec->channels, dec->sample_rate,
                    enc->channels, enc->sample_rate);
568
            av_exit(1);
569 570 571
        }
    }

572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
    if (dec->sample_fmt!=enc->sample_fmt &&
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
        if (!audio_out2)
            audio_out2 = av_malloc(audio_out_size);
        if (!audio_out2)
            av_exit(1);
        if (ost->reformat_ctx)
            av_audio_convert_free(ost->reformat_ctx);
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
                                                   dec->sample_fmt, 1, NULL, 0);
        if (!ost->reformat_ctx) {
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
                avcodec_get_sample_fmt_name(dec->sample_fmt),
                avcodec_get_sample_fmt_name(enc->sample_fmt));
            av_exit(1);
        }
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
    }

592
    if(audio_sync_method){
593
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
594
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
595 596
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
597

598 599
        //FIXME resample delay
        if(fabs(delta) > 50){
600
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
601
                if(byte_delta < 0){
602
                    byte_delta= FFMAX(byte_delta, -size);
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
                    size += byte_delta;
                    buf  -= byte_delta;
                    if(verbose > 2)
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
                    if(!size)
                        return;
                    ist->is_start=0;
                }else{
                    static uint8_t *input_tmp= NULL;
                    input_tmp= av_realloc(input_tmp, byte_delta + size);

                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
                        ist->is_start=0;
                    else
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;

                    memset(input_tmp, 0, byte_delta);
                    memcpy(input_tmp + byte_delta, buf, size);
                    buf= input_tmp;
                    size += byte_delta;
                    if(verbose > 2)
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
                }
            }else if(audio_sync_method>1){
627
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
628 629 630
                assert(ost->audio_resample);
                if(verbose > 2)
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
631
//                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));
632 633
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
            }
634
        }
635
    }else
636
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
637
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
Fabrice Bellard's avatar
Fabrice Bellard committed
638 639 640

    if (ost->audio_resample) {
        buftmp = audio_buf;
641
        size_out = audio_resample(ost->resample,
Fabrice Bellard's avatar
Fabrice Bellard committed
642
                                  (short *)buftmp, (short *)buf,
643 644
                                  size / (ist->st->codec->channels * isize));
        size_out = size_out * enc->channels * osize;
Fabrice Bellard's avatar
Fabrice Bellard committed
645 646 647 648 649
    } else {
        buftmp = buf;
        size_out = size;
    }

650 651 652
    if (dec->sample_fmt!=enc->sample_fmt) {
        const void *ibuf[6]= {buftmp};
        void *obuf[6]= {audio_out2};
653 654
        int istride[6]= {isize};
        int ostride[6]= {osize};
655 656 657
        int len= size_out/istride[0];
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
            printf("av_audio_convert() failed\n");
658 659
            if (exit_on_error)
                av_exit(1);
660 661 662
            return;
        }
        buftmp = audio_out2;
663
        size_out = len*osize;
664 665
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
666
    /* now encode as many frames as possible */
667
    if (enc->frame_size > 1) {
Fabrice Bellard's avatar
Fabrice Bellard committed
668
        /* output resampled raw samples */
669 670 671 672
        if (av_fifo_realloc2(&ost->fifo, av_fifo_size(&ost->fifo) + size_out) < 0) {
            fprintf(stderr, "av_fifo_realloc2() failed\n");
            av_exit(1);
        }
673
        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
Fabrice Bellard's avatar
Fabrice Bellard committed
674

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

677
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
678 679 680
            AVPacket pkt;
            av_init_packet(&pkt);

681 682
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);

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

685
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
686
                                       (short *)audio_buf);
687 688 689 690
            if (ret < 0) {
                fprintf(stderr, "Audio encoding failed\n");
                av_exit(1);
            }
691
            audio_size += ret;
692 693 694
            pkt.stream_index= ost->index;
            pkt.data= audio_out;
            pkt.size= ret;
695
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
696
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
697
            pkt.flags |= PKT_FLAG_KEY;
698
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
699

700
            ost->sync_opts += enc->frame_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
701 702
        }
    } else {
703
        AVPacket pkt;
704
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
705
        av_init_packet(&pkt);
706

707
        ost->sync_opts += size_out / (osize * enc->channels);
708

709
        /* output a pcm frame */
710 711 712 713 714
        /* determine the size of the coded buffer */
        size_out /= osize;
        if (coded_bps)
            size_out *= coded_bps;

715
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
716
        ret = avcodec_encode_audio(enc, audio_out, size_out,
717
                                   (short *)buftmp);
718 719 720 721
        if (ret < 0) {
            fprintf(stderr, "Audio encoding failed\n");
            av_exit(1);
        }
722
        audio_size += ret;
723 724 725
        pkt.stream_index= ost->index;
        pkt.data= audio_out;
        pkt.size= ret;
726
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
727
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
728
        pkt.flags |= PKT_FLAG_KEY;
729
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
Fabrice Bellard's avatar
Fabrice Bellard committed
730 731 732
    }
}

733 734 735 736 737
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
{
    AVCodecContext *dec;
    AVPicture *picture2;
    AVPicture picture_tmp;
738
    uint8_t *buf = 0;
739

740
    dec = ist->st->codec;
741 742

    /* deinterlace : must be done before any resize */
743
    if (do_deinterlace || using_vhook) {
744 745 746 747 748 749 750
        int size;

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

752 753 754
        picture2 = &picture_tmp;
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);

Michael Niedermayer's avatar
Michael Niedermayer committed
755
        if (do_deinterlace){
756
            if(avpicture_deinterlace(picture2, picture,
Michael Niedermayer's avatar
Michael Niedermayer committed
757 758
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
                /* if error, do not deinterlace */
759
                fprintf(stderr, "Deinterlacing failed\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
760 761 762 763 764
                av_free(buf);
                buf = NULL;
                picture2 = picture;
            }
        } else {
765
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
766
        }
767 768 769 770
    } else {
        picture2 = picture;
    }

771
    if (CONFIG_VHOOK)
Diego Biurrun's avatar
Diego Biurrun committed
772 773
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
                           1000000 * ist->pts / AV_TIME_BASE);
774 775 776 777 778 779

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

780 781
/* we begin to correct av delay at this threshold */
#define AV_DELAY_MAX 0.100
Fabrice Bellard's avatar
Fabrice Bellard committed
782

783 784
static void do_subtitle_out(AVFormatContext *s,
                            AVOutputStream *ost,
785 786 787 788 789 790 791 792 793 794 795 796
                            AVInputStream *ist,
                            AVSubtitle *sub,
                            int64_t pts)
{
    static uint8_t *subtitle_out = NULL;
    int subtitle_out_max_size = 65536;
    int subtitle_out_size, nb, i;
    AVCodecContext *enc;
    AVPacket pkt;

    if (pts == AV_NOPTS_VALUE) {
        fprintf(stderr, "Subtitle packets must have a pts\n");
797 798
        if (exit_on_error)
            av_exit(1);
799 800 801
        return;
    }

802
    enc = ost->st->codec;
803 804 805 806 807 808 809 810 811 812 813 814 815 816

    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++) {
817
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
818
                                                    subtitle_out_max_size, sub);
819

820 821 822 823
        av_init_packet(&pkt);
        pkt.stream_index = ost->index;
        pkt.data = subtitle_out;
        pkt.size = subtitle_out_size;
824
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
825 826 827 828 829 830 831 832
        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;
        }
833
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
834 835 836
    }
}

837
static int bit_buffer_size= 1024*256;
838
static uint8_t *bit_buffer= NULL;
839

840 841
static void do_video_out(AVFormatContext *s,
                         AVOutputStream *ost,
Fabrice Bellard's avatar
Fabrice Bellard committed
842
                         AVInputStream *ist,
843
                         AVFrame *in_picture,
844
                         int *frame_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
845
{
846
    int nb_frames, i, ret;
847
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
848
    AVFrame picture_crop_temp, picture_pad_temp;
849
    AVCodecContext *enc, *dec;
850

851
    avcodec_get_frame_defaults(&picture_crop_temp);
852
    avcodec_get_frame_defaults(&picture_pad_temp);
853

854 855
    enc = ost->st->codec;
    dec = ist->st->codec;
Fabrice Bellard's avatar
Fabrice Bellard committed
856

857 858 859
    /* by default, we output a single frame */
    nb_frames = 1;

860 861
    *frame_size = 0;

862
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
863
        double vdelta;
864
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
865 866 867
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
        if (vdelta < -1.1)
            nb_frames = 0;
868 869
        else if (video_sync_method == 2)
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
870
        else if (vdelta > 1.1)
871
            nb_frames = lrintf(vdelta);
872
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
873 874 875 876
        if (nb_frames == 0){
            ++nb_frames_drop;
            if (verbose>2)
                fprintf(stderr, "*** drop!\n");
877 878
        }else if (nb_frames > 1) {
            nb_frames_dup += nb_frames;
879
            if (verbose>2)
880
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
881 882
        }
    }else
883
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
884

885
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
886
    if (nb_frames <= 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
887
        return;
888

889
    if (ost->video_crop) {
890
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
891
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
892 893
            if (exit_on_error)
                av_exit(1);
894
            return;
895 896
        }
        formatted_picture = &picture_crop_temp;
897 898
    } else {
        formatted_picture = in_picture;
899 900 901 902 903 904 905 906
    }

    final_picture = formatted_picture;
    padding_src = formatted_picture;
    resampling_dst = &ost->pict_tmp;
    if (ost->video_pad) {
        final_picture = &ost->pict_tmp;
        if (ost->video_resample) {
907
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
908
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
909 910
                if (exit_on_error)
                    av_exit(1);
911
                return;
912 913 914 915 916
            }
            resampling_dst = &picture_pad_temp;
        }
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
917
    if (ost->video_resample) {
918
        padding_src = NULL;
919
        final_picture = &ost->pict_tmp;
920 921
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
922
    }
923 924

    if (ost->video_pad) {
925
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
926 927
                enc->height, enc->width, enc->pix_fmt,
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
Fabrice Bellard's avatar
Fabrice Bellard committed
928
    }
929

Fabrice Bellard's avatar
Fabrice Bellard committed
930
    /* duplicates frame if needed */
931
    for(i=0;i<nb_frames;i++) {
932 933 934 935
        AVPacket pkt;
        av_init_packet(&pkt);
        pkt.stream_index= ost->index;

936 937 938 939
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
            /* raw pictures are written as AVPicture structure to
               avoid any copies. We support temorarily the older
               method. */
940
            AVFrame* old_frame = enc->coded_frame;
941
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
942 943
            pkt.data= (uint8_t *)final_picture;
            pkt.size=  sizeof(AVPicture);
944 945
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
            pkt.flags |= PKT_FLAG_KEY;
946

947
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
948
            enc->coded_frame = old_frame;
949
        } else {
950
            AVFrame big_picture;
951 952

            big_picture= *final_picture;
953 954 955
            /* better than nothing: use input picture interlaced
               settings */
            big_picture.interlaced_frame = in_picture->interlaced_frame;
956
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
957 958 959
                if(top_field_first == -1)
                    big_picture.top_field_first = in_picture->top_field_first;
                else
Michael Niedermayer's avatar
Michael Niedermayer committed
960
                    big_picture.top_field_first = top_field_first;
961
            }
962

Fabrice Bellard's avatar
Fabrice Bellard committed
963 964 965
            /* handles sameq here. This is not correct because it may
               not be a global option */
            if (same_quality) {
Michael Niedermayer's avatar
Michael Niedermayer committed
966 967 968
                big_picture.quality = ist->st->quality;
            }else
                big_picture.quality = ost->st->quality;
969 970
            if(!me_threshold)
                big_picture.pict_type = 0;
971
//            big_picture.pts = AV_NOPTS_VALUE;
972 973
            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);
974
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
975
            ret = avcodec_encode_video(enc,
976
                                       bit_buffer, bit_buffer_size,
Michael Niedermayer's avatar
Michael Niedermayer committed
977
                                       &big_picture);
978
            if (ret < 0) {
979
                fprintf(stderr, "Video encoding failed\n");
980
                av_exit(1);
981
            }
982
            //enc->frame_number = enc->real_pict_num;
983
            if(ret>0){
984
                pkt.data= bit_buffer;
985
                pkt.size= ret;
986
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
987
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
988
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
989 990
   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);*/
991

992
                if(enc->coded_frame->key_frame)
993
                    pkt.flags |= PKT_FLAG_KEY;
994
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
995
                *frame_size = ret;
996
                video_size += ret;
997 998 999 1000 1001 1002 1003
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
                //        enc->frame_number-1, enc->real_pict_num, ret,
                //        enc->pict_type);
                /* if two pass, output log */
                if (ost->logfile && enc->stats_out) {
                    fprintf(ost->logfile, "%s", enc->stats_out);
                }
1004
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
1005
        }
1006
        ost->sync_opts++;
1007
        ost->frame_number++;
Fabrice Bellard's avatar
Fabrice Bellard committed
1008 1009 1010
    }
}

1011
static double psnr(double d){
1012
    return -10.0*log(d)/log(10.0);
1013 1014
}

1015
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1016
                           int frame_size)
1017 1018 1019 1020
{
    AVCodecContext *enc;
    int frame_number;
    double ti1, bitrate, avg_bitrate;
1021

1022
    /* this is executed just the first time do_video_stats is called */
1023 1024 1025
    if (!vstats_file) {
        vstats_file = fopen(vstats_filename, "w");
        if (!vstats_file) {
1026
            perror("fopen");
1027
            av_exit(1);
1028 1029 1030
        }
    }

1031
    enc = ost->st->codec;
1032
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1033
        frame_number = ost->frame_number;
1034
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1035
        if (enc->flags&CODEC_FLAG_PSNR)
1036
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1037

1038
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1039
        /* compute pts value */
1040
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1041 1042
        if (ti1 < 0.01)
            ti1 = 0.01;
1043

1044
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1045
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1046
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1047
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1048
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1049
    }
1050 1051
}

1052
static void print_report(AVFormatContext **output_files,
1053 1054
                         AVOutputStream **ost_table, int nb_ostreams,
                         int is_last_report)
1055 1056 1057 1058
{
    char buf[1024];
    AVOutputStream *ost;
    AVFormatContext *oc, *os;
1059
    int64_t total_size;
1060 1061 1062
    AVCodecContext *enc;
    int frame_number, vid, i;
    double bitrate, ti1, pts;
1063
    static int64_t last_time = -1;
1064
    static int qp_histogram[52];
1065

1066
    if (!is_last_report) {
1067
        int64_t cur_time;
1068 1069 1070 1071 1072
        /* display the report every 0.5 seconds */
        cur_time = av_gettime();
        if (last_time == -1) {
            last_time = cur_time;
            return;
1073
        }
1074 1075 1076 1077 1078
        if ((cur_time - last_time) < 500000)
            return;
        last_time = cur_time;
    }

1079

1080 1081
    oc = output_files[0];

1082
    total_size = url_fsize(oc->pb);
1083
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1084
        total_size= url_ftell(oc->pb);
1085

1086 1087 1088 1089 1090 1091
    buf[0] = '\0';
    ti1 = 1e10;
    vid = 0;
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        os = output_files[ost->file_index];
1092
        enc = ost->st->codec;
1093
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1094
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1095
                     !ost->st->stream_copy ?
1096
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1097
        }
1098
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1099 1100
            float t = (av_gettime()-timer_start) / 1000000.0;

1101
            frame_number = ost->frame_number;
1102 1103
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1104
                     !ost->st->stream_copy ?
1105
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1106
            if(is_last_report)
1107
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1108
            if(qp_hist){
1109 1110
                int j;
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1111
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1112 1113 1114 1115
                    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)));
            }
1116 1117 1118 1119 1120
            if (enc->flags&CODEC_FLAG_PSNR){
                int j;
                double error, error_sum=0;
                double scale, scale_sum=0;
                char type[3]= {'Y','U','V'};
1121
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
                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;
1133
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1134
                }
1135
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1136
            }
1137 1138 1139
            vid = 1;
        }
        /* compute min output value */
1140
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1141
        if ((pts < ti1) && (pts > 0))
1142 1143 1144 1145
            ti1 = pts;
    }
    if (ti1 < 0.01)
        ti1 = 0.01;
1146

1147 1148
    if (verbose || is_last_report) {
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1149 1150

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

1154 1155 1156
        if (verbose > 1)
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
                  nb_frames_dup, nb_frames_drop);
1157

1158 1159 1160
        if (verbose >= 0)
            fprintf(stderr, "%s    \r", buf);

1161 1162
        fflush(stderr);
    }
1163

1164 1165
    if (is_last_report && verbose >= 0){
        int64_t raw= audio_size + video_size + extra_size;
1166
        fprintf(stderr, "\n");
1167 1168 1169 1170 1171 1172 1173
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
                video_size/1024.0,
                audio_size/1024.0,
                extra_size/1024.0,
                100.0*(total_size - raw)/raw
        );
    }
1174 1175
}

1176 1177 1178
/* pkt = NULL means EOF (needed to flush decoder buffers) */
static int output_packet(AVInputStream *ist, int ist_index,
                         AVOutputStream **ost_table, int nb_ostreams,
1179
                         const AVPacket *pkt)
1180 1181 1182 1183 1184 1185 1186 1187 1188
{
    AVFormatContext *os;
    AVOutputStream *ost;
    uint8_t *ptr;
    int len, ret, i;
    uint8_t *data_buf;
    int data_size, got_picture;
    AVFrame picture;
    void *buffer_to_free;
1189
    static unsigned int samples_size= 0;
1190
    static short *samples= NULL;
1191 1192
    AVSubtitle subtitle, *subtitle_to_free;
    int got_subtitle;
1193

1194 1195 1196
    if(ist->next_pts == AV_NOPTS_VALUE)
        ist->next_pts= ist->pts;

1197 1198 1199 1200 1201 1202 1203
    if (pkt == NULL) {
        /* EOF handling */
        ptr = NULL;
        len = 0;
        goto handle_eof;
    }

1204 1205 1206
    if(pkt->dts != AV_NOPTS_VALUE)
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);

1207 1208
    len = pkt->size;
    ptr = pkt->data;
1209 1210 1211

    //while we have more to decode or while the decoder did output something on EOF
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1212
    handle_eof:
1213
        ist->pts= ist->next_pts;
1214

1215 1216 1217
        if(len && len != pkt->size && verbose>0)
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);

1218 1219 1220
        /* decode the packet if needed */
        data_buf = NULL; /* fail safe */
        data_size = 0;
1221
        subtitle_to_free = NULL;
1222
        if (ist->decoding_needed) {
1223
            switch(ist->st->codec->codec_type) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1224
            case CODEC_TYPE_AUDIO:{
1225 1226 1227 1228 1229
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
                    av_free(samples);
                    samples= av_malloc(samples_size);
                }
1230
                data_size= samples_size;
1231 1232
                    /* XXX: could avoid copy if PCM 16 bits with same
                       endianness as CPU */
1233
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
                                           ptr, len);
                if (ret < 0)
                    goto fail_decode;
                ptr += ret;
                len -= ret;
                /* Some bug in mpeg audio decoder gives */
                /* data_size < 0, it seems they are overflows */
                if (data_size <= 0) {
                    /* no audio frame */
                    continue;
                }
                data_buf = (uint8_t *)samples;
1246
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1247
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
Michael Niedermayer's avatar
Michael Niedermayer committed
1248
                break;}
1249
            case CODEC_TYPE_VIDEO:
1250
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1251
                    /* XXX: allocate picture correctly */
1252 1253
                    avcodec_get_frame_defaults(&picture);

1254
                    ret = avcodec_decode_video(ist->st->codec,
1255 1256
                                               &picture, &got_picture, ptr, len);
                    ist->st->quality= picture.quality;
1257
                    if (ret < 0)
1258 1259 1260 1261 1262
                        goto fail_decode;
                    if (!got_picture) {
                        /* no picture yet */
                        goto discard_packet;
                    }
1263
                    if (ist->st->codec->time_base.num != 0) {
1264
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1265 1266
                                          ist->st->codec->time_base.num) /
                            ist->st->codec->time_base.den;
1267 1268 1269
                    }
                    len = 0;
                    break;
1270
            case CODEC_TYPE_SUBTITLE:
1271
                ret = avcodec_decode_subtitle(ist->st->codec,
1272 1273
                                              &subtitle, &got_subtitle, ptr, len);
                if (ret < 0)
1274
                    goto fail_decode;
1275 1276
                if (!got_subtitle) {
                    goto discard_packet;
1277
                }
1278 1279 1280 1281 1282 1283 1284
                subtitle_to_free = &subtitle;
                len = 0;
                break;
            default:
                goto fail_decode;
            }
        } else {
1285 1286 1287
            switch(ist->st->codec->codec_type) {
            case CODEC_TYPE_AUDIO:
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1288
                    ist->st->codec->sample_rate;
1289 1290 1291 1292 1293 1294
                break;
            case CODEC_TYPE_VIDEO:
                if (ist->st->codec->time_base.num != 0) {
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
                                      ist->st->codec->time_base.num) /
                        ist->st->codec->time_base.den;
1295
                }
1296
                break;
1297
            }
1298 1299 1300 1301 1302
            data_buf = ptr;
            data_size = len;
            ret = len;
            len = 0;
        }
1303

1304 1305 1306 1307 1308
        buffer_to_free = NULL;
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
            pre_process_video_frame(ist, (AVPicture *)&picture,
                                    &buffer_to_free);
        }
1309

1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
        // preprocess audio (volume)
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
            if (audio_volume != 256) {
                short *volp;
                volp = samples;
                for(i=0;i<(data_size / sizeof(short));i++) {
                    int v = ((*volp) * audio_volume + 128) >> 8;
                    if (v < -32768) v = -32768;
                    if (v >  32767) v = 32767;
                    *volp++ = v;
1320 1321
                }
            }
1322
        }
1323

1324
        /* frame rate emulation */
1325
        if (rate_emu) {
1326
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1327 1328 1329 1330
            int64_t now = av_gettime() - ist->start;
            if (pts > now)
                usleep(pts - now);
        }
1331

1332 1333 1334 1335 1336
        /* if output time reached then transcode raw format,
           encode packets and output them */
        if (start_time == 0 || ist->pts >= start_time)
            for(i=0;i<nb_ostreams;i++) {
                int frame_size;
1337

1338 1339 1340
                ost = ost_table[i];
                if (ost->source_index == ist_index) {
                    os = output_files[ost->file_index];
1341 1342

#if 0
1343 1344 1345 1346
                    printf("%d: got pts=%0.3f %0.3f\n", i,
                           (double)pkt->pts / AV_TIME_BASE,
                           ((double)ist->pts / AV_TIME_BASE) -
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1347
#endif
1348 1349 1350 1351 1352 1353 1354 1355 1356 1357
                    /* set the input output pts pairs */
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;

                    if (ost->encoding_needed) {
                        switch(ost->st->codec->codec_type) {
                        case CODEC_TYPE_AUDIO:
                            do_audio_out(os, ost, ist, data_buf, data_size);
                            break;
                        case CODEC_TYPE_VIDEO:
                            do_video_out(os, ost, ist, &picture, &frame_size);
1358
                            if (vstats_filename && frame_size)
1359 1360 1361 1362 1363 1364 1365
                                do_video_stats(os, ost, frame_size);
                            break;
                        case CODEC_TYPE_SUBTITLE:
                            do_subtitle_out(os, ost, ist, &subtitle,
                                            pkt->pts);
                            break;
                        default:
1366
                            abort();
1367 1368 1369 1370 1371 1372
                        }
                    } else {
                        AVFrame avframe; //FIXME/XXX remove this
                        AVPacket opkt;
                        av_init_packet(&opkt);

1373
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1374 1375
                            continue;

1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
                        /* no reencoding needed : output the packet directly */
                        /* force the input stream PTS */

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

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

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

Baptiste Coudurier's avatar
Baptiste Coudurier committed
1396
                        if (pkt->dts == AV_NOPTS_VALUE)
1397
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1398 1399
                        else
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1400

1401
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1402 1403 1404 1405 1406 1407
                        opkt.flags= pkt->flags;

                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
                            opkt.destruct= av_destruct_packet;

1408
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1409 1410 1411
                        ost->st->codec->frame_number++;
                        ost->frame_number++;
                        av_free_packet(&opkt);
1412 1413
                    }
                }
1414 1415 1416 1417 1418 1419
            }
        av_free(buffer_to_free);
        /* XXX: allocate the subtitles in the codec ? */
        if (subtitle_to_free) {
            if (subtitle_to_free->rects != NULL) {
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1420 1421
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1422
                    av_freep(&subtitle_to_free->rects[i]);
1423
                }
1424
                av_freep(&subtitle_to_free->rects);
1425
            }
1426 1427
            subtitle_to_free->num_rects = 0;
            subtitle_to_free = NULL;
1428
        }
1429
    }
1430
 discard_packet:
1431 1432
    if (pkt == NULL) {
        /* EOF handling */
1433

1434 1435 1436
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            if (ost->source_index == ist_index) {
1437
                AVCodecContext *enc= ost->st->codec;
1438
                os = output_files[ost->file_index];
1439

1440
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1441
                    continue;
1442
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1443 1444 1445 1446 1447
                    continue;

                if (ost->encoding_needed) {
                    for(;;) {
                        AVPacket pkt;
1448
                        int fifo_bytes;
1449 1450
                        av_init_packet(&pkt);
                        pkt.stream_index= ost->index;
1451

1452
                        switch(ost->st->codec->codec_type) {
1453
                        case CODEC_TYPE_AUDIO:
1454
                            fifo_bytes = av_fifo_size(&ost->fifo);
1455 1456 1457 1458 1459
                            ret = 0;
                            /* encode any samples remaining in fifo */
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
                                int fs_tmp = enc->frame_size;
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1460
                                av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1461 1462
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
                                enc->frame_size = fs_tmp;
Michael Niedermayer's avatar
Michael Niedermayer committed
1463 1464
                            }
                            if(ret <= 0) {
1465 1466
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
                            }
1467 1468 1469 1470
                            if (ret < 0) {
                                fprintf(stderr, "Audio encoding failed\n");
                                av_exit(1);
                            }
1471 1472 1473 1474
                            audio_size += ret;
                            pkt.flags |= PKT_FLAG_KEY;
                            break;
                        case CODEC_TYPE_VIDEO:
1475
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1476 1477 1478 1479
                            if (ret < 0) {
                                fprintf(stderr, "Video encoding failed\n");
                                av_exit(1);
                            }
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489
                            video_size += ret;
                            if(enc->coded_frame && enc->coded_frame->key_frame)
                                pkt.flags |= PKT_FLAG_KEY;
                            if (ost->logfile && enc->stats_out) {
                                fprintf(ost->logfile, "%s", enc->stats_out);
                            }
                            break;
                        default:
                            ret=-1;
                        }
1490

1491 1492
                        if(ret<=0)
                            break;
1493
                        pkt.data= bit_buffer;
1494
                        pkt.size= ret;
1495
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1496
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1497
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1498 1499 1500 1501 1502
                    }
                }
            }
        }
    }
1503

1504 1505 1506 1507 1508
    return 0;
 fail_decode:
    return -1;
}

1509 1510 1511 1512 1513 1514
static void print_sdp(AVFormatContext **avc, int n)
{
    char sdp[2048];

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

1518 1519 1520 1521 1522 1523 1524
static int stream_index_from_inputs(AVFormatContext **input_files,
                                    int nb_input_files,
                                    AVInputFile *file_table,
                                    AVInputStream **ist_table,
                                    enum CodecType type,
                                    int programid)
{
1525
    int p, q, z;
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
    for(z=0; z<nb_input_files; z++) {
        AVFormatContext *ic = input_files[z];
        for(p=0; p<ic->nb_programs; p++) {
            AVProgram *program = ic->programs[p];
            if(program->id != programid)
                continue;
            for(q=0; q<program->nb_stream_indexes; q++) {
                int sidx = program->stream_index[q];
                int ris = file_table[z].ist_index + sidx;
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
                    return ris;
            }
        }
    }

    return -1;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
1544 1545 1546 1547 1548 1549 1550 1551 1552
/*
 * The following code is the main loop of the file converter
 */
static int av_encode(AVFormatContext **output_files,
                     int nb_output_files,
                     AVFormatContext **input_files,
                     int nb_input_files,
                     AVStreamMap *stream_maps, int nb_stream_maps)
{
1553
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1554 1555 1556 1557
    AVFormatContext *is, *os;
    AVCodecContext *codec, *icodec;
    AVOutputStream *ost, **ost_table = NULL;
    AVInputStream *ist, **ist_table = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
1558
    AVInputFile *file_table;
1559
    int key;
1560
    int want_sdp = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1561

1562
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
Fabrice Bellard's avatar
Fabrice Bellard committed
1563 1564
    if (!file_table)
        goto fail;
1565

Fabrice Bellard's avatar
Fabrice Bellard committed
1566 1567 1568 1569 1570
    /* input stream init */
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        file_table[i].ist_index = j;
1571
        file_table[i].nb_streams = is->nb_streams;
Fabrice Bellard's avatar
Fabrice Bellard committed
1572 1573 1574 1575 1576 1577
        j += is->nb_streams;
    }
    nb_istreams = j;

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
    for(i=0;i<nb_istreams;i++) {
        ist = av_mallocz(sizeof(AVInputStream));
        if (!ist)
            goto fail;
        ist_table[i] = ist;
    }
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        for(k=0;k<is->nb_streams;k++) {
            ist = ist_table[j++];
            ist->st = is->streams[k];
            ist->file_index = i;
            ist->index = k;
            ist->discard = 1; /* the stream is discarded by default
                                 (changed later) */
1596

1597
            if (rate_emu) {
1598 1599
                ist->start = av_gettime();
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
1600 1601 1602 1603 1604 1605 1606
        }
    }

    /* output stream init */
    nb_ostreams = 0;
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
1607
        if (!os->nb_streams) {
1608 1609
            dump_format(output_files[i], i, output_files[i]->filename, 1);
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1610
            av_exit(1);
1611
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1612 1613 1614 1615
        nb_ostreams += os->nb_streams;
    }
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1616
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1617 1618
    }

1619 1620 1621 1622
    /* Sanity check the mapping args -- do the input files & streams exist? */
    for(i=0;i<nb_stream_maps;i++) {
        int fi = stream_maps[i].file_index;
        int si = stream_maps[i].stream_index;
1623

1624 1625 1626
        if (fi < 0 || fi > nb_input_files - 1 ||
            si < 0 || si > file_table[fi].nb_streams - 1) {
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1627
            av_exit(1);
1628
        }
1629 1630 1631 1632 1633
        fi = stream_maps[i].sync_file_index;
        si = stream_maps[i].sync_stream_index;
        if (fi < 0 || fi > nb_input_files - 1 ||
            si < 0 || si > file_table[fi].nb_streams - 1) {
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1634
            av_exit(1);
1635
        }
1636
    }
1637

Fabrice Bellard's avatar
Fabrice Bellard committed
1638 1639 1640 1641 1642 1643 1644 1645 1646
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
    if (!ost_table)
        goto fail;
    for(i=0;i<nb_ostreams;i++) {
        ost = av_mallocz(sizeof(AVOutputStream));
        if (!ost)
            goto fail;
        ost_table[i] = ost;
    }
1647

Fabrice Bellard's avatar
Fabrice Bellard committed
1648 1649 1650
    n = 0;
    for(k=0;k<nb_output_files;k++) {
        os = output_files[k];
1651
        for(i=0;i<os->nb_streams;i++,n++) {
Fabrice Bellard's avatar
Fabrice Bellard committed
1652
            int found;
1653
            ost = ost_table[n];
Fabrice Bellard's avatar
Fabrice Bellard committed
1654 1655 1656 1657
            ost->file_index = k;
            ost->index = i;
            ost->st = os->streams[i];
            if (nb_stream_maps > 0) {
1658 1659
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
                    stream_maps[n].stream_index;
1660

1661
                /* Sanity check that the stream types match */
1662
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1663 1664
                    int i= ost->file_index;
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1665
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1666
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1667
                        ost->file_index, ost->index);
1668
                    av_exit(1);
1669
                }
1670

Fabrice Bellard's avatar
Fabrice Bellard committed
1671
            } else {
1672 1673 1674 1675 1676 1677 1678 1679
                if(opt_programid) {
                    found = 0;
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
                    if(j != -1) {
                        ost->source_index = j;
                        found = 1;
                    }
                } else {
1680 1681
                    /* get corresponding input stream index : we select the first one with the right type */
                    found = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1682 1683
                    for(j=0;j<nb_istreams;j++) {
                        ist = ist_table[j];
1684 1685
                        if (ist->discard &&
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
Fabrice Bellard's avatar
Fabrice Bellard committed
1686 1687
                            ost->source_index = j;
                            found = 1;
1688
                            break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1689 1690
                        }
                    }
1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702
                }

                if (!found) {
                    if(! opt_programid) {
                        /* try again and reuse existing stream */
                        for(j=0;j<nb_istreams;j++) {
                            ist = ist_table[j];
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
                                ost->source_index = j;
                                found = 1;
                            }
                        }
1703
                    }
Fabrice Bellard's avatar
Fabrice Bellard committed
1704
                    if (!found) {
1705 1706
                        int i= ost->file_index;
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1707 1708
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
                                ost->file_index, ost->index);
1709
                        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1710 1711 1712 1713 1714
                    }
                }
            }
            ist = ist_table[ost->source_index];
            ist->discard = 0;
1715
            ost->sync_ist = (nb_stream_maps > 0) ?
1716 1717
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
                         stream_maps[n].sync_stream_index] : ist;
Fabrice Bellard's avatar
Fabrice Bellard committed
1718 1719 1720 1721 1722 1723
        }
    }

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

1727 1728
        codec = ost->st->codec;
        icodec = ist->st->codec;
Fabrice Bellard's avatar
Fabrice Bellard committed
1729

1730 1731 1732 1733
        if (!ost->st->language[0])
            av_strlcpy(ost->st->language, ist->st->language,
                       sizeof(ost->st->language));

1734 1735
        ost->st->disposition = ist->st->disposition;

1736 1737 1738 1739
        if (ost->st->stream_copy) {
            /* if stream_copy is selected, no need to decode or encode */
            codec->codec_id = icodec->codec_id;
            codec->codec_type = icodec->codec_type;
1740 1741 1742 1743 1744 1745 1746 1747

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

1748
            codec->bit_rate = icodec->bit_rate;
1749 1750
            codec->extradata= icodec->extradata;
            codec->extradata_size= icodec->extradata_size;
1751
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1752 1753 1754
                codec->time_base = icodec->time_base;
            else
                codec->time_base = ist->st->time_base;
1755 1756
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
1757 1758 1759 1760
                if(audio_volume != 256) {
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
                    av_exit(1);
                }
1761
                codec->channel_layout = icodec->channel_layout;
1762 1763
                codec->sample_rate = icodec->sample_rate;
                codec->channels = icodec->channels;
1764
                codec->frame_size = icodec->frame_size;
1765
                codec->block_align= icodec->block_align;
1766 1767
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
                    codec->block_align= 0;
1768 1769
                if(codec->codec_id == CODEC_ID_AC3)
                    codec->block_align= 0;
1770 1771
                break;
            case CODEC_TYPE_VIDEO:
1772 1773
                if(using_vhook) {
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1774
                    av_exit(1);
1775
                }
1776
                codec->pix_fmt = icodec->pix_fmt;
1777 1778
                codec->width = icodec->width;
                codec->height = icodec->height;
1779
                codec->has_b_frames = icodec->has_b_frames;
1780
                break;
1781
            case CODEC_TYPE_SUBTITLE:
1782 1783
                codec->width = icodec->width;
                codec->height = icodec->height;
1784
                break;
1785
            default:
1786
                abort();
1787 1788 1789 1790
            }
        } else {
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
1791
                if (av_fifo_init(&ost->fifo, 1024))
Fabrice Bellard's avatar
Fabrice Bellard committed
1792
                    goto fail;
1793
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1794 1795
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
                icodec->request_channels = codec->channels;
Fabrice Bellard's avatar
Fabrice Bellard committed
1796 1797
                ist->decoding_needed = 1;
                ost->encoding_needed = 1;
1798 1799
                break;
            case CODEC_TYPE_VIDEO:
1800 1801 1802 1803 1804 1805 1806
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
                ost->video_resample = ((codec->width != icodec->width -
                                (frame_leftBand + frame_rightBand) +
                                (frame_padleft + frame_padright)) ||
                        (codec->height != icodec->height -
                                (frame_topBand  + frame_bottomBand) +
1807 1808
                                (frame_padtop + frame_padbottom)) ||
                        (codec->pix_fmt != icodec->pix_fmt));
1809
                if (ost->video_crop) {
1810 1811
                    ost->topBand = frame_topBand;
                    ost->leftBand = frame_leftBand;
1812 1813
                }
                if (ost->video_pad) {
1814 1815 1816 1817
                    ost->padtop = frame_padtop;
                    ost->padleft = frame_padleft;
                    ost->padbottom = frame_padbottom;
                    ost->padright = frame_padright;
1818 1819
                    if (!ost->video_resample) {
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1820 1821
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
                                         codec->width, codec->height))
1822 1823 1824 1825
                            goto fail;
                    }
                }
                if (ost->video_resample) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1826
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1827 1828
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
                                         codec->width, codec->height)) {
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1829
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1830
                        av_exit(1);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
1831
                    }
1832
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1833 1834 1835 1836
                    ost->img_resample_ctx = sws_getContext(
                            icodec->width - (frame_leftBand + frame_rightBand),
                            icodec->height - (frame_topBand + frame_bottomBand),
                            icodec->pix_fmt,
1837 1838
                            codec->width - (frame_padleft + frame_padright),
                            codec->height - (frame_padtop + frame_padbottom),
1839 1840
                            codec->pix_fmt,
                            sws_flags, NULL, NULL, NULL);
1841 1842
                    if (ost->img_resample_ctx == NULL) {
                        fprintf(stderr, "Cannot get resampling context\n");
1843
                        av_exit(1);
1844
                    }
1845
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
Fabrice Bellard's avatar
Fabrice Bellard committed
1846 1847 1848
                }
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
1849
                break;
1850 1851 1852 1853
            case CODEC_TYPE_SUBTITLE:
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
                break;
1854
            default:
1855
                abort();
1856
                break;
Fabrice Bellard's avatar
Fabrice Bellard committed
1857
            }
1858
            /* two pass mode */
1859
            if (ost->encoding_needed &&
1860 1861 1862 1863 1864
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                char logfilename[1024];
                FILE *f;
                int size;
                char *logbuffer;
1865 1866

                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1867 1868
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
                         i);
1869 1870 1871
                if (codec->flags & CODEC_FLAG_PASS1) {
                    f = fopen(logfilename, "w");
                    if (!f) {
1872
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1873
                        av_exit(1);
1874 1875 1876 1877 1878 1879
                    }
                    ost->logfile = f;
                } else {
                    /* read the log file */
                    f = fopen(logfilename, "r");
                    if (!f) {
1880
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1881
                        av_exit(1);
1882 1883 1884 1885 1886 1887 1888
                    }
                    fseek(f, 0, SEEK_END);
                    size = ftell(f);
                    fseek(f, 0, SEEK_SET);
                    logbuffer = av_malloc(size + 1);
                    if (!logbuffer) {
                        fprintf(stderr, "Could not allocate log buffer\n");
1889
                        av_exit(1);
1890
                    }
1891
                    size = fread(logbuffer, 1, size, f);
1892 1893 1894
                    fclose(f);
                    logbuffer[size] = '\0';
                    codec->stats_in = logbuffer;
1895 1896 1897
                }
            }
        }
1898 1899 1900 1901
        if(codec->codec_type == CODEC_TYPE_VIDEO){
            int size= codec->width * codec->height;
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1902 1903
    }

1904 1905 1906 1907 1908
    if (!bit_buffer)
        bit_buffer = av_malloc(bit_buffer_size);
    if (!bit_buffer)
        goto fail;

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

    /* dump the stream mapping */
1916 1917 1918 1919
    if (verbose >= 0) {
        fprintf(stderr, "Stream mapping:\n");
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
1920
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1921 1922
                    ist_table[ost->source_index]->file_index,
                    ist_table[ost->source_index]->index,
1923
                    ost->file_index,
1924
                    ost->index);
1925 1926 1927 1928 1929
            if (ost->sync_ist != ist_table[ost->source_index])
                fprintf(stderr, " [sync #%d.%d]",
                        ost->sync_ist->file_index,
                        ost->sync_ist->index);
            fprintf(stderr, "\n");
1930
        }
1931 1932
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
1933 1934 1935 1936
    /* open each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
Aurelien Jacobs's avatar
Aurelien Jacobs committed
1937 1938
            AVCodec *codec = output_codecs[i];
            if (!codec)
Aurelien Jacobs's avatar
Aurelien Jacobs committed
1939
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
Fabrice Bellard's avatar
Fabrice Bellard committed
1940
            if (!codec) {
1941
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
Fabrice Bellard's avatar
Fabrice Bellard committed
1942
                        ost->file_index, ost->index);
1943
                av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1944
            }
1945
            if (avcodec_open(ost->st->codec, codec) < 0) {
1946
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
Fabrice Bellard's avatar
Fabrice Bellard committed
1947
                        ost->file_index, ost->index);
1948
                av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1949
            }
1950
            extra_size += ost->st->codec->extradata_size;
Fabrice Bellard's avatar
Fabrice Bellard committed
1951 1952 1953 1954 1955 1956 1957
        }
    }

    /* open each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
Aurelien Jacobs's avatar
Aurelien Jacobs committed
1958 1959
            AVCodec *codec = input_codecs[i];
            if (!codec)
Aurelien Jacobs's avatar
Aurelien Jacobs committed
1960
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
Fabrice Bellard's avatar
Fabrice Bellard committed
1961
            if (!codec) {
1962
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1963
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1964
                av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1965
            }
1966
            if (avcodec_open(ist->st->codec, codec) < 0) {
1967
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
Fabrice Bellard's avatar
Fabrice Bellard committed
1968
                        ist->file_index, ist->index);
1969
                av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1970
            }
1971 1972
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
Fabrice Bellard's avatar
Fabrice Bellard committed
1973 1974 1975 1976 1977 1978
        }
    }

    /* init pts */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
1979
        is = input_files[ist->file_index];
1980
        ist->pts = 0;
1981
        ist->next_pts = AV_NOPTS_VALUE;
1982
        ist->is_start = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1983
    }
1984

1985 1986 1987 1988 1989 1990 1991
    /* set meta data information from input file if required */
    for (i=0;i<nb_meta_data_maps;i++) {
        AVFormatContext *out_file;
        AVFormatContext *in_file;

        int out_file_index = meta_data_maps[i].out_file;
        int in_file_index = meta_data_maps[i].in_file;
1992
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1993
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1994
            ret = AVERROR(EINVAL);
1995 1996
            goto fail;
        }
1997
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1998
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1999
            ret = AVERROR(EINVAL);
2000
            goto fail;
2001 2002
        }

2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
        out_file = output_files[out_file_index];
        in_file = input_files[in_file_index];

        strcpy(out_file->title, in_file->title);
        strcpy(out_file->author, in_file->author);
        strcpy(out_file->copyright, in_file->copyright);
        strcpy(out_file->comment, in_file->comment);
        strcpy(out_file->album, in_file->album);
        out_file->year = in_file->year;
        out_file->track = in_file->track;
        strcpy(out_file->genre, in_file->genre);
    }
2015

Fabrice Bellard's avatar
Fabrice Bellard committed
2016 2017 2018
    /* open files and write file headers */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
2019
        if (av_write_header(os) < 0) {
2020
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
2021
            ret = AVERROR(EINVAL);
2022 2023
            goto fail;
        }
2024 2025 2026 2027 2028 2029
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
            want_sdp = 0;
        }
    }
    if (want_sdp) {
        print_sdp(output_files, nb_output_files);
Fabrice Bellard's avatar
Fabrice Bellard committed
2030 2031
    }

2032
    if (!using_stdin && verbose >= 0) {
2033
        fprintf(stderr, "Press [q] to stop encoding\n");
2034 2035
        url_set_interrupt_cb(decode_interrupt_cb);
    }
2036 2037
    term_init();

2038
    key = -1;
2039
    timer_start = av_gettime();
2040

2041
    for(; received_sigterm == 0;) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2042 2043
        int file_index, ist_index;
        AVPacket pkt;
2044 2045
        double ipts_min;
        double opts_min;
2046

Fabrice Bellard's avatar
Fabrice Bellard committed
2047
    redo:
2048 2049
        ipts_min= 1e100;
        opts_min= 1e100;
2050
        /* if 'q' pressed, exits */
2051
        if (!using_stdin) {
2052 2053
            if (q_pressed)
                break;
2054 2055 2056 2057 2058
            /* read_key() returns 0 on EOF */
            key = read_key();
            if (key == 'q')
                break;
        }
2059

2060 2061
        /* select the stream that we must read now by looking at the
           smallest output pts */
Fabrice Bellard's avatar
Fabrice Bellard committed
2062
        file_index = -1;
2063
        for(i=0;i<nb_ostreams;i++) {
2064
            double ipts, opts;
2065 2066 2067
            ost = ost_table[i];
            os = output_files[ost->file_index];
            ist = ist_table[ost->source_index];
2068 2069
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2070
            else
2071
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
            ipts = (double)ist->pts;
            if (!file_table[ist->file_index].eof_reached){
                if(ipts < ipts_min) {
                    ipts_min = ipts;
                    if(input_sync ) file_index = ist->file_index;
                }
                if(opts < opts_min) {
                    opts_min = opts;
                    if(!input_sync) file_index = ist->file_index;
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
2082
            }
2083
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2084 2085 2086
                file_index= -1;
                break;
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
2087 2088
        }
        /* if none, if is finished */
2089
        if (file_index < 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2090
            break;
2091 2092
        }

Fabrice Bellard's avatar
Fabrice Bellard committed
2093
        /* finish if recording time exhausted */
2094
        if (opts_min >= (recording_time / 1000000.0))
Fabrice Bellard's avatar
Fabrice Bellard committed
2095
            break;
2096

2097
        /* finish if limit size exhausted */
2098
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2099 2100
            break;

2101
        /* read a frame from it and output it in the fifo */
Fabrice Bellard's avatar
Fabrice Bellard committed
2102
        is = input_files[file_index];
2103
        ret= av_read_frame(is, &pkt);
2104
        if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm"))
2105 2106
            continue;
        if (ret < 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2107
            file_table[file_index].eof_reached = 1;
Alex Beregszaszi's avatar
Alex Beregszaszi committed
2108 2109 2110 2111
            if (opt_shortest)
                break;
            else
                continue;
Fabrice Bellard's avatar
Fabrice Bellard committed
2112
        }
2113

2114
        if (do_pkt_dump) {
2115
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2116
        }
2117 2118 2119
        /* the following test is needed in case new streams appear
           dynamically in stream : we ignore them */
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2120
            goto discard_packet;
Fabrice Bellard's avatar
Fabrice Bellard committed
2121 2122
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
        ist = ist_table[ist_index];
2123 2124
        if (ist->discard)
            goto discard_packet;
Fabrice Bellard's avatar
Fabrice Bellard committed
2125

2126 2127 2128 2129 2130
        if (pkt.dts != AV_NOPTS_VALUE)
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
        if (pkt.pts != AV_NOPTS_VALUE)
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);

2131 2132 2133 2134 2135 2136 2137
        if(input_files_ts_scale[file_index][pkt.stream_index]){
            if(pkt.pts != AV_NOPTS_VALUE)
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
            if(pkt.dts != AV_NOPTS_VALUE)
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
        }

2138
//        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2139 2140
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2141 2142 2143
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
            int64_t delta= pkt_dts - ist->next_pts;
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2144 2145
                input_files_ts_offset[ist->file_index]-= delta;
                if (verbose > 2)
2146
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2147 2148 2149
                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);
2150 2151 2152
            }
        }

2153
        //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2154
        if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2155 2156 2157 2158

            if (verbose >= 0)
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
                        ist->file_index, ist->index);
2159 2160
            if (exit_on_error)
                av_exit(1);
2161 2162
            av_free_packet(&pkt);
            goto redo;
Michael Niedermayer's avatar
Michael Niedermayer committed
2163
        }
2164

2165
    discard_packet:
Fabrice Bellard's avatar
Fabrice Bellard committed
2166
        av_free_packet(&pkt);
2167

2168 2169
        /* dump report by using the output first video and audio streams */
        print_report(output_files, ost_table, nb_ostreams, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
2170
    }
2171 2172 2173 2174 2175 2176 2177 2178 2179

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

2180
    term_exit();
Fabrice Bellard's avatar
Fabrice Bellard committed
2181

2182 2183 2184 2185 2186 2187
    /* write the trailer if needed and close file */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
        av_write_trailer(os);
    }

2188 2189 2190
    /* dump report by using the first video and audio streams */
    print_report(output_files, ost_table, nb_ostreams, 1);

Fabrice Bellard's avatar
Fabrice Bellard committed
2191 2192 2193 2194
    /* close each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
2195 2196
            av_freep(&ost->st->codec->stats_in);
            avcodec_close(ost->st->codec);
Fabrice Bellard's avatar
Fabrice Bellard committed
2197 2198
        }
    }
2199

Fabrice Bellard's avatar
Fabrice Bellard committed
2200 2201 2202 2203
    /* close each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
2204
            avcodec_close(ist->st->codec);
Fabrice Bellard's avatar
Fabrice Bellard committed
2205 2206 2207 2208
        }
    }

    /* finished ! */
2209

Fabrice Bellard's avatar
Fabrice Bellard committed
2210 2211
    ret = 0;
 fail1:
2212
    av_freep(&bit_buffer);
2213
    av_free(file_table);
Fabrice Bellard's avatar
Fabrice Bellard committed
2214

Fabrice Bellard's avatar
Fabrice Bellard committed
2215 2216 2217
    if (ist_table) {
        for(i=0;i<nb_istreams;i++) {
            ist = ist_table[i];
2218
            av_free(ist);
Fabrice Bellard's avatar
Fabrice Bellard committed
2219
        }
2220
        av_free(ist_table);
Fabrice Bellard's avatar
Fabrice Bellard committed
2221 2222 2223 2224 2225
    }
    if (ost_table) {
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            if (ost) {
2226 2227 2228 2229
                if (ost->logfile) {
                    fclose(ost->logfile);
                    ost->logfile = NULL;
                }
2230 2231
                av_fifo_free(&ost->fifo); /* works even if fifo is not
                                             initialized but set to zero */
2232
                av_free(ost->pict_tmp.data[0]);
Fabrice Bellard's avatar
Fabrice Bellard committed
2233
                if (ost->video_resample)
2234
                    sws_freeContext(ost->img_resample_ctx);
2235
                if (ost->resample)
Fabrice Bellard's avatar
Fabrice Bellard committed
2236
                    audio_resample_close(ost->resample);
2237 2238
                if (ost->reformat_ctx)
                    av_audio_convert_free(ost->reformat_ctx);
2239
                av_free(ost);
Fabrice Bellard's avatar
Fabrice Bellard committed
2240 2241
            }
        }
2242
        av_free(ost_table);
Fabrice Bellard's avatar
Fabrice Bellard committed
2243 2244 2245
    }
    return ret;
 fail:
2246
    ret = AVERROR(ENOMEM);
Fabrice Bellard's avatar
Fabrice Bellard committed
2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271
    goto fail1;
}

#if 0
int file_read(const char *filename)
{
    URLContext *h;
    unsigned char buffer[1024];
    int len, i;

    if (url_open(&h, filename, O_RDONLY) < 0) {
        printf("could not open '%s'\n", filename);
        return -1;
    }
    for(;;) {
        len = url_read(h, buffer, sizeof(buffer));
        if (len <= 0)
            break;
        for(i=0;i<len;i++) putchar(buffer[i]);
    }
    url_close(h);
    return 0;
}
#endif

2272
static void opt_format(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2273
{
2274 2275
    /* compatibility stuff for pgmyuv */
    if (!strcmp(arg, "pgmyuv")) {
2276
        pgmyuv_compatibility_hack=1;
2277
//        opt_image_format(arg);
2278
        arg = "image2";
2279
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2280 2281
    }

2282 2283 2284 2285
    file_iformat = av_find_input_format(arg);
    file_oformat = guess_format(arg, NULL, NULL);
    if (!file_iformat && !file_oformat) {
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2286
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2287 2288 2289
    }
}

2290
static void opt_video_rc_override_string(const char *arg)
2291 2292 2293 2294
{
    video_rc_override_string = arg;
}

2295
static int opt_me_threshold(const char *opt, const char *arg)
2296
{
2297 2298
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
    return 0;
2299 2300
}

2301
static int opt_verbose(const char *opt, const char *arg)
2302
{
2303
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2304
    av_log_set_level(verbose);
2305
    return 0;
2306 2307
}

2308
static int opt_frame_rate(const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2309
{
2310
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2311
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2312
        av_exit(1);
2313
    }
2314
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2315 2316
}

2317
static int opt_bitrate(const char *opt, const char *arg)
2318 2319 2320 2321 2322 2323 2324
{
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;

    opt_default(opt, arg);

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

    return 0;
2327 2328
}

2329
static void opt_frame_crop_top(const char *arg)
2330
{
2331
    frame_topBand = atoi(arg);
2332 2333
    if (frame_topBand < 0) {
        fprintf(stderr, "Incorrect top crop size\n");
2334
        av_exit(1);
2335 2336 2337
    }
    if ((frame_topBand % 2) != 0) {
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2338
        av_exit(1);
2339 2340
    }
    if ((frame_topBand) >= frame_height){
2341
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2342
        av_exit(1);
2343 2344 2345 2346
    }
    frame_height -= frame_topBand;
}

2347
static void opt_frame_crop_bottom(const char *arg)
2348 2349 2350 2351
{
    frame_bottomBand = atoi(arg);
    if (frame_bottomBand < 0) {
        fprintf(stderr, "Incorrect bottom crop size\n");
2352
        av_exit(1);
2353 2354 2355
    }
    if ((frame_bottomBand % 2) != 0) {
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2356
        av_exit(1);
2357 2358
    }
    if ((frame_bottomBand) >= frame_height){
2359
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2360
        av_exit(1);
2361 2362 2363 2364
    }
    frame_height -= frame_bottomBand;
}

2365
static void opt_frame_crop_left(const char *arg)
2366 2367 2368 2369
{
    frame_leftBand = atoi(arg);
    if (frame_leftBand < 0) {
        fprintf(stderr, "Incorrect left crop size\n");
2370
        av_exit(1);
2371 2372 2373
    }
    if ((frame_leftBand % 2) != 0) {
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2374
        av_exit(1);
2375 2376
    }
    if ((frame_leftBand) >= frame_width){
2377
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2378
        av_exit(1);
2379 2380 2381 2382
    }
    frame_width -= frame_leftBand;
}

2383
static void opt_frame_crop_right(const char *arg)
2384 2385 2386 2387
{
    frame_rightBand = atoi(arg);
    if (frame_rightBand < 0) {
        fprintf(stderr, "Incorrect right crop size\n");
2388
        av_exit(1);
2389 2390 2391
    }
    if ((frame_rightBand % 2) != 0) {
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2392
        av_exit(1);
2393 2394
    }
    if ((frame_rightBand) >= frame_width){
2395
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2396
        av_exit(1);
2397 2398 2399 2400
    }
    frame_width -= frame_rightBand;
}

2401
static void opt_frame_size(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2402
{
2403
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2404
        fprintf(stderr, "Incorrect frame size\n");
2405
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2406 2407 2408
    }
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2409
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2410 2411 2412
    }
}

2413 2414 2415

#define SCALEBITS 10
#define ONE_HALF  (1 << (SCALEBITS - 1))
2416
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434

#define RGB_TO_Y(r, g, b) \
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)

#define RGB_TO_U(r1, g1, b1, shift)\
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)

#define RGB_TO_V(r1, g1, b1, shift)\
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)

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

    r = (rgb >> 16);
2437 2438 2439 2440 2441 2442 2443 2444 2445 2446
    g = ((rgb >> 8) & 255);
    b = (rgb & 255);

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

static void opt_frame_pad_top(const char *arg)
{
2447
    frame_padtop = atoi(arg);
2448 2449
    if (frame_padtop < 0) {
        fprintf(stderr, "Incorrect top pad size\n");
2450
        av_exit(1);
2451 2452 2453
    }
    if ((frame_padtop % 2) != 0) {
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2454
        av_exit(1);
2455 2456 2457 2458 2459
    }
}

static void opt_frame_pad_bottom(const char *arg)
{
2460
    frame_padbottom = atoi(arg);
2461 2462
    if (frame_padbottom < 0) {
        fprintf(stderr, "Incorrect bottom pad size\n");
2463
        av_exit(1);
2464 2465 2466
    }
    if ((frame_padbottom % 2) != 0) {
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2467
        av_exit(1);
2468 2469 2470 2471 2472 2473
    }
}


static void opt_frame_pad_left(const char *arg)
{
2474
    frame_padleft = atoi(arg);
2475 2476
    if (frame_padleft < 0) {
        fprintf(stderr, "Incorrect left pad size\n");
2477
        av_exit(1);
2478 2479 2480
    }
    if ((frame_padleft % 2) != 0) {
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2481
        av_exit(1);
2482 2483 2484 2485 2486 2487
    }
}


static void opt_frame_pad_right(const char *arg)
{
2488
    frame_padright = atoi(arg);
2489 2490
    if (frame_padright < 0) {
        fprintf(stderr, "Incorrect right pad size\n");
2491
        av_exit(1);
2492 2493 2494
    }
    if ((frame_padright % 2) != 0) {
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2495
        av_exit(1);
2496 2497 2498
    }
}

2499
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2500 2501
{
    int i;
2502 2503 2504 2505
    char fmt_str[128];
    for (i=-1; i < nb_fmts; i++) {
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
        fprintf(stdout, "%s\n", fmt_str);
2506 2507
    }
}
2508

2509 2510
static void opt_frame_pix_fmt(const char *arg)
{
2511 2512 2513
    if (strcmp(arg, "list"))
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
    else {
2514
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2515
        av_exit(0);
2516
    }
2517 2518
}

2519 2520 2521 2522 2523
static void opt_frame_aspect_ratio(const char *arg)
{
    int x = 0, y = 0;
    double ar = 0;
    const char *p;
2524
    char *end;
2525

2526 2527
    p = strchr(arg, ':');
    if (p) {
2528 2529 2530
        x = strtol(arg, &end, 10);
        if (end == p)
            y = strtol(end+1, &end, 10);
2531 2532
        if (x > 0 && y > 0)
            ar = (double)x / (double)y;
2533
    } else
2534
        ar = strtod(arg, NULL);
2535 2536 2537

    if (!ar) {
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2538
        av_exit(1);
2539 2540 2541 2542
    }
    frame_aspect_ratio = ar;
}

2543
static void opt_qscale(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2544
{
2545
    video_qscale = atof(arg);
Loren Merritt's avatar
Loren Merritt committed
2546
    if (video_qscale <= 0 ||
2547
        video_qscale > 255) {
Loren Merritt's avatar
Loren Merritt committed
2548
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2549
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2550 2551 2552
    }
}

2553 2554 2555 2556 2557
static void opt_top_field_first(const char *arg)
{
    top_field_first= atoi(arg);
}

2558
static int opt_thread_count(const char *opt, const char *arg)
2559
{
2560
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2561
#if !HAVE_THREADS
2562 2563
    if (verbose >= 0)
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2564
#endif
2565
    return 0;
2566 2567
}

2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
static void opt_audio_sample_fmt(const char *arg)
{
    if (strcmp(arg, "list"))
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
    else {
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
        av_exit(0);
    }
}

2578
static int opt_audio_rate(const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2579
{
2580 2581
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2582 2583
}

2584
static int opt_audio_channels(const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2585
{
2586 2587
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2588 2589
}

2590
static void opt_video_channel(const char *arg)
2591 2592 2593 2594
{
    video_channel = strtol(arg, NULL, 0);
}

2595 2596 2597 2598 2599
static void opt_video_standard(const char *arg)
{
    video_standard = av_strdup(arg);
}

2600
static void opt_codec(int *pstream_copy, char **pcodec_name,
2601
                      int codec_type, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2602
{
2603
    av_freep(pcodec_name);
2604
    if (!strcmp(arg, "copy")) {
2605
        *pstream_copy = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
2606
    } else {
2607
        *pcodec_name = av_strdup(arg);
Fabrice Bellard's avatar
Fabrice Bellard committed
2608 2609 2610
    }
}

2611 2612
static void opt_audio_codec(const char *arg)
{
2613
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2614 2615
}

2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633
static void opt_audio_tag(const char *arg)
{
    char *tail;
    audio_codec_tag= strtol(arg, &tail, 0);

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

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

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

2634
#if CONFIG_VHOOK
2635
static void add_frame_hooker(const char *arg)
2636 2637 2638 2639
{
    int argc = 0;
    char *argv[64];
    int i;
Fabrice Bellard's avatar
Fabrice Bellard committed
2640
    char *args = av_strdup(arg);
2641

2642 2643
    using_vhook = 1;

2644 2645 2646 2647 2648 2649 2650 2651
    argv[0] = strtok(args, " ");
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
    }

    i = frame_hook_add(argc, argv);

    if (i != 0) {
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2652
        av_exit(1);
2653 2654
    }
}
2655
#endif
2656

2657
static void opt_video_codec(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2658
{
2659
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2660
}
Fabrice Bellard's avatar
Fabrice Bellard committed
2661

2662 2663
static void opt_subtitle_codec(const char *arg)
{
2664
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
Fabrice Bellard's avatar
Fabrice Bellard committed
2665 2666
}

2667
static void opt_map(const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2668 2669
{
    AVStreamMap *m;
2670
    char *p;
Fabrice Bellard's avatar
Fabrice Bellard committed
2671 2672 2673

    m = &stream_maps[nb_stream_maps++];

2674
    m->file_index = strtol(arg, &p, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
2675 2676
    if (*p)
        p++;
Juanjo's avatar
Juanjo committed
2677

2678
    m->stream_index = strtol(p, &p, 0);
2679 2680
    if (*p) {
        p++;
2681
        m->sync_file_index = strtol(p, &p, 0);
2682 2683
        if (*p)
            p++;
2684
        m->sync_stream_index = strtol(p, &p, 0);
2685 2686 2687 2688
    } else {
        m->sync_file_index = m->file_index;
        m->sync_stream_index = m->stream_index;
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
2689 2690
}

2691 2692 2693
static void opt_map_meta_data(const char *arg)
{
    AVMetaDataMap *m;
2694
    char *p;
2695

2696 2697
    m = &meta_data_maps[nb_meta_data_maps++];

2698
    m->out_file = strtol(arg, &p, 0);
2699 2700 2701
    if (*p)
        p++;

2702
    m->in_file = strtol(p, &p, 0);
2703 2704
}

2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721
static void opt_input_ts_scale(const char *arg)
{
    unsigned int stream;
    double scale;
    char *p;

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

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

    input_files_ts_scale[nb_input_files][stream]= scale;
}

2722
static int opt_recording_time(const char *opt, const char *arg)
Fabrice Bellard's avatar
Fabrice Bellard committed
2723
{
2724 2725
    recording_time = parse_time_or_die(opt, arg, 1);
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2726 2727
}

2728
static int opt_start_time(const char *opt, const char *arg)
2729
{
2730 2731
    start_time = parse_time_or_die(opt, arg, 1);
    return 0;
2732 2733
}

2734
static int opt_rec_timestamp(const char *opt, const char *arg)
2735
{
2736 2737
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
    return 0;
2738 2739
}

2740
static int opt_input_ts_offset(const char *opt, const char *arg)
2741
{
2742 2743
    input_ts_offset = parse_time_or_die(opt, arg, 1);
    return 0;
2744 2745
}

2746 2747
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
{
Michael Niedermayer's avatar
Michael Niedermayer committed
2748
    const char *codec_string = encoder ? "encoder" : "decoder";
2749 2750 2751 2752 2753 2754 2755 2756
    AVCodec *codec;

    if(!name)
        return CODEC_ID_NONE;
    codec = encoder ?
        avcodec_find_encoder_by_name(name) :
        avcodec_find_decoder_by_name(name);
    if(!codec) {
2757
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2758
        av_exit(1);
2759 2760
    }
    if(codec->type != type) {
2761
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2762
        av_exit(1);
2763 2764 2765 2766
    }
    return codec->id;
}

2767
static void opt_input_file(const char *filename)
Fabrice Bellard's avatar
Fabrice Bellard committed
2768 2769 2770
{
    AVFormatContext *ic;
    AVFormatParameters params, *ap = &params;
2771
    int err, i, ret, rfps, rfps_base;
2772
    int64_t timestamp;
Fabrice Bellard's avatar
Fabrice Bellard committed
2773

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

2777
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2778
                    !strcmp(filename, "/dev/stdin");
2779

Fabrice Bellard's avatar
Fabrice Bellard committed
2780
    /* get default parameters from command line */
2781 2782
    ic = av_alloc_format_context();

2783
    memset(ap, 0, sizeof(*ap));
2784
    ap->prealloced_context = 1;
2785 2786
    ap->sample_rate = audio_sample_rate;
    ap->channels = audio_channels;
2787 2788
    ap->time_base.den = frame_rate.num;
    ap->time_base.num = frame_rate.den;
2789 2790
    ap->width = frame_width + frame_padleft + frame_padright;
    ap->height = frame_height + frame_padtop + frame_padbottom;
2791
    ap->pix_fmt = frame_pix_fmt;
2792
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2793 2794
    ap->channel = video_channel;
    ap->standard = video_standard;
2795 2796
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2797 2798
    if(pgmyuv_compatibility_hack)
        ap->video_codec_id= CODEC_ID_PGMYUV;
2799

2800
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2801 2802 2803 2804 2805

    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);

2806 2807
    /* open the input file with generic libav function */
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
Fabrice Bellard's avatar
Fabrice Bellard committed
2808
    if (err < 0) {
2809
        print_error(filename, err);
2810
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2811
    }
2812 2813 2814 2815 2816 2817
    if(opt_programid) {
        int i;
        for(i=0; i<ic->nb_programs; i++)
            if(ic->programs[i]->id != opt_programid)
                ic->programs[i]->discard = AVDISCARD_ALL;
    }
2818

2819 2820
    ic->loop_input = loop_input;

2821 2822 2823
    /* If not enough info to get the stream parameters, we decode the
       first frames to get it. (used in mpeg case for example) */
    ret = av_find_stream_info(ic);
2824
    if (ret < 0 && verbose >= 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2825
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2826
        av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2827 2828
    }

2829 2830 2831 2832 2833
    timestamp = start_time;
    /* add the stream start time */
    if (ic->start_time != AV_NOPTS_VALUE)
        timestamp += ic->start_time;

2834 2835
    /* if seeking requested, we execute it */
    if (start_time != 0) {
2836
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2837
        if (ret < 0) {
2838
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2839 2840 2841 2842 2843 2844
                    filename, (double)timestamp / AV_TIME_BASE);
        }
        /* reset seek info */
        start_time = 0;
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
2845 2846
    /* update the current parameters so that they match the one of the input stream */
    for(i=0;i<ic->nb_streams;i++) {
2847
        AVCodecContext *enc = ic->streams[i]->codec;
2848 2849 2850
        if(thread_count>1)
            avcodec_thread_init(enc, thread_count);
        enc->thread_count= thread_count;
Fabrice Bellard's avatar
Fabrice Bellard committed
2851 2852
        switch(enc->codec_type) {
        case CODEC_TYPE_AUDIO:
2853
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2854
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2855
            channel_layout = enc->channel_layout;
Fabrice Bellard's avatar
Fabrice Bellard committed
2856 2857
            audio_channels = enc->channels;
            audio_sample_rate = enc->sample_rate;
2858
            audio_sample_fmt = enc->sample_fmt;
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2859
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2860
            if(audio_disable)
2861
                ic->streams[i]->discard= AVDISCARD_ALL;
Fabrice Bellard's avatar
Fabrice Bellard committed
2862 2863
            break;
        case CODEC_TYPE_VIDEO:
2864
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
Fabrice Bellard's avatar
Fabrice Bellard committed
2865 2866
            frame_height = enc->height;
            frame_width = enc->width;
2867 2868 2869 2870 2871
            if(ic->streams[i]->sample_aspect_ratio.num)
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
            else
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
            frame_aspect_ratio *= (float) enc->width / enc->height;
2872
            frame_pix_fmt = enc->pix_fmt;
2873 2874
            rfps      = ic->streams[i]->r_frame_rate.num;
            rfps_base = ic->streams[i]->r_frame_rate.den;
2875
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2876 2877
            if(me_threshold)
                enc->debug |= FF_DEBUG_MV;
2878

2879
            if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2880 2881

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

2885
                    (float)rfps / rfps_base, rfps, rfps_base);
2886
            }
2887
            /* update the current frame rate to match the stream frame rate */
2888 2889
            frame_rate.num = rfps;
            frame_rate.den = rfps_base;
2890

Aurelien Jacobs's avatar
Aurelien Jacobs committed
2891
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2892
            if(video_disable)
2893 2894 2895
                ic->streams[i]->discard= AVDISCARD_ALL;
            else if(video_discard)
                ic->streams[i]->discard= video_discard;
Fabrice Bellard's avatar
Fabrice Bellard committed
2896
            break;
2897 2898
        case CODEC_TYPE_DATA:
            break;
2899
        case CODEC_TYPE_SUBTITLE:
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2900
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2901 2902
            if(subtitle_disable)
                ic->streams[i]->discard = AVDISCARD_ALL;
2903
            break;
2904
        case CODEC_TYPE_ATTACHMENT:
2905
        case CODEC_TYPE_UNKNOWN:
Aurelien Jacobs's avatar
Aurelien Jacobs committed
2906
            nb_icodecs++;
2907
            break;
2908
        default:
2909
            abort();
Fabrice Bellard's avatar
Fabrice Bellard committed
2910 2911
        }
    }
2912

Fabrice Bellard's avatar
Fabrice Bellard committed
2913
    input_files[nb_input_files] = ic;
2914
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
Fabrice Bellard's avatar
Fabrice Bellard committed
2915
    /* dump the file content */
2916 2917 2918
    if (verbose >= 0)
        dump_format(ic, nb_input_files, filename, 0);

Fabrice Bellard's avatar
Fabrice Bellard committed
2919
    nb_input_files++;
2920 2921
    file_iformat = NULL;
    file_oformat = NULL;
2922

2923
    video_channel = 0;
2924

2925 2926 2927
    av_freep(&video_codec_name);
    av_freep(&audio_codec_name);
    av_freep(&subtitle_codec_name);
Fabrice Bellard's avatar
Fabrice Bellard committed
2928 2929
}

2930 2931
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
                                         int *has_subtitle_ptr)
2932
{
2933
    int has_video, has_audio, has_subtitle, i, j;
2934 2935 2936 2937
    AVFormatContext *ic;

    has_video = 0;
    has_audio = 0;
2938
    has_subtitle = 0;
2939 2940 2941
    for(j=0;j<nb_input_files;j++) {
        ic = input_files[j];
        for(i=0;i<ic->nb_streams;i++) {
2942
            AVCodecContext *enc = ic->streams[i]->codec;
2943 2944 2945 2946 2947 2948 2949
            switch(enc->codec_type) {
            case CODEC_TYPE_AUDIO:
                has_audio = 1;
                break;
            case CODEC_TYPE_VIDEO:
                has_video = 1;
                break;
2950 2951 2952
            case CODEC_TYPE_SUBTITLE:
                has_subtitle = 1;
                break;
2953
            case CODEC_TYPE_DATA:
2954
            case CODEC_TYPE_ATTACHMENT:
2955
            case CODEC_TYPE_UNKNOWN:
2956
                break;
2957
            default:
2958
                abort();
2959 2960 2961 2962 2963
            }
        }
    }
    *has_video_ptr = has_video;
    *has_audio_ptr = has_audio;
2964
    *has_subtitle_ptr = has_subtitle;
2965 2966
}

2967
static void new_video_stream(AVFormatContext *oc)
Fabrice Bellard's avatar
Fabrice Bellard committed
2968 2969
{
    AVStream *st;
2970 2971
    AVCodecContext *video_enc;
    int codec_id;
2972

2973 2974 2975
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
2976
        av_exit(1);
2977
    }
2978
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2979 2980 2981
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
    video_bitstream_filters= NULL;

2982
    if(thread_count>1)
2983
        avcodec_thread_init(st->codec, thread_count);
2984

2985
    video_enc = st->codec;
2986

2987 2988
    if(video_codec_tag)
        video_enc->codec_tag= video_codec_tag;
2989

2990
    if(   (video_global_header&1)
2991
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2992
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2993
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2994 2995
    }
    if(video_global_header&2){
2996
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2997
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2998
    }
2999

3000 3001 3002
    if (video_stream_copy) {
        st->stream_copy = 1;
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3003
        video_enc->sample_aspect_ratio =
3004
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3005
    } else {
3006
        const char *p;
3007 3008
        int i;
        AVCodec *codec;
3009
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3010

Aurelien Jacobs's avatar
Aurelien Jacobs committed
3011
        if (video_codec_name) {
3012
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3013 3014 3015 3016 3017 3018
            codec = avcodec_find_encoder_by_name(video_codec_name);
            output_codecs[nb_ocodecs] = codec;
        } else {
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
            codec = avcodec_find_encoder(codec_id);
        }
3019

3020
        video_enc->codec_id = codec_id;
3021

3022
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3023

3024 3025
        if (codec && codec->supported_framerates && !force_fps)
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3026 3027
        video_enc->time_base.den = fps.num;
        video_enc->time_base.num = fps.den;
3028

3029 3030
        video_enc->width = frame_width + frame_padright + frame_padleft;
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3031
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3032
        video_enc->pix_fmt = frame_pix_fmt;
3033
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044

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

3045
        if (intra_only)
3046 3047 3048
            video_enc->gop_size = 0;
        if (video_qscale || same_quality) {
            video_enc->flags |= CODEC_FLAG_QSCALE;
3049
            video_enc->global_quality=
3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064
                st->quality = FF_QP2LAMBDA * video_qscale;
        }

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

        video_enc->thread_count = thread_count;
        p= video_rc_override_string;
        for(i=0; p; i++){
            int start, end, q;
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
            if(e!=3){
                fprintf(stderr, "error parsing rc_override\n");
3065
                av_exit(1);
3066
            }
3067 3068
            video_enc->rc_override=
                av_realloc(video_enc->rc_override,
3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083
                           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;
3084 3085
        if (!video_enc->rc_initial_buffer_occupancy)
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3086 3087 3088 3089 3090
        video_enc->me_threshold= me_threshold;
        video_enc->intra_dc_precision= intra_dc_precision - 8;

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

3092 3093 3094 3095 3096 3097 3098 3099 3100
        /* two pass mode */
        if (do_pass) {
            if (do_pass == 1) {
                video_enc->flags |= CODEC_FLAG_PASS1;
            } else {
                video_enc->flags |= CODEC_FLAG_PASS2;
            }
        }
    }
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3101
    nb_ocodecs++;
3102 3103 3104

    /* reset some key parameters */
    video_disable = 0;
3105
    av_freep(&video_codec_name);
3106 3107 3108 3109 3110 3111 3112
    video_stream_copy = 0;
}

static void new_audio_stream(AVFormatContext *oc)
{
    AVStream *st;
    AVCodecContext *audio_enc;
3113
    int codec_id;
3114

3115 3116 3117
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
3118
        av_exit(1);
3119
    }
3120
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3121 3122 3123 3124

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

3125
    if(thread_count>1)
3126
        avcodec_thread_init(st->codec, thread_count);
3127

3128
    audio_enc = st->codec;
3129
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3130

3131 3132
    if(audio_codec_tag)
        audio_enc->codec_tag= audio_codec_tag;
3133

3134
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3135
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3136
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3137
    }
3138 3139 3140 3141
    if (audio_stream_copy) {
        st->stream_copy = 1;
        audio_enc->channels = audio_channels;
    } else {
3142
        AVCodec *codec;
3143

3144
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3145

Aurelien Jacobs's avatar
Aurelien Jacobs committed
3146
        if (audio_codec_name) {
3147
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3148 3149 3150 3151 3152 3153
            codec = avcodec_find_encoder_by_name(audio_codec_name);
            output_codecs[nb_ocodecs] = codec;
        } else {
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
            codec = avcodec_find_encoder(codec_id);
        }
3154
        audio_enc->codec_id = codec_id;
3155

3156 3157 3158 3159
        if (audio_qscale > QSCALE_NONE) {
            audio_enc->flags |= CODEC_FLAG_QSCALE;
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
        }
3160
        audio_enc->thread_count = thread_count;
3161
        audio_enc->channels = audio_channels;
3162
        audio_enc->sample_fmt = audio_sample_fmt;
3163
        audio_enc->channel_layout = channel_layout;
3164 3165 3166 3167 3168 3169 3170 3171 3172 3173

        if(codec && codec->sample_fmts){
            const enum SampleFormat *p= codec->sample_fmts;
            for(; *p!=-1; p++){
                if(*p == audio_enc->sample_fmt)
                    break;
            }
            if(*p == -1)
                audio_enc->sample_fmt = codec->sample_fmts[0];
        }
3174
    }
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3175
    nb_ocodecs++;
3176
    audio_enc->sample_rate = audio_sample_rate;
3177
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3178
    if (audio_language) {
3179
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3180 3181 3182 3183 3184 3185
        av_free(audio_language);
        audio_language = NULL;
    }

    /* reset some key parameters */
    audio_disable = 0;
3186
    av_freep(&audio_codec_name);
3187 3188 3189
    audio_stream_copy = 0;
}

3190
static void new_subtitle_stream(AVFormatContext *oc)
3191 3192 3193
{
    AVStream *st;
    AVCodecContext *subtitle_enc;
3194

3195 3196 3197
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
3198
        av_exit(1);
3199
    }
3200
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3201

3202 3203 3204
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
    subtitle_bitstream_filters= NULL;

3205
    subtitle_enc = st->codec;
3206 3207 3208 3209
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
    if (subtitle_stream_copy) {
        st->stream_copy = 1;
    } else {
3210
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3211
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3212
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3213
    }
Aurelien Jacobs's avatar
Aurelien Jacobs committed
3214
    nb_ocodecs++;
3215 3216

    if (subtitle_language) {
3217
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3218 3219 3220 3221
        av_free(subtitle_language);
        subtitle_language = NULL;
    }

3222
    subtitle_disable = 0;
3223
    av_freep(&subtitle_codec_name);
3224 3225 3226 3227 3228 3229 3230 3231
    subtitle_stream_copy = 0;
}

static void opt_new_audio_stream(void)
{
    AVFormatContext *oc;
    if (nb_output_files <= 0) {
        fprintf(stderr, "At least one output file must be specified\n");
3232
        av_exit(1);
3233 3234 3235 3236 3237 3238 3239 3240 3241 3242
    }
    oc = output_files[nb_output_files - 1];
    new_audio_stream(oc);
}

static void opt_new_video_stream(void)
{
    AVFormatContext *oc;
    if (nb_output_files <= 0) {
        fprintf(stderr, "At least one output file must be specified\n");
3243
        av_exit(1);
3244 3245 3246 3247 3248
    }
    oc = output_files[nb_output_files - 1];
    new_video_stream(oc);
}

3249 3250 3251 3252 3253
static void opt_new_subtitle_stream(void)
{
    AVFormatContext *oc;
    if (nb_output_files <= 0) {
        fprintf(stderr, "At least one output file must be specified\n");
3254
        av_exit(1);
3255 3256 3257 3258 3259
    }
    oc = output_files[nb_output_files - 1];
    new_subtitle_stream(oc);
}

3260 3261 3262
static void opt_output_file(const char *filename)
{
    AVFormatContext *oc;
3263
    int use_video, use_audio, use_subtitle;
3264
    int input_has_video, input_has_audio, input_has_subtitle;
3265
    AVFormatParameters params, *ap = &params;
Fabrice Bellard's avatar
Fabrice Bellard committed
3266 3267 3268 3269

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

3270
    oc = av_alloc_format_context();
Fabrice Bellard's avatar
Fabrice Bellard committed
3271

3272 3273 3274
    if (!file_oformat) {
        file_oformat = guess_format(NULL, filename, NULL);
        if (!file_oformat) {
3275
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3276
                    filename);
3277
            av_exit(1);
3278
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
3279
    }
3280

3281
    oc->oformat = file_oformat;
3282
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
Fabrice Bellard's avatar
Fabrice Bellard committed
3283

3284
    if (!strcmp(file_oformat->name, "ffm") &&
3285
        av_strstart(filename, "http:", NULL)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
3286 3287
        /* special case for files sent to ffserver: we get the stream
           parameters from ffserver */
3288 3289 3290
        int err = read_ffserver_streams(oc, filename);
        if (err < 0) {
            print_error(filename, err);
3291
            av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
3292 3293
        }
    } else {
3294 3295 3296
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3297

3298 3299 3300
        /* disable if no corresponding type found and at least one
           input file */
        if (nb_input_files > 0) {
3301 3302
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
                                         &input_has_subtitle);
3303 3304 3305 3306
            if (!input_has_video)
                use_video = 0;
            if (!input_has_audio)
                use_audio = 0;
3307 3308
            if (!input_has_subtitle)
                use_subtitle = 0;
3309
        }
3310 3311

        /* manual disable */
Fabrice Bellard's avatar
Fabrice Bellard committed
3312 3313 3314 3315 3316 3317
        if (audio_disable) {
            use_audio = 0;
        }
        if (video_disable) {
            use_video = 0;
        }
3318 3319 3320
        if (subtitle_disable) {
            use_subtitle = 0;
        }
3321

Fabrice Bellard's avatar
Fabrice Bellard committed
3322
        if (use_video) {
3323
            new_video_stream(oc);
Fabrice Bellard's avatar
Fabrice Bellard committed
3324
        }
3325

Fabrice Bellard's avatar
Fabrice Bellard committed
3326
        if (use_audio) {
3327
            new_audio_stream(oc);
Fabrice Bellard's avatar
Fabrice Bellard committed
3328 3329
        }

3330 3331 3332 3333
        if (use_subtitle) {
            new_subtitle_stream(oc);
        }

3334
        oc->timestamp = rec_timestamp;
3335

3336
        if (str_title)
3337
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
Fabrice Bellard's avatar
Fabrice Bellard committed
3338
        if (str_author)
3339
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
Fabrice Bellard's avatar
Fabrice Bellard committed
3340
        if (str_copyright)
3341
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
Fabrice Bellard's avatar
Fabrice Bellard committed
3342
        if (str_comment)
3343
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3344
        if (str_album)
3345
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3346 3347
        if (str_genre)
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
Fabrice Bellard's avatar
Fabrice Bellard committed
3348 3349
    }

3350
    output_files[nb_output_files++] = oc;
Fabrice Bellard's avatar
Fabrice Bellard committed
3351

3352
    /* check filename in case of an image number is expected */
3353
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3354
        if (!av_filename_number_test(oc->filename)) {
3355
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3356
            av_exit(1);
3357
        }
3358 3359
    }

3360
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
3361
        /* test if it already exists to avoid loosing precious files */
3362
        if (!file_overwrite &&
Fabrice Bellard's avatar
Fabrice Bellard committed
3363
            (strchr(filename, ':') == NULL ||
3364
             filename[1] == ':' ||
3365
             av_strstart(filename, "file:", NULL))) {
Fabrice Bellard's avatar
Fabrice Bellard committed
3366 3367
            if (url_exist(filename)) {
                int c;
3368

3369
                if (!using_stdin) {
3370 3371 3372 3373 3374
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
                    fflush(stderr);
                    c = getchar();
                    if (toupper(c) != 'Y') {
                        fprintf(stderr, "Not overwriting - exiting\n");
3375
                        av_exit(1);
3376
                    }
3377 3378
                }
                else {
3379
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3380
                    av_exit(1);
3381
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
3382 3383
            }
        }
3384

Fabrice Bellard's avatar
Fabrice Bellard committed
3385 3386 3387
        /* open the file */
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
            fprintf(stderr, "Could not open '%s'\n", filename);
3388
            av_exit(1);
Fabrice Bellard's avatar
Fabrice Bellard committed
3389 3390 3391
        }
    }

3392 3393 3394 3395
    memset(ap, 0, sizeof(*ap));
    if (av_set_parameters(oc, ap) < 0) {
        fprintf(stderr, "%s: Invalid encoding parameters\n",
                oc->filename);
3396
        av_exit(1);
3397 3398
    }

3399 3400
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3401
    oc->loop_output = loop_output;
3402

3403
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3404

Fabrice Bellard's avatar
Fabrice Bellard committed
3405
    /* reset some options */
3406 3407
    file_oformat = NULL;
    file_iformat = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
3408 3409
}

3410
/* same option as mencoder */
3411
static void opt_pass(const char *pass_str)
3412 3413 3414 3415 3416
{
    int pass;
    pass = atoi(pass_str);
    if (pass != 1 && pass != 2) {
        fprintf(stderr, "pass number can be only 1 or 2\n");
3417
        av_exit(1);
3418 3419 3420
    }
    do_pass = pass;
}
3421

3422
static int64_t getutime(void)
Fabrice Bellard's avatar
Fabrice Bellard committed
3423
{
3424
#if HAVE_GETRUSAGE
3425 3426 3427 3428
    struct rusage rusage;

    getrusage(RUSAGE_SELF, &rusage);
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3429
#elif HAVE_GETPROCESSTIMES
3430 3431 3432 3433 3434 3435
    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
3436
    return av_gettime();
Ramiro Polla's avatar
Ramiro Polla committed
3437
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
3438
}
Fabrice Bellard's avatar
Fabrice Bellard committed
3439

3440
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3441 3442 3443 3444 3445 3446 3447 3448 3449 3450
{
    int i;
    const char *p = str;
    for(i = 0;; i++) {
        dest[i] = atoi(p);
        if(i == 63)
            break;
        p = strchr(p, ',');
        if(!p) {
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3451
            av_exit(1);
3452 3453 3454 3455 3456
        }
        p++;
    }
}

3457
static void opt_inter_matrix(const char *arg)
3458 3459 3460 3461 3462
{
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(inter_matrix, arg);
}

3463
static void opt_intra_matrix(const char *arg)
3464 3465 3466 3467 3468
{
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(intra_matrix, arg);
}

3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484
/**
 * Trivial log callback.
 * Only suitable for show_help and similar since it lacks prefix handling.
 */
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
{
    vfprintf(stdout, fmt, vl);
}

static void show_help(void)
{
    av_log_set_callback(log_callback_help);
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
           "Hyper fast Audio and Video encoder\n");
    printf("\n");
    show_help_options(options, "Main options:\n",
3485
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3486 3487 3488
    show_help_options(options, "\nAdvanced options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
                      OPT_EXPERT);
3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506
    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);
3507
    printf("\n");
3508
    av_opt_show(avctx_opts[0], NULL);
3509
    printf("\n");
3510
    av_opt_show(avformat_opts, NULL);
3511
    printf("\n");
3512 3513 3514
    av_opt_show(sws_opts, NULL);
}

3515 3516 3517
static void opt_target(const char *arg)
{
    int norm = -1;
3518
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3519 3520 3521 3522 3523 3524 3525

    if(!strncmp(arg, "pal-", 4)) {
        norm = 0;
        arg += 4;
    } else if(!strncmp(arg, "ntsc-", 5)) {
        norm = 1;
        arg += 5;
3526 3527 3528
    } else if(!strncmp(arg, "film-", 5)) {
        norm = 2;
        arg += 5;
3529 3530 3531
    } else {
        int fr;
        /* Calculate FR via float to avoid int overflow */
3532
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3533 3534 3535 3536 3537 3538 3539 3540 3541 3542
        if(fr == 25000) {
            norm = 0;
        } else if((fr == 29970) || (fr == 23976)) {
            norm = 1;
        } else {
            /* Try to determine PAL/NTSC by peeking in the input files */
            if(nb_input_files) {
                int i, j;
                for(j = 0; j < nb_input_files; j++) {
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3543
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3544 3545
                        if(c->codec_type != CODEC_TYPE_VIDEO)
                            continue;
3546
                        fr = c->time_base.den * 1000 / c->time_base.num;
3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560
                        if(fr == 25000) {
                            norm = 0;
                            break;
                        } else if((fr == 29970) || (fr == 23976)) {
                            norm = 1;
                            break;
                        }
                    }
                    if(norm >= 0)
                        break;
                }
            }
        }
        if(verbose && norm >= 0)
3561
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3562 3563 3564
    }

    if(norm < 0) {
3565 3566
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3567
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3568
        av_exit(1);
3569 3570 3571 3572 3573 3574 3575 3576 3577
    }

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

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

        opt_frame_size(norm ? "352x240" : "352x288");
3578
        opt_frame_rate(NULL, frame_rates[norm]);
3579
        opt_default("gop", norm ? "18" : "15");
3580

3581
        opt_default("b", "1150000");
3582 3583
        opt_default("maxrate", "1150000");
        opt_default("minrate", "1150000");
3584
        opt_default("bufsize", "327680"); // 40*1024*8;
3585

3586
        opt_default("ab", "224000");
3587
        audio_sample_rate = 44100;
3588
        audio_channels = 2;
3589

3590
        opt_default("packetsize", "2324");
3591
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3592

3593 3594 3595 3596 3597 3598
        /* We have to offset the PTS, so that it is consistent with the SCR.
           SCR starts at 36000, but the first two packs contain only padding
           and the first pack from the other stream, respectively, may also have
           been written before.
           So the real data starts at SCR 36000+3*1200. */
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3599 3600 3601 3602
    } else if(!strcmp(arg, "svcd")) {

        opt_video_codec("mpeg2video");
        opt_audio_codec("mp2");
3603
        opt_format("svcd");
3604 3605

        opt_frame_size(norm ? "480x480" : "480x576");
3606
        opt_frame_rate(NULL, frame_rates[norm]);
3607
        opt_default("gop", norm ? "18" : "15");
3608

3609
        opt_default("b", "2040000");
3610 3611
        opt_default("maxrate", "2516000");
        opt_default("minrate", "0"); //1145000;
3612
        opt_default("bufsize", "1835008"); //224*1024*8;
3613
        opt_default("flags", "+scan_offset");
3614

3615

3616
        opt_default("ab", "224000");
3617 3618
        audio_sample_rate = 44100;

3619
        opt_default("packetsize", "2324");
3620

3621 3622 3623 3624
    } else if(!strcmp(arg, "dvd")) {

        opt_video_codec("mpeg2video");
        opt_audio_codec("ac3");
3625
        opt_format("dvd");
3626 3627

        opt_frame_size(norm ? "720x480" : "720x576");
3628
        opt_frame_rate(NULL, frame_rates[norm]);
3629
        opt_default("gop", norm ? "18" : "15");
3630

3631
        opt_default("b", "6000000");
3632 3633
        opt_default("maxrate", "9000000");
        opt_default("minrate", "0"); //1500000;
3634
        opt_default("bufsize", "1835008"); //224*1024*8;
3635

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

3639
        opt_default("ab", "448000");
3640 3641
        audio_sample_rate = 48000;

3642
    } else if(!strncmp(arg, "dv", 2)) {
3643 3644 3645 3646

        opt_format("dv");

        opt_frame_size(norm ? "720x480" : "720x576");
3647 3648
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
                                             (norm ? "yuv411p" : "yuv420p"));
3649
        opt_frame_rate(NULL, frame_rates[norm]);
3650 3651 3652 3653

        audio_sample_rate = 48000;
        audio_channels = 2;

3654 3655
    } else {
        fprintf(stderr, "Unknown target: %s\n", arg);
3656
        av_exit(1);
3657 3658 3659
    }
}

3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676
static void opt_vstats_file (const char *arg)
{
    av_free (vstats_filename);
    vstats_filename=av_strdup (arg);
}

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

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

3677
static int opt_bsf(const char *opt, const char *arg)
3678 3679 3680 3681 3682
{
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
    AVBitStreamFilterContext **bsfp;

    if(!bsfc){
Alex Beregszaszi's avatar
Alex Beregszaszi committed
3683
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3684
        av_exit(1);
3685 3686
    }

3687 3688 3689
    bsfp= *opt == 'v' ? &video_bitstream_filters :
          *opt == 'a' ? &audio_bitstream_filters :
                        &subtitle_bitstream_filters;
3690 3691 3692 3693
    while(*bsfp)
        bsfp= &(*bsfp)->next;

    *bsfp= bsfc;
3694 3695

    return 0;
3696 3697
}

Michael Niedermayer's avatar
Michael Niedermayer committed
3698 3699
static int opt_preset(const char *opt, const char *arg)
{
3700
    FILE *f=NULL;
3701
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3702
    int i;
3703 3704
    const char *base[2]= { getenv("HOME"),
                           FFMPEG_DATADIR,
3705
                         };
Michael Niedermayer's avatar
Michael Niedermayer committed
3706

3707 3708
    for(i=!base[0]; i<2 && !f; i++){
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3709
        f= fopen(filename, "r");
Michael Niedermayer's avatar
Michael Niedermayer committed
3710 3711 3712 3713
        if(!f){
            char *codec_name= *opt == 'v' ? video_codec_name :
                              *opt == 'a' ? audio_codec_name :
                                            subtitle_codec_name;
3714
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3715
            f= fopen(filename, "r");
Michael Niedermayer's avatar
Michael Niedermayer committed
3716
        }
3717
    }
3718 3719
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
              is_dos_path(arg))){
3720 3721
        snprintf(filename, sizeof(filename), arg);
        f= fopen(filename, "r");
3722
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
3723 3724

    if(!f){
3725
        fprintf(stderr, "File for preset '%s' not found\n", arg);
Michael Niedermayer's avatar
Michael Niedermayer committed
3726 3727 3728 3729
        av_exit(1);
    }

    while(!feof(f)){
3730 3731 3732 3733 3734
        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){
3735
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
Michael Niedermayer's avatar
Michael Niedermayer committed
3736 3737
            av_exit(1);
        }
3738 3739 3740 3741 3742 3743
        if(!strcmp(tmp, "acodec")){
            opt_audio_codec(tmp2);
        }else if(!strcmp(tmp, "vcodec")){
            opt_video_codec(tmp2);
        }else if(!strcmp(tmp, "scodec")){
            opt_subtitle_codec(tmp2);
3744
        }else if(opt_default(tmp, tmp2) < 0){
3745
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3746 3747
            av_exit(1);
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
3748 3749 3750 3751 3752 3753 3754
    }

    fclose(f);

    return 0;
}

3755
static const OptionDef options[] = {
3756
    /* main options */
Michael Niedermayer's avatar
Michael Niedermayer committed
3757 3758
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3759
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3760
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
Fabrice Bellard's avatar
Fabrice Bellard committed
3761 3762 3763
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3764
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3765
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3766
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3767
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3768 3769
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3770
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
Fabrice Bellard's avatar
Fabrice Bellard committed
3771
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3772
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
Fabrice Bellard's avatar
Fabrice Bellard committed
3773 3774 3775
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3776
    { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3777
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3778
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3779
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
Fabrice Bellard's avatar
Fabrice Bellard committed
3780
      "add timings for benchmarking" },
3781
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3782
      "dump each input packet" },
3783
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3784
      "when dumping packets, also dump the payload" },
Fabrice Bellard's avatar
Fabrice Bellard committed
3785
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3786
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3787
    { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3788
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3789
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3790
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3791 3792
    { "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", "" },
3793
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3794
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3795
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3796
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3797
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3798
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3799
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3800
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3801 3802

    /* video options */
3803 3804
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3805
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3806
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3807 3808
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3809
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3810 3811 3812 3813
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3814 3815 3816 3817 3818
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3819 3820
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
Måns Rullgård's avatar
Måns Rullgård committed
3821
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3822
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
Fabrice Bellard's avatar
Fabrice Bellard committed
3823
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3824
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3825
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3826
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3827 3828
      "use same video quality as source (implies VBR)" },
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
Stefano Sabatini's avatar
Stefano Sabatini committed
3829
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3830
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3831 3832
      "deinterlace pictures" },
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3833 3834
    { "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" },
3835
#if CONFIG_VHOOK
3836
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3837
#endif
3838 3839
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3840
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3841
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3842
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3843
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3844
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3845
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3846 3847

    /* audio options */
3848
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3849
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3850
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3851 3852
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3853 3854
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3855
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3856
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3857 3858
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3859
    { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3860

3861
    /* subtitle options */
3862
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3863 3864 3865
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3866

3867 3868 3869
    /* grab options */
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3870
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3871 3872

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

3876 3877 3878
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3879

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

3884
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
Fabrice Bellard's avatar
Fabrice Bellard committed
3885 3886 3887
    { NULL, },
};

3888 3889 3890 3891 3892
int main(int argc, char **argv)
{
    int i;
    int64_t ti;

Luca Abeni's avatar
Luca Abeni committed
3893 3894
    avcodec_register_all();
    avdevice_register_all();
3895 3896
    av_register_all();

3897 3898 3899
    if(isatty(STDIN_FILENO))
        url_set_interrupt_cb(decode_interrupt_cb);

3900 3901 3902 3903 3904 3905
    for(i=0; i<CODEC_TYPE_NB; i++){
        avctx_opts[i]= avcodec_alloc_context2(i);
    }
    avformat_opts = av_alloc_format_context();
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);

3906
    show_banner();
3907 3908 3909 3910 3911 3912

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

    /* file converter / grab */
    if (nb_output_files <= 0) {
3913
        fprintf(stderr, "At least one output file must be specified\n");
3914
        av_exit(1);
3915 3916 3917
    }

    if (nb_input_files == 0) {
3918
        fprintf(stderr, "At least one input file must be specified\n");
3919
        av_exit(1);
3920 3921 3922
    }

    ti = getutime();
3923 3924 3925
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
                  stream_maps, nb_stream_maps) < 0)
        av_exit(1);
3926 3927 3928 3929 3930
    ti = getutime() - ti;
    if (do_benchmark) {
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
    }

3931
    return av_exit(0);
3932
}