ffmpeg.c 134 KB
Newer Older
glantau's avatar
merge  
glantau committed
1
/*
2
 * FFmpeg main
bellard's avatar
bellard committed
3
 * Copyright (c) 2000-2003 Fabrice Bellard
glantau's avatar
merge  
glantau 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.
glantau's avatar
merge  
glantau committed
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
glantau's avatar
merge  
glantau 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.
glantau's avatar
merge  
glantau 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
glantau's avatar
merge  
glantau committed
20
 */
21

22 23 24 25 26 27
#include "config.h"
#include <ctype.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <errno.h>
gpoirier's avatar
gpoirier committed
28
#include <signal.h>
michael's avatar
michael committed
29
#include <limits.h>
glantau's avatar
glantau committed
30
#include "avformat.h"
31
#include "swscale.h"
32
#include "framehook.h"
michael's avatar
michael committed
33
#include "opt.h"
34
#include "fifo.h"
35
#include "avstring.h"
glantau's avatar
glantau committed
36

37 38 39 40
#if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
#include <windows.h>
#endif

ramiro's avatar
ramiro committed
41
#if defined(HAVE_TERMIOS_H)
glantau's avatar
merge  
glantau committed
42 43 44 45 46
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <termios.h>
glantau's avatar
glantau committed
47
#include <sys/resource.h>
ramiro's avatar
ramiro committed
48 49
#elif defined(HAVE_CONIO_H)
#include <conio.h>
glantau's avatar
glantau committed
50
#endif
michael's avatar
michael committed
51
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
52
#include <time.h>
glantau's avatar
merge  
glantau committed
53

54
#include "version.h"
bellard's avatar
bellard committed
55 56
#include "cmdutils.h"

michael's avatar
michael committed
57 58 59
#undef NDEBUG
#include <assert.h>

60 61 62
#if !defined(INFINITY) && defined(HUGE_VAL)
#define INFINITY HUGE_VAL
#endif
glantau's avatar
merge  
glantau committed
63

michael's avatar
michael committed
64 65
#undef exit

glantau's avatar
merge  
glantau committed
66 67 68 69
/* select an input stream for an output stream */
typedef struct AVStreamMap {
    int file_index;
    int stream_index;
70 71
    int sync_file_index;
    int sync_stream_index;
glantau's avatar
merge  
glantau committed
72 73
} AVStreamMap;

74 75 76 77 78 79
/** select an input file for an output file */
typedef struct AVMetaDataMap {
    int out_file;
    int in_file;
} AVMetaDataMap;

glantau's avatar
merge  
glantau committed
80 81
extern const OptionDef options[];

82
static void show_help(void);
83
static void opt_show_license(void);
84
static int opt_default(const char *opt, const char *arg);
glantau's avatar
merge  
glantau committed
85 86 87 88

#define MAX_FILES 20

static AVFormatContext *input_files[MAX_FILES];
michael's avatar
michael committed
89
static int64_t input_files_ts_offset[MAX_FILES];
glantau's avatar
merge  
glantau committed
90 91 92 93 94 95 96 97
static int nb_input_files = 0;

static AVFormatContext *output_files[MAX_FILES];
static int nb_output_files = 0;

static AVStreamMap stream_maps[MAX_FILES];
static int nb_stream_maps;

98 99 100
static AVMetaDataMap meta_data_maps[MAX_FILES];
static int nb_meta_data_maps;

101 102
static AVInputFormat *file_iformat;
static AVOutputFormat *file_oformat;
michael's avatar
michael committed
103 104
static int frame_width  = 0;
static int frame_height = 0;
romansh's avatar
 
romansh committed
105
static float frame_aspect_ratio = 0;
michael's avatar
michael committed
106
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
107 108 109 110 111
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 */
112 113 114 115
static int frame_topBand  = 0;
static int frame_bottomBand = 0;
static int frame_leftBand  = 0;
static int frame_rightBand = 0;
116
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
117
static AVRational frame_rate = (AVRational) {25,1};
118
static float video_qscale = 0;
119
static int video_qdiff = 3;
120 121
static uint16_t *intra_matrix = NULL;
static uint16_t *inter_matrix = NULL;
122
#if 0 //experimental, (can be removed)
michaelni's avatar
michaelni committed
123 124 125
static float video_rc_qsquish=1.0;
static float video_rc_qmod_amp=0;
static int video_rc_qmod_freq=0;
126
#endif
michaelni's avatar
michaelni committed
127 128
static char *video_rc_override_string=NULL;
static char *video_rc_eq="tex^qComp";
glantau's avatar
merge  
glantau committed
129
static int video_disable = 0;
130
static int video_discard = 0;
131
static char *video_codec_name = NULL;
michael's avatar
michael committed
132
static int video_codec_tag = 0;
glantau's avatar
merge  
glantau committed
133
static int same_quality = 0;
134
static int do_deinterlace = 0;
michaelni's avatar
michaelni committed
135
static int strict = 0;
michael's avatar
michael committed
136
static int top_field_first = -1;
137
static int me_threshold = 0;
michael's avatar
-cbp  
michael committed
138
static int intra_dc_precision = 8;
139
static int loop_input = 0;
140
static int loop_output = AVFMT_NOOUTPUTLOOP;
141
static int qp_hist = 0;
glantau's avatar
merge  
glantau committed
142 143 144

static int intra_only = 0;
static int audio_sample_rate = 44100;
145 146
#define QSCALE_NONE -99999
static float audio_qscale = QSCALE_NONE;
glantau's avatar
merge  
glantau committed
147 148
static int audio_disable = 0;
static int audio_channels = 1;
149
static char  *audio_codec_name = NULL;
michael's avatar
michael committed
150
static int audio_codec_tag = 0;
151 152
static char *audio_language = NULL;

153
static int subtitle_disable = 0;
154
static char *subtitle_codec_name = NULL;
155
static char *subtitle_language = NULL;
glantau's avatar
merge  
glantau committed
156

157 158
static float mux_preload= 0.5;
static float mux_max_delay= 0.7;
159

kabi's avatar
kabi committed
160
static int64_t recording_time = 0;
161
static int64_t start_time = 0;
romansh's avatar
 
romansh committed
162
static int64_t rec_timestamp = 0;
michael's avatar
michael committed
163
static int64_t input_ts_offset = 0;
glantau's avatar
merge  
glantau committed
164 165 166 167 168
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;
169
static char *str_album = NULL;
glantau's avatar
glantau committed
170
static int do_benchmark = 0;
171
static int do_hex_dump = 0;
172
static int do_pkt_dump = 0;
173
static int do_psnr = 0;
174 175
static int do_pass = 0;
static char *pass_logfilename = NULL;
176 177
static int audio_stream_copy = 0;
static int video_stream_copy = 0;
178
static int subtitle_stream_copy = 0;
michael's avatar
michael committed
179 180
static int video_sync_method= 1;
static int audio_sync_method= 0;
michael's avatar
michael committed
181
static float audio_drift_threshold= 0.1;
182
static int copy_ts= 0;
183
static int opt_shortest = 0; //
184
static int video_global_header = 0;
benoit's avatar
 
benoit committed
185 186
static char *vstats_filename;
static FILE *fvstats;
187

188 189
static int rate_emu = 0;

190
static int  video_channel = 0;
191
static char *video_standard;
192

193
static int audio_volume = 256;
194

195
static int using_stdin = 0;
196
static int using_vhook = 0;
197
static int verbose = 1;
198
static int thread_count= 1;
199
static int q_pressed = 0;
200 201 202
static int64_t video_size = 0;
static int64_t audio_size = 0;
static int64_t extra_size = 0;
michael's avatar
michael committed
203 204
static int nb_frames_dup = 0;
static int nb_frames_drop = 0;
205
static int input_sync;
206
static uint64_t limit_filesize = 0; //
207

208
static int pgmyuv_compatibility_hack=0;
209
static float dts_delta_threshold = 10;
210

211 212
static int sws_flags = SWS_BICUBIC;

benoit's avatar
benoit committed
213 214 215 216 217 218
static const char **opt_names;
static int opt_name_count;
static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
static AVFormatContext *avformat_opts;
static struct SwsContext *sws_opts;
static int64_t timer_start;
michael's avatar
michael committed
219

220 221 222
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
223

224
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
glantau's avatar
merge  
glantau committed
225

226 227
struct AVInputStream;

glantau's avatar
merge  
glantau committed
228 229 230 231 232
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 */
233 234 235 236
    int encoding_needed;     /* true if encoding needed for this stream */
    int frame_number;
    /* input pts and corresponding output pts
       for A/V sync */
237 238
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
    struct AVInputStream *sync_ist; /* input stream to sync against */
239
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
glantau's avatar
merge  
glantau committed
240
    /* video only */
241
    int video_resample;
242
    AVFrame pict_tmp;      /* temporary image for resampling */
243 244
    struct SwsContext *img_resample_ctx; /* for image resampling */
    int resample_height;
245

246
    int video_crop;
247 248
    int topBand;             /* cropping area sizes */
    int leftBand;
249

250
    int video_pad;
251 252 253 254
    int padtop;              /* padding area sizes */
    int padbottom;
    int padleft;
    int padright;
255

glantau's avatar
merge  
glantau committed
256 257 258
    /* audio only */
    int audio_resample;
    ReSampleContext *resample; /* for audio resampling */
259
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
260
    FILE *logfile;
glantau's avatar
merge  
glantau committed
261 262 263 264 265 266 267 268
} 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' */
kabi's avatar
kabi committed
269
    int64_t sample_index;      /* current sample */
270 271 272

    int64_t       start;     /* time when read started */
    unsigned long frame;     /* current frame */
273 274
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
                                is not defined */
romansh's avatar
 
romansh committed
275
    int64_t       pts;       /* current pts */
michael's avatar
michael committed
276
    int is_start;            /* is 1 at the start and after a discontinuity */
glantau's avatar
merge  
glantau committed
277 278 279 280 281 282
} 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 */
283
    int nb_streams;       /* nb streams we are aware of */
glantau's avatar
merge  
glantau committed
284 285
} AVInputFile;

286
#ifdef HAVE_TERMIOS_H
glantau's avatar
glantau committed
287

glantau's avatar
merge  
glantau committed
288 289
/* init terminal so that we can grab keys */
static struct termios oldtty;
gpoirier's avatar
gpoirier committed
290
#endif
glantau's avatar
merge  
glantau committed
291 292 293

static void term_exit(void)
{
294
#ifdef HAVE_TERMIOS_H
glantau's avatar
merge  
glantau committed
295
    tcsetattr (0, TCSANOW, &oldtty);
gpoirier's avatar
gpoirier committed
296
#endif
glantau's avatar
merge  
glantau committed
297 298
}

299 300 301 302 303 304 305 306 307
static volatile sig_atomic_t received_sigterm = 0;

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

glantau's avatar
merge  
glantau committed
308 309
static void term_init(void)
{
310
#ifdef HAVE_TERMIOS_H
glantau's avatar
merge  
glantau committed
311 312 313 314 315 316 317 318 319 320 321 322 323
    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;
324

glantau's avatar
merge  
glantau committed
325
    tcsetattr (0, TCSANOW, &tty);
gpoirier's avatar
gpoirier committed
326 327
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
#endif
glantau's avatar
merge  
glantau committed
328

329 330 331 332 333
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
    /*
    register a function to be called at normal program termination
    */
glantau's avatar
merge  
glantau committed
334
    atexit(term_exit);
335 336 337
#ifdef CONFIG_BEOS_NETSERVER
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
#endif
glantau's avatar
merge  
glantau committed
338 339 340 341 342
}

/* read a key without blocking */
static int read_key(void)
{
ramiro's avatar
ramiro committed
343
#if defined(HAVE_TERMIOS_H)
344
    int n = 1;
glantau's avatar
merge  
glantau committed
345
    unsigned char ch;
346 347
#ifndef CONFIG_BEOS_NETSERVER
    struct timeval tv;
glantau's avatar
merge  
glantau committed
348 349 350 351 352 353 354
    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);
355
#endif
glantau's avatar
merge  
glantau committed
356
    if (n > 0) {
357 358
        n = read(0, &ch, 1);
        if (n == 1)
glantau's avatar
merge  
glantau committed
359
            return ch;
360 361

        return n;
glantau's avatar
merge  
glantau committed
362
    }
ramiro's avatar
ramiro committed
363 364 365
#elif defined(HAVE_CONIO_H)
    if(kbhit())
        return(getch());
gpoirier's avatar
gpoirier committed
366
#endif
glantau's avatar
merge  
glantau committed
367 368 369
    return -1;
}

370 371 372 373 374
static int decode_interrupt_cb(void)
{
    return q_pressed || (q_pressed = read_key() == 'q');
}

375
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
glantau's avatar
merge  
glantau committed
376
{
377
    int i, err;
glantau's avatar
merge  
glantau committed
378 379
    AVFormatContext *ic;

380 381 382
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
    if (err < 0)
        return err;
glantau's avatar
merge  
glantau committed
383 384 385 386
    /* copy stream format */
    s->nb_streams = ic->nb_streams;
    for(i=0;i<ic->nb_streams;i++) {
        AVStream *st;
michaelni's avatar
michaelni committed
387

388
        // FIXME: a more elegant solution is needed
389
        st = av_mallocz(sizeof(AVStream));
glantau's avatar
merge  
glantau committed
390
        memcpy(st, ic->streams[i], sizeof(AVStream));
391 392
        st->codec = avcodec_alloc_context();
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
glantau's avatar
merge  
glantau committed
393 394 395 396 397 398 399
        s->streams[i] = st;
    }

    av_close_input_file(ic);
    return 0;
}

400 401 402 403
static double
get_sync_ipts(const AVOutputStream *ost)
{
    const AVInputStream *ist = ost->sync_ist;
404
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
405 406
}

407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
    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);
        if(a){
            av_free_packet(pkt);
            new_pkt.destruct= av_destruct_packet;
        }
        *pkt= new_pkt;

        bsfc= bsfc->next;
    }

    av_interleaved_write_frame(s, pkt);
}

426
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
glantau's avatar
merge  
glantau committed
427

428 429
static void do_audio_out(AVFormatContext *s,
                         AVOutputStream *ost,
glantau's avatar
merge  
glantau committed
430 431 432
                         AVInputStream *ist,
                         unsigned char *buf, int size)
{
kabi's avatar
kabi committed
433
    uint8_t *buftmp;
434 435
    static uint8_t *audio_buf = NULL;
    static uint8_t *audio_out = NULL;
michaelni's avatar
10l  
michaelni committed
436
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
437

glantau's avatar
merge  
glantau committed
438
    int size_out, frame_bytes, ret;
439
    AVCodecContext *enc= ost->st->codec;
glantau's avatar
merge  
glantau committed
440

441 442 443 444
    /* SC: dynamic allocation of buffers */
    if (!audio_buf)
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
    if (!audio_out)
michaelni's avatar
10l  
michaelni committed
445
        audio_out = av_malloc(audio_out_size);
446 447 448
    if (!audio_buf || !audio_out)
        return;               /* Should signal an error ! */

michael's avatar
michael committed
449
    if(audio_sync_method){
450
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
451
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
452 453
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
michael's avatar
michael committed
454

michael's avatar
michael committed
455 456
        //FIXME resample delay
        if(fabs(delta) > 50){
michael's avatar
michael committed
457
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
michael's avatar
michael committed
458
                if(byte_delta < 0){
459
                    byte_delta= FFMAX(byte_delta, -size);
michael's avatar
michael committed
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
                    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){
reimar's avatar
reimar committed
484
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
michael's avatar
michael committed
485 486 487
                assert(ost->audio_resample);
                if(verbose > 2)
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
488
//                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
michael's avatar
michael committed
489 490
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
            }
491
        }
michael's avatar
michael committed
492
    }else
493
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
494
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
glantau's avatar
merge  
glantau committed
495 496 497

    if (ost->audio_resample) {
        buftmp = audio_buf;
498
        size_out = audio_resample(ost->resample,
glantau's avatar
merge  
glantau committed
499
                                  (short *)buftmp, (short *)buf,
500
                                  size / (ist->st->codec->channels * 2));
glantau's avatar
merge  
glantau committed
501 502 503 504 505 506 507
        size_out = size_out * enc->channels * 2;
    } else {
        buftmp = buf;
        size_out = size;
    }

    /* now encode as many frames as possible */
508
    if (enc->frame_size > 1) {
glantau's avatar
merge  
glantau committed
509
        /* output resampled raw samples */
510
        av_fifo_write(&ost->fifo, buftmp, size_out);
glantau's avatar
merge  
glantau committed
511 512

        frame_bytes = enc->frame_size * 2 * enc->channels;
513

514
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
515 516 517
            AVPacket pkt;
            av_init_packet(&pkt);

518
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
519
                                       (short *)audio_buf);
520
            audio_size += ret;
521 522 523
            pkt.stream_index= ost->index;
            pkt.data= audio_out;
            pkt.size= ret;
michael's avatar
michael committed
524
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
525
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
526
            pkt.flags |= PKT_FLAG_KEY;
527
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
528

michael's avatar
michael committed
529
            ost->sync_opts += enc->frame_size;
glantau's avatar
merge  
glantau committed
530 531
        }
    } else {
532 533
        AVPacket pkt;
        av_init_packet(&pkt);
michael's avatar
michael committed
534

535
        ost->sync_opts += size_out / (2 * enc->channels);
michael's avatar
michael committed
536

537 538 539
        /* output a pcm frame */
        /* XXX: change encoding codec API to avoid this ? */
        switch(enc->codec->id) {
540 541 542 543 544 545 546 547 548 549 550 551 552
        case CODEC_ID_PCM_S32LE:
        case CODEC_ID_PCM_S32BE:
        case CODEC_ID_PCM_U32LE:
        case CODEC_ID_PCM_U32BE:
            size_out = size_out << 1;
            break;
        case CODEC_ID_PCM_S24LE:
        case CODEC_ID_PCM_S24BE:
        case CODEC_ID_PCM_U24LE:
        case CODEC_ID_PCM_U24BE:
        case CODEC_ID_PCM_S24DAUD:
            size_out = size_out / 2 * 3;
            break;
553 554 555 556 557 558 559 560 561
        case CODEC_ID_PCM_S16LE:
        case CODEC_ID_PCM_S16BE:
        case CODEC_ID_PCM_U16LE:
        case CODEC_ID_PCM_U16BE:
            break;
        default:
            size_out = size_out >> 1;
            break;
        }
562
        ret = avcodec_encode_audio(enc, audio_out, size_out,
563
                                   (short *)buftmp);
564
        audio_size += ret;
565 566 567
        pkt.stream_index= ost->index;
        pkt.data= audio_out;
        pkt.size= ret;
michael's avatar
michael committed
568
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
569
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
570
        pkt.flags |= PKT_FLAG_KEY;
571
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
glantau's avatar
merge  
glantau committed
572 573 574
    }
}

575 576 577 578 579
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
{
    AVCodecContext *dec;
    AVPicture *picture2;
    AVPicture picture_tmp;
kabi's avatar
kabi committed
580
    uint8_t *buf = 0;
581

582
    dec = ist->st->codec;
583 584

    /* deinterlace : must be done before any resize */
585
    if (do_deinterlace || using_vhook) {
586 587 588 589 590 591 592
        int size;

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

594 595 596
        picture2 = &picture_tmp;
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);

michaelni's avatar
10l  
michaelni committed
597
        if (do_deinterlace){
598
            if(avpicture_deinterlace(picture2, picture,
michaelni's avatar
10l  
michaelni committed
599 600 601 602 603 604 605
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
                /* if error, do not deinterlace */
                av_free(buf);
                buf = NULL;
                picture2 = picture;
            }
        } else {
606
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
607
        }
608 609 610 611
    } else {
        picture2 = picture;
    }

612
    if (ENABLE_VHOOK)
diego's avatar
diego committed
613 614
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
                           1000000 * ist->pts / AV_TIME_BASE);
615 616 617 618 619 620

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

621 622
/* we begin to correct av delay at this threshold */
#define AV_DELAY_MAX 0.100
glantau's avatar
merge  
glantau committed
623

624 625
static void do_subtitle_out(AVFormatContext *s,
                            AVOutputStream *ost,
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
                            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");
        return;
    }

641
    enc = ost->st->codec;
642 643 644 645 646 647 648 649 650 651 652 653 654 655

    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++) {
656
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
657
                                                    subtitle_out_max_size, sub);
658

659 660 661 662
        av_init_packet(&pkt);
        pkt.stream_index = ost->index;
        pkt.data = subtitle_out;
        pkt.size = subtitle_out_size;
663
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
664 665 666 667 668 669 670 671
        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;
        }
672
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
673 674 675
    }
}

676
static int bit_buffer_size= 1024*256;
677
static uint8_t *bit_buffer= NULL;
678

679 680
static void do_video_out(AVFormatContext *s,
                         AVOutputStream *ost,
glantau's avatar
merge  
glantau committed
681
                         AVInputStream *ist,
682
                         AVFrame *in_picture,
michael's avatar
michael committed
683
                         int *frame_size)
glantau's avatar
merge  
glantau committed
684
{
685
    int nb_frames, i, ret;
686
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
687
    AVFrame picture_crop_temp, picture_pad_temp;
688
    AVCodecContext *enc, *dec;
689

690
    avcodec_get_frame_defaults(&picture_crop_temp);
691
    avcodec_get_frame_defaults(&picture_pad_temp);
692

693 694
    enc = ost->st->codec;
    dec = ist->st->codec;
glantau's avatar
merge  
glantau committed
695

696 697 698
    /* by default, we output a single frame */
    nb_frames = 1;

699 700
    *frame_size = 0;

michael's avatar
michael committed
701
    if(video_sync_method){
702
        double vdelta;
703
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
704 705 706 707
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
        if (vdelta < -1.1)
            nb_frames = 0;
        else if (vdelta > 1.1)
michael's avatar
michael committed
708
            nb_frames = lrintf(vdelta);
709
//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);
710 711 712 713
        if (nb_frames == 0){
            ++nb_frames_drop;
            if (verbose>2)
                fprintf(stderr, "*** drop!\n");
michael's avatar
michael committed
714 715
        }else if (nb_frames > 1) {
            nb_frames_dup += nb_frames;
716
            if (verbose>2)
michael's avatar
michael committed
717
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
718 719
        }
    }else
720
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
romansh's avatar
 
romansh committed
721

michael's avatar
michael committed
722
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
723
    if (nb_frames <= 0)
glantau's avatar
merge  
glantau committed
724
        return;
725

726
    if (ost->video_crop) {
727
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
728
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
diego's avatar
diego committed
729
            return;
730 731
        }
        formatted_picture = &picture_crop_temp;
732 733
    } else {
        formatted_picture = in_picture;
734 735 736 737 738 739 740 741
    }

    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) {
742
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
743
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
diego's avatar
diego committed
744
                return;
745 746 747 748 749
            }
            resampling_dst = &picture_pad_temp;
        }
    }

glantau's avatar
merge  
glantau committed
750
    if (ost->video_resample) {
751
        padding_src = NULL;
752
        final_picture = &ost->pict_tmp;
753 754
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
755
    }
756 757

    if (ost->video_pad) {
758
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
759 760
                enc->height, enc->width, enc->pix_fmt,
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
glantau's avatar
merge  
glantau committed
761
    }
762

glantau's avatar
merge  
glantau committed
763
    /* duplicates frame if needed */
764
    for(i=0;i<nb_frames;i++) {
765 766 767 768
        AVPacket pkt;
        av_init_packet(&pkt);
        pkt.stream_index= ost->index;

769 770 771 772
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
            /* raw pictures are written as AVPicture structure to
               avoid any copies. We support temorarily the older
               method. */
romansh's avatar
 
romansh committed
773
            AVFrame* old_frame = enc->coded_frame;
774
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
775 776
            pkt.data= (uint8_t *)final_picture;
            pkt.size=  sizeof(AVPicture);
michael's avatar
michael committed
777
            if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
778
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
779 780 781
            if(dec->coded_frame && dec->coded_frame->key_frame)
                pkt.flags |= PKT_FLAG_KEY;

782
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
783
            enc->coded_frame = old_frame;
784
        } else {
michaelni's avatar
michaelni committed
785
            AVFrame big_picture;
786 787

            big_picture= *final_picture;
788 789 790
            /* better than nothing: use input picture interlaced
               settings */
            big_picture.interlaced_frame = in_picture->interlaced_frame;
791
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
michael's avatar
michael committed
792 793 794
                if(top_field_first == -1)
                    big_picture.top_field_first = in_picture->top_field_first;
                else
michael's avatar
michael committed
795
                    big_picture.top_field_first = top_field_first;
michael's avatar
michael committed
796
            }
797

glantau's avatar
merge  
glantau committed
798 799 800
            /* handles sameq here. This is not correct because it may
               not be a global option */
            if (same_quality) {
michaelni's avatar
michaelni committed
801 802 803
                big_picture.quality = ist->st->quality;
            }else
                big_picture.quality = ost->st->quality;
804 805
            if(!me_threshold)
                big_picture.pict_type = 0;
806
//            big_picture.pts = AV_NOPTS_VALUE;
michael's avatar
michael committed
807 808
            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);
809
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
810
            ret = avcodec_encode_video(enc,
811
                                       bit_buffer, bit_buffer_size,
michaelni's avatar
michaelni committed
812
                                       &big_picture);
takis's avatar
takis committed
813 814 815 816
            if (ret == -1) {
                fprintf(stderr, "Video encoding failed\n");
                exit(1);
            }
817
            //enc->frame_number = enc->real_pict_num;
michael's avatar
michael committed
818
            if(ret>0){
819
                pkt.data= bit_buffer;
820
                pkt.size= ret;
michael's avatar
michael committed
821
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
822
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
823
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
michael's avatar
michael committed
824 825
   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);*/
826

827 828
                if(enc->coded_frame && enc->coded_frame->key_frame)
                    pkt.flags |= PKT_FLAG_KEY;
829
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
830 831 832 833 834 835 836 837
                *frame_size = ret;
                //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);
                }
838
            }
glantau's avatar
merge  
glantau committed
839
        }
840
        ost->sync_opts++;
841
        ost->frame_number++;
glantau's avatar
merge  
glantau committed
842 843 844
    }
}

845 846
static double psnr(double d){
    if(d==0) return INFINITY;
847
    return -10.0*log(d)/log(10.0);
848 849
}

850
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
851
                           int frame_size)
852 853 854 855
{
    AVCodecContext *enc;
    int frame_number;
    double ti1, bitrate, avg_bitrate;
856

benoit's avatar
 
benoit committed
857
    /* this is executed just the first time do_video_stats is called */
benoit's avatar
 
benoit committed
858
    if (!fvstats) {
benoit's avatar
 
benoit committed
859
        fvstats = fopen(vstats_filename, "w");
benoit's avatar
 
benoit committed
860 861 862 863 864 865
        if (!fvstats) {
            perror("fopen");
            exit(1);
        }
    }

866
    enc = ost->st->codec;
867
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
868
        frame_number = ost->frame_number;
869
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
870
        if (enc->flags&CODEC_FLAG_PSNR)
michaelni's avatar
michaelni committed
871
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
872

873
        fprintf(fvstats,"f_size= %6d ", frame_size);
874
        /* compute pts value */
michael's avatar
michael committed
875
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
876 877
        if (ti1 < 0.01)
            ti1 = 0.01;
878

michael's avatar
michael committed
879
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
880
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
881
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
882
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
883
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
884
    }
885 886
}

887
static void print_report(AVFormatContext **output_files,
888 889
                         AVOutputStream **ost_table, int nb_ostreams,
                         int is_last_report)
890 891 892 893
{
    char buf[1024];
    AVOutputStream *ost;
    AVFormatContext *oc, *os;
kabi's avatar
kabi committed
894
    int64_t total_size;
895 896 897
    AVCodecContext *enc;
    int frame_number, vid, i;
    double bitrate, ti1, pts;
kabi's avatar
kabi committed
898
    static int64_t last_time = -1;
899
    static int qp_histogram[52];
900

901
    if (!is_last_report) {
kabi's avatar
kabi committed
902
        int64_t cur_time;
903 904 905 906 907
        /* display the report every 0.5 seconds */
        cur_time = av_gettime();
        if (last_time == -1) {
            last_time = cur_time;
            return;
908
        }
909 910 911 912 913
        if ((cur_time - last_time) < 500000)
            return;
        last_time = cur_time;
    }

914

915 916
    oc = output_files[0];

917 918 919
    total_size = url_fsize(&oc->pb);
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
        total_size= url_ftell(&oc->pb);
920

921 922 923 924 925 926
    buf[0] = '\0';
    ti1 = 1e10;
    vid = 0;
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        os = output_files[ost->file_index];
927
        enc = ost->st->codec;
928
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
929
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
930
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
931
        }
932
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
933 934
            float t = (av_gettime()-timer_start) / 1000000.0;

935
            frame_number = ost->frame_number;
936 937 938
            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,
                     enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
939
            if(is_last_report)
940
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
941 942 943 944 945 946 947 948
            if(qp_hist && enc->coded_frame){
                int j;
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
                    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)));
            }
949 950 951 952 953
            if (enc->flags&CODEC_FLAG_PSNR){
                int j;
                double error, error_sum=0;
                double scale, scale_sum=0;
                char type[3]= {'Y','U','V'};
954
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
955 956 957 958 959 960 961 962 963 964 965
                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;
966
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
967
                }
968
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
969
            }
970 971 972
            vid = 1;
        }
        /* compute min output value */
alex's avatar
alex committed
973
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
974
        if ((pts < ti1) && (pts > 0))
975 976 977 978
            ti1 = pts;
    }
    if (ti1 < 0.01)
        ti1 = 0.01;
979

980 981
    if (verbose || is_last_report) {
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
982 983

        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
984 985
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
            (double)total_size / 1024, ti1, bitrate);
michael's avatar
michael committed
986

987 988 989
        if (verbose > 1)
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
                  nb_frames_dup, nb_frames_drop);
990

991 992 993
        if (verbose >= 0)
            fprintf(stderr, "%s    \r", buf);

994 995
        fflush(stderr);
    }
996

997 998
    if (is_last_report && verbose >= 0){
        int64_t raw= audio_size + video_size + extra_size;
999
        fprintf(stderr, "\n");
1000 1001 1002 1003 1004 1005 1006
        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
        );
    }
1007 1008
}

1009 1010 1011
/* pkt = NULL means EOF (needed to flush decoder buffers) */
static int output_packet(AVInputStream *ist, int ist_index,
                         AVOutputStream **ost_table, int nb_ostreams,
1012
                         const AVPacket *pkt)
1013 1014 1015 1016 1017 1018 1019 1020 1021
{
    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;
1022
    static unsigned int samples_size= 0;
1023
    static short *samples= NULL;
1024 1025
    AVSubtitle subtitle, *subtitle_to_free;
    int got_subtitle;
1026

michael's avatar
michael committed
1027 1028 1029
    if(!pkt){
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
michael's avatar
michael committed
1030
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1031
    } else {
1032
//        assert(ist->pts == ist->next_pts);
1033
    }
1034

1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
    if (pkt == NULL) {
        /* EOF handling */
        ptr = NULL;
        len = 0;
        goto handle_eof;
    }

    len = pkt->size;
    ptr = pkt->data;
    while (len > 0) {
    handle_eof:
        /* decode the packet if needed */
        data_buf = NULL; /* fail safe */
        data_size = 0;
1049
        subtitle_to_free = NULL;
1050
        if (ist->decoding_needed) {
1051
            switch(ist->st->codec->codec_type) {
michael's avatar
michael committed
1052
            case CODEC_TYPE_AUDIO:{
1053
                if(pkt)
1054
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
michael's avatar
michael committed
1055
                data_size= samples_size;
1056 1057
                    /* XXX: could avoid copy if PCM 16 bits with same
                       endianness as CPU */
michael's avatar
michael committed
1058
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
                                           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;
1071
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1072
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
michael's avatar
michael committed
1073
                break;}
1074
            case CODEC_TYPE_VIDEO:
1075
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1076
                    /* XXX: allocate picture correctly */
1077 1078
                    avcodec_get_frame_defaults(&picture);

1079
                    ret = avcodec_decode_video(ist->st->codec,
1080 1081
                                               &picture, &got_picture, ptr, len);
                    ist->st->quality= picture.quality;
1082
                    if (ret < 0)
1083 1084 1085 1086 1087
                        goto fail_decode;
                    if (!got_picture) {
                        /* no picture yet */
                        goto discard_packet;
                    }
1088
                    if (ist->st->codec->time_base.num != 0) {
1089
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1090 1091
                                          ist->st->codec->time_base.num) /
                            ist->st->codec->time_base.den;
1092 1093 1094
                    }
                    len = 0;
                    break;
1095
            case CODEC_TYPE_SUBTITLE:
1096
                ret = avcodec_decode_subtitle(ist->st->codec,
1097 1098
                                              &subtitle, &got_subtitle, ptr, len);
                if (ret < 0)
1099
                    goto fail_decode;
1100 1101
                if (!got_subtitle) {
                    goto discard_packet;
1102
                }
1103 1104 1105 1106 1107 1108 1109
                subtitle_to_free = &subtitle;
                len = 0;
                break;
            default:
                goto fail_decode;
            }
        } else {
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
            switch(ist->st->codec->codec_type) {
            case CODEC_TYPE_AUDIO:
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
                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;
1120
                }
1121
                break;
1122
            }
1123 1124 1125 1126 1127
            data_buf = ptr;
            data_size = len;
            ret = len;
            len = 0;
        }
1128

1129 1130 1131 1132 1133
        buffer_to_free = NULL;
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
            pre_process_video_frame(ist, (AVPicture *)&picture,
                                    &buffer_to_free);
        }
1134

1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
        // 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;
1145 1146
                }
            }
1147
        }
1148

1149 1150 1151 1152 1153 1154
        /* frame rate emulation */
        if (ist->st->codec->rate_emu) {
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
            int64_t now = av_gettime() - ist->start;
            if (pts > now)
                usleep(pts - now);
1155

1156 1157
            ist->frame++;
        }
1158 1159

#if 0
1160 1161 1162 1163 1164 1165 1166 1167 1168
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
           is the one of the next displayed one */
        /* XXX: add mpeg4 too ? */
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
            if (ist->st->codec->pict_type != B_TYPE) {
                int64_t tmp;
                tmp = ist->last_ip_pts;
                ist->last_ip_pts  = ist->frac_pts.val;
                ist->frac_pts.val = tmp;
1169
            }
1170
        }
1171
#endif
1172 1173 1174 1175 1176
        /* 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;
1177

1178 1179 1180
                ost = ost_table[i];
                if (ost->source_index == ist_index) {
                    os = output_files[ost->file_index];
1181 1182

#if 0
1183 1184 1185 1186
                    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));
1187
#endif
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
                    /* 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);
                            video_size += frame_size;
benoit's avatar
 
benoit committed
1199
                            if (vstats_filename && frame_size)
1200 1201 1202 1203 1204 1205 1206
                                do_video_stats(os, ost, frame_size);
                            break;
                        case CODEC_TYPE_SUBTITLE:
                            do_subtitle_out(os, ost, ist, &subtitle,
                                            pkt->pts);
                            break;
                        default:
1207
                            abort();
1208 1209 1210 1211 1212 1213
                        }
                    } else {
                        AVFrame avframe; //FIXME/XXX remove this
                        AVPacket opkt;
                        av_init_packet(&opkt);

1214 1215 1216
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
                            continue;

1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
                        /* 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)
1233
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1234 1235 1236 1237
                        else
                            opkt.pts= AV_NOPTS_VALUE;

                            if (pkt->dts == AV_NOPTS_VALUE)
1238
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1239
                            else
1240 1241
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);

1242
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
                        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;

                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
                        ost->st->codec->frame_number++;
                        ost->frame_number++;
                        av_free_packet(&opkt);
1253 1254
                    }
                }
1255 1256 1257 1258 1259 1260 1261 1262
            }
        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++) {
                    av_free(subtitle_to_free->rects[i].bitmap);
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1263
                }
1264
                av_freep(&subtitle_to_free->rects);
1265
            }
1266 1267
            subtitle_to_free->num_rects = 0;
            subtitle_to_free = NULL;
1268
        }
1269
    }
1270
 discard_packet:
1271 1272
    if (pkt == NULL) {
        /* EOF handling */
1273

1274 1275 1276
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            if (ost->source_index == ist_index) {
1277
                AVCodecContext *enc= ost->st->codec;
1278
                os = output_files[ost->file_index];
1279

1280
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1281
                    continue;
1282
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1283 1284 1285 1286 1287
                    continue;

                if (ost->encoding_needed) {
                    for(;;) {
                        AVPacket pkt;
1288
                        int fifo_bytes;
1289 1290
                        av_init_packet(&pkt);
                        pkt.stream_index= ost->index;
1291

1292
                        switch(ost->st->codec->codec_type) {
1293
                        case CODEC_TYPE_AUDIO:
1294
                            fifo_bytes = av_fifo_size(&ost->fifo);
1295 1296 1297 1298 1299
                            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);
1300
                                if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1301 1302 1303
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
                                }
                                enc->frame_size = fs_tmp;
michael's avatar
michael committed
1304 1305
                            }
                            if(ret <= 0) {
1306 1307
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
                            }
1308 1309 1310 1311
                            audio_size += ret;
                            pkt.flags |= PKT_FLAG_KEY;
                            break;
                        case CODEC_TYPE_VIDEO:
1312
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
                            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;
                        }
1323

1324 1325
                        if(ret<=0)
                            break;
1326
                        pkt.data= bit_buffer;
1327
                        pkt.size= ret;
michael's avatar
michael committed
1328
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
1329
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1330
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1331 1332 1333 1334 1335
                    }
                }
            }
        }
    }
1336

1337 1338 1339 1340 1341
    return 0;
 fail_decode:
    return -1;
}

1342 1343 1344 1345 1346 1347 1348
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);
}
1349

glantau's avatar
merge  
glantau committed
1350 1351 1352 1353 1354 1355 1356 1357 1358
/*
 * 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)
{
romansh's avatar
 
romansh committed
1359
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
glantau's avatar
merge  
glantau committed
1360 1361 1362 1363
    AVFormatContext *is, *os;
    AVCodecContext *codec, *icodec;
    AVOutputStream *ost, **ost_table = NULL;
    AVInputStream *ist, **ist_table = NULL;
glantau's avatar
glantau committed
1364
    AVInputFile *file_table;
1365
    int key;
1366
    int want_sdp = 1;
glantau's avatar
glantau committed
1367

1368
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
glantau's avatar
glantau committed
1369 1370
    if (!file_table)
        goto fail;
1371

glantau's avatar
merge  
glantau committed
1372 1373 1374 1375 1376
    /* input stream init */
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        file_table[i].ist_index = j;
1377
        file_table[i].nb_streams = is->nb_streams;
glantau's avatar
merge  
glantau committed
1378 1379 1380 1381 1382 1383
        j += is->nb_streams;
    }
    nb_istreams = j;

    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
    if (!ist_table)
glantau's avatar
glantau committed
1384
        goto fail;
1385

glantau's avatar
merge  
glantau committed
1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
    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) */
1402

1403
            if (ist->st->codec->rate_emu) {
1404 1405 1406
                ist->start = av_gettime();
                ist->frame = 0;
            }
glantau's avatar
merge  
glantau committed
1407 1408 1409 1410 1411 1412 1413
        }
    }

    /* output stream init */
    nb_ostreams = 0;
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
1414 1415 1416 1417
        if (!os->nb_streams) {
            fprintf(stderr, "Output file does not contain any stream\n");
            exit(1);
        }
glantau's avatar
merge  
glantau committed
1418 1419 1420 1421 1422 1423 1424
        nb_ostreams += os->nb_streams;
    }
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
        exit(1);
    }

1425 1426 1427 1428
    /* 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;
1429

1430 1431 1432 1433 1434
        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);
            exit(1);
        }
1435 1436 1437 1438 1439 1440 1441
        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);
            exit(1);
        }
1442
    }
1443

glantau's avatar
merge  
glantau committed
1444 1445 1446 1447 1448 1449 1450 1451 1452
    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;
    }
1453

glantau's avatar
merge  
glantau committed
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
    n = 0;
    for(k=0;k<nb_output_files;k++) {
        os = output_files[k];
        for(i=0;i<os->nb_streams;i++) {
            int found;
            ost = ost_table[n++];
            ost->file_index = k;
            ost->index = i;
            ost->st = os->streams[i];
            if (nb_stream_maps > 0) {
1464
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
glantau's avatar
merge  
glantau committed
1465
                    stream_maps[n-1].stream_index;
1466

1467
                /* Sanity check that the stream types match */
1468
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1469 1470 1471 1472 1473
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
                        ost->file_index, ost->index);
                    exit(1);
                }
1474

glantau's avatar
merge  
glantau committed
1475 1476 1477 1478 1479
            } else {
                /* get corresponding input stream index : we select the first one with the right type */
                found = 0;
                for(j=0;j<nb_istreams;j++) {
                    ist = ist_table[j];
1480
                    if (ist->discard &&
1481
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
glantau's avatar
merge  
glantau committed
1482 1483
                        ost->source_index = j;
                        found = 1;
1484
                        break;
glantau's avatar
merge  
glantau committed
1485 1486
                    }
                }
1487

glantau's avatar
merge  
glantau committed
1488 1489 1490 1491
                if (!found) {
                    /* try again and reuse existing stream */
                    for(j=0;j<nb_istreams;j++) {
                        ist = ist_table[j];
1492
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
glantau's avatar
merge  
glantau committed
1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
                            ost->source_index = j;
                            found = 1;
                        }
                    }
                    if (!found) {
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
                                ost->file_index, ost->index);
                        exit(1);
                    }
                }
            }
            ist = ist_table[ost->source_index];
            ist->discard = 0;
1506 1507 1508
            ost->sync_ist = (nb_stream_maps > 0) ?
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
                         stream_maps[n-1].sync_stream_index] : ist;
glantau's avatar
merge  
glantau committed
1509 1510 1511 1512 1513 1514
        }
    }

    /* for each output stream, we compute the right encoding parameters */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
1515
        os = output_files[ost->file_index];
glantau's avatar
merge  
glantau committed
1516 1517
        ist = ist_table[ost->source_index];

1518 1519
        codec = ost->st->codec;
        icodec = ist->st->codec;
glantau's avatar
merge  
glantau committed
1520

1521 1522 1523 1524
        if (!ost->st->language[0])
            av_strlcpy(ost->st->language, ist->st->language,
                       sizeof(ost->st->language));

1525 1526 1527 1528
        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;
1529 1530 1531 1532 1533 1534 1535 1536

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

1537
            codec->bit_rate = icodec->bit_rate;
michael's avatar
michael committed
1538 1539
            codec->extradata= icodec->extradata;
            codec->extradata_size= icodec->extradata_size;
1540
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1541 1542 1543
                codec->time_base = icodec->time_base;
            else
                codec->time_base = ist->st->time_base;
1544 1545 1546 1547
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
                codec->sample_rate = icodec->sample_rate;
                codec->channels = icodec->channels;
michael's avatar
michael committed
1548
                codec->frame_size = icodec->frame_size;
michael's avatar
michael committed
1549
                codec->block_align= icodec->block_align;
1550 1551
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
                    codec->block_align= 0;
1552 1553
                break;
            case CODEC_TYPE_VIDEO:
1554 1555 1556 1557
                if(using_vhook) {
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
                    exit(1);
                }
1558
                codec->pix_fmt = icodec->pix_fmt;
1559 1560
                codec->width = icodec->width;
                codec->height = icodec->height;
michael's avatar
michael committed
1561
                codec->has_b_frames = icodec->has_b_frames;
1562
                break;
1563 1564
            case CODEC_TYPE_SUBTITLE:
                break;
1565
            default:
1566
                abort();
1567 1568 1569 1570
            }
        } else {
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
1571
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
glantau's avatar
merge  
glantau committed
1572
                    goto fail;
1573

glantau's avatar
merge  
glantau committed
1574 1575 1576 1577
                if (codec->channels == icodec->channels &&
                    codec->sample_rate == icodec->sample_rate) {
                    ost->audio_resample = 0;
                } else {
1578
                    if (codec->channels != icodec->channels &&
1579 1580 1581
                        (icodec->codec_id == CODEC_ID_AC3 ||
                         icodec->codec_id == CODEC_ID_DTS)) {
                        /* Special case for 5:1 AC3 and DTS input */
1582
                        /* and mono or stereo output      */
1583 1584 1585 1586 1587 1588 1589
                        /* Request specific number of channels */
                        icodec->channels = codec->channels;
                        if (codec->sample_rate == icodec->sample_rate)
                            ost->audio_resample = 0;
                        else {
                            ost->audio_resample = 1;
                        }
1590
                    } else {
1591
                        ost->audio_resample = 1;
michael's avatar
michael committed
1592 1593
                    }
                }
michael's avatar
michael committed
1594
                if(audio_sync_method>1)
michael's avatar
michael committed
1595 1596 1597 1598 1599 1600 1601
                    ost->audio_resample = 1;

                if(ost->audio_resample){
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
                                                    codec->sample_rate, icodec->sample_rate);
                    if(!ost->resample){
                        printf("Can't resample.  Aborting.\n");
1602
                        abort();
1603
                    }
glantau's avatar
merge  
glantau committed
1604 1605 1606
                }
                ist->decoding_needed = 1;
                ost->encoding_needed = 1;
1607 1608
                break;
            case CODEC_TYPE_VIDEO:
1609 1610 1611 1612 1613 1614 1615
                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) +
1616 1617
                                (frame_padtop + frame_padbottom)) ||
                        (codec->pix_fmt != icodec->pix_fmt));
1618
                if (ost->video_crop) {
1619 1620
                    ost->topBand = frame_topBand;
                    ost->leftBand = frame_leftBand;
1621 1622
                }
                if (ost->video_pad) {
1623 1624 1625 1626
                    ost->padtop = frame_padtop;
                    ost->padleft = frame_padleft;
                    ost->padbottom = frame_padbottom;
                    ost->padright = frame_padright;
1627 1628 1629 1630 1631 1632 1633 1634
                    if (!ost->video_resample) {
                        avcodec_get_frame_defaults(&ost->pict_tmp);
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
                                         codec->width, codec->height ) )
                            goto fail;
                    }
                }
                if (ost->video_resample) {
michael's avatar
michael committed
1635
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1636
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
bcoudurier's avatar
bcoudurier committed
1637 1638
                                         codec->width, codec->height ) ) {
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1639
                        exit(1);
bcoudurier's avatar
bcoudurier committed
1640
                    }
benoit's avatar
benoit committed
1641
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1642 1643 1644 1645
                    ost->img_resample_ctx = sws_getContext(
                            icodec->width - (frame_leftBand + frame_rightBand),
                            icodec->height - (frame_topBand + frame_bottomBand),
                            icodec->pix_fmt,
1646 1647
                            codec->width - (frame_padleft + frame_padright),
                            codec->height - (frame_padtop + frame_padbottom),
1648 1649
                            codec->pix_fmt,
                            sws_flags, NULL, NULL, NULL);
1650 1651 1652 1653
                    if (ost->img_resample_ctx == NULL) {
                        fprintf(stderr, "Cannot get resampling context\n");
                        exit(1);
                    }
1654
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
glantau's avatar
merge  
glantau committed
1655 1656 1657
                }
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
1658
                break;
1659 1660 1661 1662
            case CODEC_TYPE_SUBTITLE:
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
                break;
1663
            default:
1664
                abort();
1665
                break;
glantau's avatar
merge  
glantau committed
1666
            }
1667
            /* two pass mode */
1668
            if (ost->encoding_needed &&
1669 1670 1671 1672 1673
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                char logfilename[1024];
                FILE *f;
                int size;
                char *logbuffer;
1674 1675 1676

                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
                         pass_logfilename ?
1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
                if (codec->flags & CODEC_FLAG_PASS1) {
                    f = fopen(logfilename, "w");
                    if (!f) {
                        perror(logfilename);
                        exit(1);
                    }
                    ost->logfile = f;
                } else {
                    /* read the log file */
                    f = fopen(logfilename, "r");
                    if (!f) {
                        perror(logfilename);
                        exit(1);
                    }
                    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");
                        exit(1);
                    }
1700
                    size = fread(logbuffer, 1, size, f);
1701 1702 1703
                    fclose(f);
                    logbuffer[size] = '\0';
                    codec->stats_in = logbuffer;
1704 1705 1706
                }
            }
        }
1707 1708 1709 1710
        if(codec->codec_type == CODEC_TYPE_VIDEO){
            int size= codec->width * codec->height;
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
        }
glantau's avatar
merge  
glantau committed
1711 1712
    }

1713 1714 1715 1716 1717
    if (!bit_buffer)
        bit_buffer = av_malloc(bit_buffer_size);
    if (!bit_buffer)
        goto fail;

1718 1719 1720 1721 1722 1723 1724
    /* 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 */
1725 1726 1727 1728
    if (verbose >= 0) {
        fprintf(stderr, "Stream mapping:\n");
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
1729
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1730 1731
                    ist_table[ost->source_index]->file_index,
                    ist_table[ost->source_index]->index,
1732
                    ost->file_index,
1733
                    ost->index);
1734 1735 1736 1737 1738
            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");
1739
        }
1740 1741
    }

glantau's avatar
merge  
glantau committed
1742 1743 1744 1745 1746
    /* open each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
            AVCodec *codec;
1747
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
glantau's avatar
merge  
glantau committed
1748
            if (!codec) {
1749
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
glantau's avatar
merge  
glantau committed
1750 1751 1752
                        ost->file_index, ost->index);
                exit(1);
            }
1753
            if (avcodec_open(ost->st->codec, codec) < 0) {
1754
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
glantau's avatar
merge  
glantau committed
1755 1756 1757
                        ost->file_index, ost->index);
                exit(1);
            }
1758
            extra_size += ost->st->codec->extradata_size;
glantau's avatar
merge  
glantau committed
1759 1760 1761 1762 1763 1764 1765 1766
        }
    }

    /* open each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
            AVCodec *codec;
1767
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
glantau's avatar
merge  
glantau committed
1768
            if (!codec) {
1769
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1770
                        ist->st->codec->codec_id, ist->file_index, ist->index);
glantau's avatar
merge  
glantau committed
1771 1772
                exit(1);
            }
1773
            if (avcodec_open(ist->st->codec, codec) < 0) {
1774
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
glantau's avatar
merge  
glantau committed
1775 1776 1777
                        ist->file_index, ist->index);
                exit(1);
            }
1778 1779
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
glantau's avatar
merge  
glantau committed
1780 1781 1782 1783 1784 1785
        }
    }

    /* init pts */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
1786
        is = input_files[ist->file_index];
romansh's avatar
 
romansh committed
1787
        ist->pts = 0;
1788
        ist->next_pts=0;
michael's avatar
michael committed
1789 1790
        if(   input_files_ts_offset[ist->file_index] != -is->start_time
           && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
michael's avatar
michael committed
1791
            ist->next_pts= AV_NOPTS_VALUE;
michael's avatar
michael committed
1792
        ist->is_start = 1;
glantau's avatar
merge  
glantau committed
1793
    }
michael's avatar
michael committed
1794

1795 1796 1797 1798 1799 1800 1801 1802 1803
    /* 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;
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1804
            ret = AVERROR(EINVAL);
1805 1806 1807 1808
            goto fail;
        }
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1809
            ret = AVERROR(EINVAL);
1810
            goto fail;
1811 1812
        }

1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824
        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);
    }
1825

glantau's avatar
merge  
glantau committed
1826 1827 1828
    /* open files and write file headers */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
1829
        if (av_write_header(os) < 0) {
1830
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1831
            ret = AVERROR(EINVAL);
1832 1833
            goto fail;
        }
1834 1835 1836 1837 1838 1839
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
            want_sdp = 0;
        }
    }
    if (want_sdp) {
        print_sdp(output_files, nb_output_files);
glantau's avatar
merge  
glantau committed
1840 1841
    }

1842
    if ( !using_stdin && verbose >= 0) {
1843
        fprintf(stderr, "Press [q] to stop encoding\n");
1844 1845
        url_set_interrupt_cb(decode_interrupt_cb);
    }
1846 1847
    term_init();

1848
    key = -1;
1849
    timer_start = av_gettime();
1850

1851
    for(; received_sigterm == 0;) {
glantau's avatar
merge  
glantau committed
1852 1853
        int file_index, ist_index;
        AVPacket pkt;
1854 1855
        double ipts_min;
        double opts_min;
michael's avatar
michael committed
1856

glantau's avatar
merge  
glantau committed
1857
    redo:
1858 1859
        ipts_min= 1e100;
        opts_min= 1e100;
1860
        /* if 'q' pressed, exits */
1861
        if (!using_stdin) {
1862 1863
            if (q_pressed)
                break;
1864 1865 1866 1867 1868
            /* read_key() returns 0 on EOF */
            key = read_key();
            if (key == 'q')
                break;
        }
1869

1870 1871
        /* select the stream that we must read now by looking at the
           smallest output pts */
glantau's avatar
merge  
glantau committed
1872
        file_index = -1;
1873
        for(i=0;i<nb_ostreams;i++) {
michael's avatar
michael committed
1874
            double ipts, opts;
1875 1876 1877
            ost = ost_table[i];
            os = output_files[ost->file_index];
            ist = ist_table[ost->source_index];
1878 1879
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
michael's avatar
michael committed
1880
            else
michael's avatar
michael committed
1881
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
michael's avatar
michael committed
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891
            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;
                }
glantau's avatar
merge  
glantau committed
1892
            }
1893
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
michael's avatar
michael committed
1894 1895 1896
                file_index= -1;
                break;
            }
glantau's avatar
merge  
glantau committed
1897 1898
        }
        /* if none, if is finished */
1899
        if (file_index < 0) {
glantau's avatar
merge  
glantau committed
1900
            break;
1901 1902
        }

glantau's avatar
merge  
glantau committed
1903
        /* finish if recording time exhausted */
michael's avatar
michael committed
1904
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
glantau's avatar
merge  
glantau committed
1905
            break;
1906

1907
        /* finish if limit size exhausted */
1908
        if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1909 1910
            break;

1911
        /* read a frame from it and output it in the fifo */
glantau's avatar
merge  
glantau committed
1912
        is = input_files[file_index];
1913
        if (av_read_frame(is, &pkt) < 0) {
glantau's avatar
merge  
glantau committed
1914
            file_table[file_index].eof_reached = 1;
alex's avatar
alex committed
1915 1916 1917 1918
            if (opt_shortest)
                break;
            else
                continue;
glantau's avatar
merge  
glantau committed
1919
        }
1920

1921
        if (do_pkt_dump) {
1922
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1923
        }
1924 1925 1926
        /* 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)
1927
            goto discard_packet;
glantau's avatar
merge  
glantau committed
1928 1929
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
        ist = ist_table[ist_index];
1930 1931
        if (ist->discard)
            goto discard_packet;
glantau's avatar
merge  
glantau committed
1932

1933 1934 1935 1936 1937
        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);

1938
//        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);
michael's avatar
michael committed
1939
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1940 1941 1942
            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){
1943 1944
                input_files_ts_offset[ist->file_index]-= delta;
                if (verbose > 2)
1945
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1946 1947 1948
                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);
1949 1950 1951
            }
        }

1952
        //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1953
        if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1954 1955 1956 1957 1958

            if (verbose >= 0)
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
                        ist->file_index, ist->index);

1959 1960
            av_free_packet(&pkt);
            goto redo;
michael's avatar
michael committed
1961
        }
1962

1963
    discard_packet:
glantau's avatar
merge  
glantau committed
1964
        av_free_packet(&pkt);
1965

1966 1967
        /* dump report by using the output first video and audio streams */
        print_report(output_files, ost_table, nb_ostreams, 0);
glantau's avatar
merge  
glantau committed
1968
    }
1969 1970 1971 1972 1973 1974 1975 1976 1977

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

1978
    term_exit();
glantau's avatar
merge  
glantau committed
1979

1980 1981 1982 1983 1984 1985
    /* write the trailer if needed and close file */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
        av_write_trailer(os);
    }

1986 1987 1988
    /* dump report by using the first video and audio streams */
    print_report(output_files, ost_table, nb_ostreams, 1);

glantau's avatar
merge  
glantau committed
1989 1990 1991 1992
    /* close each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
1993 1994
            av_freep(&ost->st->codec->stats_in);
            avcodec_close(ost->st->codec);
glantau's avatar
merge  
glantau committed
1995 1996
        }
    }
1997

glantau's avatar
merge  
glantau committed
1998 1999 2000 2001
    /* close each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
2002
            avcodec_close(ist->st->codec);
glantau's avatar
merge  
glantau committed
2003 2004 2005 2006
        }
    }

    /* finished ! */
2007

glantau's avatar
merge  
glantau committed
2008 2009
    ret = 0;
 fail1:
michael's avatar
michael committed
2010
    av_freep(&bit_buffer);
glantau's avatar
glantau committed
2011
    av_free(file_table);
glantau's avatar
glantau committed
2012

glantau's avatar
merge  
glantau committed
2013 2014 2015
    if (ist_table) {
        for(i=0;i<nb_istreams;i++) {
            ist = ist_table[i];
glantau's avatar
glantau committed
2016
            av_free(ist);
glantau's avatar
merge  
glantau committed
2017
        }
glantau's avatar
glantau committed
2018
        av_free(ist_table);
glantau's avatar
merge  
glantau committed
2019 2020 2021 2022 2023
    }
    if (ost_table) {
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            if (ost) {
2024 2025 2026 2027
                if (ost->logfile) {
                    fclose(ost->logfile);
                    ost->logfile = NULL;
                }
2028 2029
                av_fifo_free(&ost->fifo); /* works even if fifo is not
                                             initialized but set to zero */
glantau's avatar
glantau committed
2030
                av_free(ost->pict_tmp.data[0]);
glantau's avatar
merge  
glantau committed
2031
                if (ost->video_resample)
2032
                    sws_freeContext(ost->img_resample_ctx);
glantau's avatar
merge  
glantau committed
2033 2034
                if (ost->audio_resample)
                    audio_resample_close(ost->resample);
glantau's avatar
glantau committed
2035
                av_free(ost);
glantau's avatar
merge  
glantau committed
2036 2037
            }
        }
glantau's avatar
glantau committed
2038
        av_free(ost_table);
glantau's avatar
merge  
glantau committed
2039 2040 2041
    }
    return ret;
 fail:
2042
    ret = AVERROR(ENOMEM);
glantau's avatar
merge  
glantau committed
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
    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

2068
static void opt_format(const char *arg)
glantau's avatar
merge  
glantau committed
2069
{
2070 2071
    /* compatibility stuff for pgmyuv */
    if (!strcmp(arg, "pgmyuv")) {
2072
        pgmyuv_compatibility_hack=1;
2073
//        opt_image_format(arg);
2074
        arg = "image2";
2075
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2076 2077
    }

2078 2079 2080 2081
    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);
glantau's avatar
merge  
glantau committed
2082 2083 2084 2085
        exit(1);
    }
}

2086
static void opt_video_rc_eq(char *arg)
michaelni's avatar
michaelni committed
2087 2088 2089 2090
{
    video_rc_eq = arg;
}

2091
static void opt_video_rc_override_string(char *arg)
2092 2093 2094 2095
{
    video_rc_override_string = arg;
}

2096 2097 2098 2099 2100
static void opt_me_threshold(const char *arg)
{
    me_threshold = atoi(arg);
}

2101 2102 2103
static void opt_verbose(const char *arg)
{
    verbose = atoi(arg);
2104
    av_log_level = atoi(arg);
2105 2106
}

2107
static void opt_frame_rate(const char *arg)
glantau's avatar
merge  
glantau committed
2108
{
2109
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
romansh's avatar
 
romansh committed
2110
        fprintf(stderr, "Incorrect frame rate\n");
2111
        exit(1);
romansh's avatar
 
romansh committed
2112
    }
glantau's avatar
merge  
glantau committed
2113 2114
}

2115
static void opt_frame_crop_top(const char *arg)
2116
{
2117
    frame_topBand = atoi(arg);
2118 2119 2120 2121 2122 2123 2124 2125 2126
    if (frame_topBand < 0) {
        fprintf(stderr, "Incorrect top crop size\n");
        exit(1);
    }
    if ((frame_topBand % 2) != 0) {
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
        exit(1);
    }
    if ((frame_topBand) >= frame_height){
2127
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2128 2129 2130 2131 2132
        exit(1);
    }
    frame_height -= frame_topBand;
}

2133
static void opt_frame_crop_bottom(const char *arg)
2134 2135 2136 2137 2138 2139 2140 2141
{
    frame_bottomBand = atoi(arg);
    if (frame_bottomBand < 0) {
        fprintf(stderr, "Incorrect bottom crop size\n");
        exit(1);
    }
    if ((frame_bottomBand % 2) != 0) {
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2142
        exit(1);
2143 2144
    }
    if ((frame_bottomBand) >= frame_height){
2145
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2146 2147 2148 2149 2150
        exit(1);
    }
    frame_height -= frame_bottomBand;
}

2151
static void opt_frame_crop_left(const char *arg)
2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162
{
    frame_leftBand = atoi(arg);
    if (frame_leftBand < 0) {
        fprintf(stderr, "Incorrect left crop size\n");
        exit(1);
    }
    if ((frame_leftBand % 2) != 0) {
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
        exit(1);
    }
    if ((frame_leftBand) >= frame_width){
2163
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2164 2165 2166 2167 2168
        exit(1);
    }
    frame_width -= frame_leftBand;
}

2169
static void opt_frame_crop_right(const char *arg)
2170 2171 2172 2173 2174 2175 2176 2177
{
    frame_rightBand = atoi(arg);
    if (frame_rightBand < 0) {
        fprintf(stderr, "Incorrect right crop size\n");
        exit(1);
    }
    if ((frame_rightBand % 2) != 0) {
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2178
        exit(1);
2179 2180
    }
    if ((frame_rightBand) >= frame_width){
2181
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2182 2183 2184 2185 2186
        exit(1);
    }
    frame_width -= frame_rightBand;
}

2187
static void opt_frame_size(const char *arg)
glantau's avatar
merge  
glantau committed
2188
{
2189
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
glantau's avatar
merge  
glantau committed
2190 2191 2192 2193 2194 2195 2196 2197 2198
        fprintf(stderr, "Incorrect frame size\n");
        exit(1);
    }
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
        fprintf(stderr, "Frame size must be a multiple of 2\n");
        exit(1);
    }
}

2199 2200 2201

#define SCALEBITS 10
#define ONE_HALF  (1 << (SCALEBITS - 1))
2202
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220

#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;
2221 2222

    r = (rgb >> 16);
2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
    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)
{
2233
    frame_padtop = atoi(arg);
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
    if (frame_padtop < 0) {
        fprintf(stderr, "Incorrect top pad size\n");
        exit(1);
    }
    if ((frame_padtop % 2) != 0) {
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
        exit(1);
    }
}

static void opt_frame_pad_bottom(const char *arg)
{
2246
    frame_padbottom = atoi(arg);
2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
    if (frame_padbottom < 0) {
        fprintf(stderr, "Incorrect bottom pad size\n");
        exit(1);
    }
    if ((frame_padbottom % 2) != 0) {
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
        exit(1);
    }
}


static void opt_frame_pad_left(const char *arg)
{
2260
    frame_padleft = atoi(arg);
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273
    if (frame_padleft < 0) {
        fprintf(stderr, "Incorrect left pad size\n");
        exit(1);
    }
    if ((frame_padleft % 2) != 0) {
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
        exit(1);
    }
}


static void opt_frame_pad_right(const char *arg)
{
2274
    frame_padright = atoi(arg);
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284
    if (frame_padright < 0) {
        fprintf(stderr, "Incorrect right pad size\n");
        exit(1);
    }
    if ((frame_padright % 2) != 0) {
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
        exit(1);
    }
}

benoit's avatar
 
benoit committed
2285 2286 2287 2288 2289 2290 2291 2292 2293
void list_pix_fmts(void)
{
    int i;
    char pix_fmt_str[128];
    for (i=-1; i < PIX_FMT_NB; i++) {
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
        fprintf(stdout, "%s\n", pix_fmt_str);
    }
}
2294

romansh's avatar
 
romansh committed
2295 2296
static void opt_frame_pix_fmt(const char *arg)
{
benoit's avatar
 
benoit committed
2297 2298 2299 2300 2301 2302
    if (strcmp(arg, "list"))
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
    else {
        list_pix_fmts();
        exit(0);
    }
romansh's avatar
 
romansh committed
2303 2304
}

romansh's avatar
 
romansh committed
2305 2306 2307 2308 2309
static void opt_frame_aspect_ratio(const char *arg)
{
    int x = 0, y = 0;
    double ar = 0;
    const char *p;
2310

romansh's avatar
 
romansh committed
2311 2312 2313
    p = strchr(arg, ':');
    if (p) {
        x = strtol(arg, (char **)&arg, 10);
2314 2315 2316 2317
        if (arg == p)
            y = strtol(arg+1, (char **)&arg, 10);
        if (x > 0 && y > 0)
            ar = (double)x / (double)y;
romansh's avatar
 
romansh committed
2318 2319 2320 2321 2322
    } else
        ar = strtod(arg, (char **)&arg);

    if (!ar) {
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2323
        exit(1);
romansh's avatar
 
romansh committed
2324 2325 2326 2327
    }
    frame_aspect_ratio = ar;
}

2328
static void opt_qscale(const char *arg)
glantau's avatar
merge  
glantau committed
2329
{
2330
    video_qscale = atof(arg);
lorenm's avatar
lorenm committed
2331
    if (video_qscale <= 0 ||
2332
        video_qscale > 255) {
lorenm's avatar
lorenm committed
2333
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
glantau's avatar
merge  
glantau committed
2334 2335 2336 2337
        exit(1);
    }
}

2338
static void opt_qdiff(const char *arg)
2339 2340 2341 2342 2343 2344 2345 2346 2347
{
    video_qdiff = atoi(arg);
    if (video_qdiff < 0 ||
        video_qdiff > 31) {
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
        exit(1);
    }
}

2348
static void opt_strict(const char *arg)
michaelni's avatar
michaelni committed
2349 2350 2351 2352
{
    strict= atoi(arg);
}

michael's avatar
michael committed
2353 2354 2355 2356 2357
static void opt_top_field_first(const char *arg)
{
    top_field_first= atoi(arg);
}

2358 2359 2360
static void opt_thread_count(const char *arg)
{
    thread_count= atoi(arg);
2361
#if !defined(HAVE_THREADS)
2362 2363
    if (verbose >= 0)
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
michael's avatar
michael committed
2364
#endif
2365 2366
}

2367
static void opt_audio_rate(const char *arg)
glantau's avatar
merge  
glantau committed
2368 2369 2370 2371
{
    audio_sample_rate = atoi(arg);
}

2372
static void opt_audio_channels(const char *arg)
glantau's avatar
merge  
glantau committed
2373 2374 2375 2376
{
    audio_channels = atoi(arg);
}

2377
static void opt_video_channel(const char *arg)
2378 2379 2380 2381
{
    video_channel = strtol(arg, NULL, 0);
}

2382 2383 2384 2385 2386
static void opt_video_standard(const char *arg)
{
    video_standard = av_strdup(arg);
}

2387
static void opt_codec(int *pstream_copy, char **pcodec_name,
2388
                      int codec_type, const char *arg)
glantau's avatar
merge  
glantau committed
2389
{
2390
    av_freep(pcodec_name);
2391
    if (!strcmp(arg, "copy")) {
2392
        *pstream_copy = 1;
glantau's avatar
merge  
glantau committed
2393
    } else {
2394
        *pcodec_name = av_strdup(arg);
glantau's avatar
merge  
glantau committed
2395 2396 2397
    }
}

2398 2399
static void opt_audio_codec(const char *arg)
{
2400
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2401 2402
}

michael's avatar
michael committed
2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
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);
}

2421
#ifdef CONFIG_VHOOK
2422
static void add_frame_hooker(const char *arg)
2423 2424 2425 2426
{
    int argc = 0;
    char *argv[64];
    int i;
bellard's avatar
bellard committed
2427
    char *args = av_strdup(arg);
2428

2429 2430
    using_vhook = 1;

2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441
    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);
        exit(1);
    }
}
2442
#endif
2443

2444
static void opt_video_codec(const char *arg)
glantau's avatar
merge  
glantau committed
2445
{
2446
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2447
}
glantau's avatar
merge  
glantau committed
2448

2449 2450
static void opt_subtitle_codec(const char *arg)
{
2451
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
glantau's avatar
merge  
glantau committed
2452 2453
}

2454
static void opt_map(const char *arg)
glantau's avatar
merge  
glantau committed
2455 2456 2457 2458 2459 2460 2461 2462 2463 2464
{
    AVStreamMap *m;
    const char *p;

    p = arg;
    m = &stream_maps[nb_stream_maps++];

    m->file_index = strtol(arg, (char **)&p, 0);
    if (*p)
        p++;
pulento's avatar
pulento committed
2465 2466

    m->stream_index = strtol(p, (char **)&p, 0);
2467 2468 2469 2470 2471 2472 2473 2474 2475 2476
    if (*p) {
        p++;
        m->sync_file_index = strtol(p, (char **)&p, 0);
        if (*p)
            p++;
        m->sync_stream_index = strtol(p, (char **)&p, 0);
    } else {
        m->sync_file_index = m->file_index;
        m->sync_stream_index = m->stream_index;
    }
glantau's avatar
merge  
glantau committed
2477 2478
}

2479 2480 2481 2482
static void opt_map_meta_data(const char *arg)
{
    AVMetaDataMap *m;
    const char *p;
2483

2484 2485 2486 2487 2488 2489 2490 2491 2492 2493
    p = arg;
    m = &meta_data_maps[nb_meta_data_maps++];

    m->out_file = strtol(arg, (char **)&p, 0);
    if (*p)
        p++;

    m->in_file = strtol(p, (char **)&p, 0);
}

2494
static void opt_recording_time(const char *arg)
glantau's avatar
merge  
glantau committed
2495 2496 2497 2498
{
    recording_time = parse_date(arg, 1);
}

2499 2500 2501 2502 2503
static void opt_start_time(const char *arg)
{
    start_time = parse_date(arg, 1);
}

romansh's avatar
 
romansh committed
2504 2505 2506 2507 2508
static void opt_rec_timestamp(const char *arg)
{
    rec_timestamp = parse_date(arg, 0) / 1000000;
}

michael's avatar
michael committed
2509 2510 2511 2512 2513
static void opt_input_ts_offset(const char *arg)
{
    input_ts_offset = parse_date(arg, 1);
}

2514 2515
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
{
2516
    char *codec_string = encoder ? "encoder" : "decoder";
2517 2518 2519 2520 2521 2522 2523 2524
    AVCodec *codec;

    if(!name)
        return CODEC_ID_NONE;
    codec = encoder ?
        avcodec_find_encoder_by_name(name) :
        avcodec_find_decoder_by_name(name);
    if(!codec) {
2525
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2526 2527 2528
        exit(1);
    }
    if(codec->type != type) {
2529
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2530 2531 2532 2533 2534
        exit(1);
    }
    return codec->id;
}

2535
static void opt_input_file(const char *filename)
glantau's avatar
merge  
glantau committed
2536 2537 2538
{
    AVFormatContext *ic;
    AVFormatParameters params, *ap = &params;
2539
    int err, i, ret, rfps, rfps_base;
michael's avatar
michael committed
2540
    int64_t timestamp;
glantau's avatar
merge  
glantau committed
2541

bellard's avatar
bellard committed
2542 2543 2544
    if (!strcmp(filename, "-"))
        filename = "pipe:";

2545
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2546 2547
                   !strcmp( filename, "/dev/stdin" );

glantau's avatar
merge  
glantau committed
2548
    /* get default parameters from command line */
2549 2550
    ic = av_alloc_format_context();

2551
    memset(ap, 0, sizeof(*ap));
2552
    ap->prealloced_context = 1;
2553 2554
    ap->sample_rate = audio_sample_rate;
    ap->channels = audio_channels;
2555 2556
    ap->time_base.den = frame_rate.num;
    ap->time_base.num = frame_rate.den;
2557 2558
    ap->width = frame_width + frame_padleft + frame_padright;
    ap->height = frame_height + frame_padtop + frame_padbottom;
romansh's avatar
 
romansh committed
2559
    ap->pix_fmt = frame_pix_fmt;
romansh's avatar
 
romansh committed
2560 2561
    ap->channel = video_channel;
    ap->standard = video_standard;
2562 2563
    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);
2564 2565
    if(pgmyuv_compatibility_hack)
        ap->video_codec_id= CODEC_ID_PGMYUV;
2566

2567
    for(i=0; i<opt_name_count; i++){
2568
        const AVOption *opt;
2569 2570 2571 2572
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
            av_set_double(ic, opt_names[i], d);
    }
2573 2574
    /* open the input file with generic libav function */
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
glantau's avatar
merge  
glantau committed
2575
    if (err < 0) {
2576
        print_error(filename, err);
glantau's avatar
merge  
glantau committed
2577 2578
        exit(1);
    }
2579

2580 2581
    ic->loop_input = loop_input;

2582 2583 2584
    /* 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);
2585
    if (ret < 0 && verbose >= 0) {
glantau's avatar
merge  
glantau committed
2586 2587 2588 2589
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
        exit(1);
    }

michael's avatar
michael committed
2590 2591 2592 2593 2594
    timestamp = start_time;
    /* add the stream start time */
    if (ic->start_time != AV_NOPTS_VALUE)
        timestamp += ic->start_time;

2595 2596
    /* if seeking requested, we execute it */
    if (start_time != 0) {
michael's avatar
michael committed
2597
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2598
        if (ret < 0) {
2599
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2600 2601 2602 2603 2604 2605
                    filename, (double)timestamp / AV_TIME_BASE);
        }
        /* reset seek info */
        start_time = 0;
    }

glantau's avatar
merge  
glantau committed
2606 2607
    /* update the current parameters so that they match the one of the input stream */
    for(i=0;i<ic->nb_streams;i++) {
2608
        int j;
2609
        AVCodecContext *enc = ic->streams[i]->codec;
michael's avatar
michael committed
2610 2611 2612
        if(thread_count>1)
            avcodec_thread_init(enc, thread_count);
        enc->thread_count= thread_count;
glantau's avatar
merge  
glantau committed
2613 2614
        switch(enc->codec_type) {
        case CODEC_TYPE_AUDIO:
2615
            for(j=0; j<opt_name_count; j++){
2616
                const AVOption *opt;
2617
                double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2618 2619 2620
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
                    av_set_double(enc, opt_names[j], d);
            }
2621
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
glantau's avatar
merge  
glantau committed
2622 2623
            audio_channels = enc->channels;
            audio_sample_rate = enc->sample_rate;
2624
            if(audio_disable)
2625
                ic->streams[i]->discard= AVDISCARD_ALL;
glantau's avatar
merge  
glantau committed
2626 2627
            break;
        case CODEC_TYPE_VIDEO:
2628
            for(j=0; j<opt_name_count; j++){
2629
                const AVOption *opt;
2630
                double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2631 2632 2633
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
                    av_set_double(enc, opt_names[j], d);
            }
glantau's avatar
merge  
glantau committed
2634 2635
            frame_height = enc->height;
            frame_width = enc->width;
2636 2637
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
            frame_pix_fmt = enc->pix_fmt;
michael's avatar
michael committed
2638 2639
            rfps      = ic->streams[i]->r_frame_rate.num;
            rfps_base = ic->streams[i]->r_frame_rate.den;
2640
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2641 2642
            if(me_threshold)
                enc->debug |= FF_DEBUG_MV;
2643

2644
            if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2645 2646

                if (verbose >= 0)
2647
                    fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
michael's avatar
michael committed
2648
                            i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2649

2650
                    (float)rfps / rfps_base, rfps, rfps_base);
2651
            }
2652
            /* update the current frame rate to match the stream frame rate */
2653 2654
            frame_rate.num = rfps;
            frame_rate.den = rfps_base;
2655 2656

            enc->rate_emu = rate_emu;
2657
            if(video_disable)
2658 2659 2660
                ic->streams[i]->discard= AVDISCARD_ALL;
            else if(video_discard)
                ic->streams[i]->discard= video_discard;
glantau's avatar
merge  
glantau committed
2661
            break;
2662 2663
        case CODEC_TYPE_DATA:
            break;
2664
        case CODEC_TYPE_SUBTITLE:
2665 2666
            if(subtitle_disable)
                ic->streams[i]->discard = AVDISCARD_ALL;
2667
            break;
2668 2669
        case CODEC_TYPE_UNKNOWN:
            break;
2670
        default:
2671
            abort();
glantau's avatar
merge  
glantau committed
2672 2673
        }
    }
2674

glantau's avatar
merge  
glantau committed
2675
    input_files[nb_input_files] = ic;
michael's avatar
michael committed
2676
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
glantau's avatar
merge  
glantau committed
2677
    /* dump the file content */
2678 2679 2680
    if (verbose >= 0)
        dump_format(ic, nb_input_files, filename, 0);

glantau's avatar
merge  
glantau committed
2681
    nb_input_files++;
2682 2683
    file_iformat = NULL;
    file_oformat = NULL;
2684

romansh's avatar
 
romansh committed
2685
    video_channel = 0;
2686

2687
    rate_emu = 0;
glantau's avatar
merge  
glantau committed
2688 2689
}

2690 2691
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
                                         int *has_subtitle_ptr)
2692
{
2693
    int has_video, has_audio, has_subtitle, i, j;
2694 2695 2696 2697
    AVFormatContext *ic;

    has_video = 0;
    has_audio = 0;
2698
    has_subtitle = 0;
2699 2700 2701
    for(j=0;j<nb_input_files;j++) {
        ic = input_files[j];
        for(i=0;i<ic->nb_streams;i++) {
2702
            AVCodecContext *enc = ic->streams[i]->codec;
2703 2704 2705 2706 2707 2708 2709
            switch(enc->codec_type) {
            case CODEC_TYPE_AUDIO:
                has_audio = 1;
                break;
            case CODEC_TYPE_VIDEO:
                has_video = 1;
                break;
2710 2711 2712
            case CODEC_TYPE_SUBTITLE:
                has_subtitle = 1;
                break;
2713
            case CODEC_TYPE_DATA:
2714
            case CODEC_TYPE_UNKNOWN:
2715
                break;
2716
            default:
2717
                abort();
2718 2719 2720 2721 2722
            }
        }
    }
    *has_video_ptr = has_video;
    *has_audio_ptr = has_audio;
2723
    *has_subtitle_ptr = has_subtitle;
2724 2725
}

2726
static void new_video_stream(AVFormatContext *oc)
glantau's avatar
merge  
glantau committed
2727 2728
{
    AVStream *st;
2729 2730
    AVCodecContext *video_enc;
    int codec_id;
2731

2732 2733 2734 2735 2736
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
        exit(1);
    }
2737
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2738 2739 2740
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
    video_bitstream_filters= NULL;

2741
    if(thread_count>1)
2742
        avcodec_thread_init(st->codec, thread_count);
2743

2744
    video_enc = st->codec;
2745

2746 2747
    if(video_codec_tag)
        video_enc->codec_tag= video_codec_tag;
2748

2749
    if(   (video_global_header&1)
2750
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2751
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2752
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2753 2754
    }
    if(video_global_header&2){
2755
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2756
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2757
    }
2758

2759 2760 2761 2762 2763 2764 2765
    if (video_stream_copy) {
        st->stream_copy = 1;
        video_enc->codec_type = CODEC_TYPE_VIDEO;
    } else {
        char *p;
        int i;
        AVCodec *codec;
2766

2767
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2768 2769
        if (video_codec_name)
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2770

2771 2772
        video_enc->codec_id = codec_id;
        codec = avcodec_find_encoder(codec_id);
2773

michael's avatar
michael committed
2774
        for(i=0; i<opt_name_count; i++){
2775
             const AVOption *opt;
2776
             double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
michael's avatar
michael committed
2777 2778 2779
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
                 av_set_double(video_enc, opt_names[i], d);
        }
2780

2781 2782
        video_enc->time_base.den = frame_rate.num;
        video_enc->time_base.num = frame_rate.den;
2783 2784
        if(codec && codec->supported_framerates){
            const AVRational *p= codec->supported_framerates;
2785
            AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798
            const AVRational *best=NULL;
            AVRational best_error= (AVRational){INT_MAX, 1};
            for(; p->den!=0; p++){
                AVRational error= av_sub_q(req, *p);
                if(error.num <0) error.num *= -1;
                if(av_cmp_q(error, best_error) < 0){
                    best_error= error;
                    best= p;
                }
            }
            video_enc->time_base.den= best->num;
            video_enc->time_base.num= best->den;
        }
2799

2800 2801
        video_enc->width = frame_width + frame_padright + frame_padleft;
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
lucabe's avatar
lucabe committed
2802
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814
        video_enc->pix_fmt = frame_pix_fmt;

        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];
        }

2815
        if (intra_only)
2816 2817 2818
            video_enc->gop_size = 0;
        if (video_qscale || same_quality) {
            video_enc->flags |= CODEC_FLAG_QSCALE;
2819
            video_enc->global_quality=
2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838
                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->max_qdiff = video_qdiff;
        video_enc->rc_eq = video_rc_eq;
        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");
                exit(1);
            }
2839 2840
            video_enc->rc_override=
                av_realloc(video_enc->rc_override,
2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855
                           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;
2856 2857
        if (!video_enc->rc_initial_buffer_occupancy)
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2858 2859 2860 2861 2862 2863
        video_enc->me_threshold= me_threshold;
        video_enc->intra_dc_precision= intra_dc_precision - 8;
        video_enc->strict_std_compliance = strict;

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

2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876
        /* two pass mode */
        if (do_pass) {
            if (do_pass == 1) {
                video_enc->flags |= CODEC_FLAG_PASS1;
            } else {
                video_enc->flags |= CODEC_FLAG_PASS2;
            }
        }
    }

    /* reset some key parameters */
    video_disable = 0;
2877
    av_freep(&video_codec_name);
2878 2879 2880 2881 2882 2883 2884
    video_stream_copy = 0;
}

static void new_audio_stream(AVFormatContext *oc)
{
    AVStream *st;
    AVCodecContext *audio_enc;
michael's avatar
michael committed
2885
    int codec_id, i;
2886

2887 2888 2889 2890 2891
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
        exit(1);
    }
2892
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2893 2894 2895 2896

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

2897
    if(thread_count>1)
2898
        avcodec_thread_init(st->codec, thread_count);
2899

2900
    audio_enc = st->codec;
2901
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
2902
    audio_enc->strict_std_compliance = strict;
2903

2904 2905
    if(audio_codec_tag)
        audio_enc->codec_tag= audio_codec_tag;
2906

2907
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2908
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2909
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2910
    }
2911 2912 2913 2914 2915
    if (audio_stream_copy) {
        st->stream_copy = 1;
        audio_enc->channels = audio_channels;
    } else {
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2916

michael's avatar
michael committed
2917
        for(i=0; i<opt_name_count; i++){
2918
            const AVOption *opt;
2919
            double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
michael's avatar
michael committed
2920 2921 2922
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
                av_set_double(audio_enc, opt_names[i], d);
        }
2923

2924 2925
        if (audio_codec_name)
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
2926
        audio_enc->codec_id = codec_id;
2927

2928 2929 2930 2931
        if (audio_qscale > QSCALE_NONE) {
            audio_enc->flags |= CODEC_FLAG_QSCALE;
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
        }
2932
        audio_enc->thread_count = thread_count;
2933
        audio_enc->channels = audio_channels;
2934 2935
    }
    audio_enc->sample_rate = audio_sample_rate;
2936
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
2937
    if (audio_language) {
2938
        av_strlcpy(st->language, audio_language, sizeof(st->language));
2939 2940 2941 2942 2943 2944
        av_free(audio_language);
        audio_language = NULL;
    }

    /* reset some key parameters */
    audio_disable = 0;
2945
    av_freep(&audio_codec_name);
2946 2947 2948
    audio_stream_copy = 0;
}

2949
static void new_subtitle_stream(AVFormatContext *oc)
2950 2951 2952
{
    AVStream *st;
    AVCodecContext *subtitle_enc;
michael's avatar
michael committed
2953
    int i;
2954

2955 2956 2957 2958 2959
    st = av_new_stream(oc, oc->nb_streams);
    if (!st) {
        fprintf(stderr, "Could not alloc stream\n");
        exit(1);
    }
2960
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2961

2962
    subtitle_enc = st->codec;
2963 2964 2965 2966
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
    if (subtitle_stream_copy) {
        st->stream_copy = 1;
    } else {
michael's avatar
michael committed
2967
        for(i=0; i<opt_name_count; i++){
2968
             const AVOption *opt;
2969
             double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
michael's avatar
michael committed
2970 2971 2972
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
                 av_set_double(subtitle_enc, opt_names[i], d);
        }
2973
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
2974 2975 2976
    }

    if (subtitle_language) {
2977
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
2978 2979 2980 2981
        av_free(subtitle_language);
        subtitle_language = NULL;
    }

2982
    subtitle_disable = 0;
2983
    av_freep(&subtitle_codec_name);
2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008
    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");
        exit(1);
    }
    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");
        exit(1);
    }
    oc = output_files[nb_output_files - 1];
    new_video_stream(oc);
}

3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019
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");
        exit(1);
    }
    oc = output_files[nb_output_files - 1];
    new_subtitle_stream(oc);
}

3020 3021 3022
static void opt_output_file(const char *filename)
{
    AVFormatContext *oc;
3023 3024
    int use_video, use_audio, use_subtitle;
    int input_has_video, input_has_audio, input_has_subtitle, i;
3025
    AVFormatParameters params, *ap = &params;
glantau's avatar
merge  
glantau committed
3026 3027 3028 3029

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

3030
    oc = av_alloc_format_context();
glantau's avatar
merge  
glantau committed
3031

3032 3033 3034
    if (!file_oformat) {
        file_oformat = guess_format(NULL, filename, NULL);
        if (!file_oformat) {
diego's avatar
diego committed
3035
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3036 3037 3038
                    filename);
            exit(1);
        }
glantau's avatar
merge  
glantau committed
3039
    }
3040

3041
    oc->oformat = file_oformat;
3042
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
glantau's avatar
merge  
glantau committed
3043

3044
    if (!strcmp(file_oformat->name, "ffm") &&
3045
        av_strstart(filename, "http:", NULL)) {
glantau's avatar
merge  
glantau committed
3046 3047 3048 3049 3050 3051 3052
        /* special case for files sent to ffserver: we get the stream
           parameters from ffserver */
        if (read_ffserver_streams(oc, filename) < 0) {
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
            exit(1);
        }
    } else {
3053 3054 3055
        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;
3056

3057 3058 3059
        /* disable if no corresponding type found and at least one
           input file */
        if (nb_input_files > 0) {
3060 3061
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
                                         &input_has_subtitle);
3062 3063 3064 3065
            if (!input_has_video)
                use_video = 0;
            if (!input_has_audio)
                use_audio = 0;
3066 3067
            if (!input_has_subtitle)
                use_subtitle = 0;
3068
        }
3069 3070

        /* manual disable */
glantau's avatar
merge  
glantau committed
3071 3072 3073 3074 3075 3076
        if (audio_disable) {
            use_audio = 0;
        }
        if (video_disable) {
            use_video = 0;
        }
3077 3078 3079
        if (subtitle_disable) {
            use_subtitle = 0;
        }
3080

glantau's avatar
merge  
glantau committed
3081
        if (use_video) {
3082
            new_video_stream(oc);
glantau's avatar
merge  
glantau committed
3083
        }
3084

glantau's avatar
merge  
glantau committed
3085
        if (use_audio) {
3086
            new_audio_stream(oc);
glantau's avatar
merge  
glantau committed
3087 3088
        }

3089 3090 3091 3092
        if (use_subtitle) {
            new_subtitle_stream(oc);
        }

romansh's avatar
 
romansh committed
3093
        oc->timestamp = rec_timestamp;
3094

3095
        if (str_title)
3096
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
glantau's avatar
merge  
glantau committed
3097
        if (str_author)
3098
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
glantau's avatar
merge  
glantau committed
3099
        if (str_copyright)
3100
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
glantau's avatar
merge  
glantau committed
3101
        if (str_comment)
3102
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3103
        if (str_album)
3104
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
glantau's avatar
merge  
glantau committed
3105 3106
    }

3107
    output_files[nb_output_files++] = oc;
glantau's avatar
merge  
glantau committed
3108

3109
    /* check filename in case of an image number is expected */
3110
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3111
        if (!av_filename_number_test(oc->filename)) {
3112
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3113
            exit(1);
3114
        }
3115 3116
    }

3117
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
glantau's avatar
merge  
glantau committed
3118
        /* test if it already exists to avoid loosing precious files */
3119
        if (!file_overwrite &&
glantau's avatar
merge  
glantau committed
3120
            (strchr(filename, ':') == NULL ||
3121
             av_strstart(filename, "file:", NULL))) {
glantau's avatar
merge  
glantau committed
3122 3123
            if (url_exist(filename)) {
                int c;
3124

3125 3126 3127 3128 3129 3130 3131 3132
                if ( !using_stdin ) {
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
                    fflush(stderr);
                    c = getchar();
                    if (toupper(c) != 'Y') {
                        fprintf(stderr, "Not overwriting - exiting\n");
                        exit(1);
                    }
3133 3134
                                }
                                else {
3135
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
glantau's avatar
merge  
glantau committed
3136
                    exit(1);
3137
                                }
glantau's avatar
merge  
glantau committed
3138 3139
            }
        }
3140

glantau's avatar
merge  
glantau committed
3141 3142 3143 3144 3145 3146 3147
        /* open the file */
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
            fprintf(stderr, "Could not open '%s'\n", filename);
            exit(1);
        }
    }

3148 3149 3150 3151 3152 3153 3154
    memset(ap, 0, sizeof(*ap));
    if (av_set_parameters(oc, ap) < 0) {
        fprintf(stderr, "%s: Invalid encoding parameters\n",
                oc->filename);
        exit(1);
    }

3155 3156
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3157
    oc->loop_output = loop_output;
3158

gpoirier's avatar
gpoirier committed
3159
    for(i=0; i<opt_name_count; i++){
3160
        const AVOption *opt;
gpoirier's avatar
gpoirier committed
3161 3162 3163 3164 3165
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
            av_set_double(oc, opt_names[i], d);
    }

glantau's avatar
merge  
glantau committed
3166
    /* reset some options */
3167 3168
    file_oformat = NULL;
    file_iformat = NULL;
glantau's avatar
merge  
glantau committed
3169 3170
}

3171
/* same option as mencoder */
3172
static void opt_pass(const char *pass_str)
3173 3174 3175 3176 3177 3178 3179 3180 3181
{
    int pass;
    pass = atoi(pass_str);
    if (pass != 1 && pass != 2) {
        fprintf(stderr, "pass number can be only 1 or 2\n");
        exit(1);
    }
    do_pass = pass;
}
3182

kabi's avatar
kabi committed
3183
static int64_t getutime(void)
glantau's avatar
glantau committed
3184
{
ramiro's avatar
ramiro committed
3185
#ifdef HAVE_GETRUSAGE
3186 3187 3188 3189
    struct rusage rusage;

    getrusage(RUSAGE_SELF, &rusage);
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3190 3191 3192 3193 3194 3195 3196
#elif defined(HAVE_GETPROCESSTIMES)
    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's avatar
ramiro committed
3197
    return av_gettime();
ramiro's avatar
ramiro committed
3198
#endif
glantau's avatar
glantau committed
3199
}
glantau's avatar
glantau committed
3200

3201
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3202
extern int ffm_nopts;
3203
#endif
3204

3205
static void opt_show_formats(void)
glantau's avatar
merge  
glantau committed
3206
{
3207 3208
    AVInputFormat *ifmt;
    AVOutputFormat *ofmt;
glantau's avatar
merge  
glantau committed
3209
    URLProtocol *up;
michael's avatar
michael committed
3210
    AVCodec *p, *p2;
3211
    const char *last_name;
michael's avatar
michael committed
3212 3213 3214 3215 3216 3217 3218

    printf("File formats:\n");
    last_name= "000";
    for(;;){
        int decode=0;
        int encode=0;
        const char *name=NULL;
3219
        const char *long_name=NULL;
michael's avatar
michael committed
3220 3221 3222 3223 3224

        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
                strcmp(ofmt->name, last_name)>0){
                name= ofmt->name;
3225
                long_name= ofmt->long_name;
michael's avatar
michael committed
3226 3227 3228 3229 3230 3231 3232
                encode=1;
            }
        }
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
                strcmp(ifmt->name, last_name)>0){
                name= ifmt->name;
3233
                long_name= ifmt->long_name;
michael's avatar
michael committed
3234 3235 3236 3237 3238 3239 3240 3241
                encode=0;
            }
            if(name && strcmp(ifmt->name, name)==0)
                decode=1;
        }
        if(name==NULL)
            break;
        last_name= name;
3242

michael's avatar
michael committed
3243
        printf(
3244 3245 3246
            " %s%s %-15s %s\n",
            decode ? "D":" ",
            encode ? "E":" ",
3247 3248
            name,
            long_name ? long_name:" ");
3249 3250 3251
    }
    printf("\n");

glantau's avatar
merge  
glantau committed
3252
    printf("Codecs:\n");
michael's avatar
michael committed
3253 3254 3255 3256 3257
    last_name= "000";
    for(;;){
        int decode=0;
        int encode=0;
        int cap=0;
3258
        const char *type_str;
michael's avatar
michael committed
3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275

        p2=NULL;
        for(p = first_avcodec; p != NULL; p = p->next) {
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
                strcmp(p->name, last_name)>0){
                p2= p;
                decode= encode= cap=0;
            }
            if(p2 && strcmp(p->name, p2->name)==0){
                if(p->decode) decode=1;
                if(p->encode) encode=1;
                cap |= p->capabilities;
            }
        }
        if(p2==NULL)
            break;
        last_name= p2->name;
3276

3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290
        switch(p2->type) {
        case CODEC_TYPE_VIDEO:
            type_str = "V";
            break;
        case CODEC_TYPE_AUDIO:
            type_str = "A";
            break;
        case CODEC_TYPE_SUBTITLE:
            type_str = "S";
            break;
        default:
            type_str = "?";
            break;
        }
michael's avatar
michael committed
3291
        printf(
3292 3293 3294
            " %s%s%s%s%s%s %s",
            decode ? "D": (/*p2->decoder ? "d":*/" "),
            encode ? "E":" ",
3295
            type_str,
michael's avatar
michael committed
3296 3297 3298 3299 3300 3301 3302
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
            cap & CODEC_CAP_DR1 ? "D":" ",
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
            p2->name);
       /* if(p2->decoder && decode==0)
            printf(" use %s for decoding", p2->decoder->name);*/
        printf("\n");
glantau's avatar
merge  
glantau committed
3303 3304 3305
    }
    printf("\n");

michael's avatar
michael committed
3306
    printf("Supported file protocols:\n");
glantau's avatar
merge  
glantau committed
3307 3308 3309
    for(up = first_protocol; up != NULL; up = up->next)
        printf(" %s:", up->name);
    printf("\n");
3310

michael's avatar
michael committed
3311
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3312
    printf("\n");
michael's avatar
michael committed
3313
    printf(
diego's avatar
diego committed
3314
"Note, the names of encoders and decoders do not always match, so there are\n"
michael's avatar
michael committed
3315
"several cases where the above table shows encoder only or decoder only entries\n"
diego's avatar
diego committed
3316 3317 3318
"even though both encoding and decoding are supported. For example, the h263\n"
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
"worse.\n");
diego's avatar
diego committed
3319
    exit(0);
glantau's avatar
merge  
glantau committed
3320 3321
}

mru's avatar
mru committed
3322
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338
{
    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);
            exit(1);
        }
        p++;
    }
}

mru's avatar
mru committed
3339
static void opt_inter_matrix(const char *arg)
3340 3341 3342 3343 3344
{
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(inter_matrix, arg);
}

mru's avatar
mru committed
3345
static void opt_intra_matrix(const char *arg)
3346 3347 3348 3349 3350
{
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(intra_matrix, arg);
}

3351 3352 3353 3354 3355 3356
static void opt_show_help(void)
{
    show_help();
    exit(0);
}

3357 3358 3359
static void opt_target(const char *arg)
{
    int norm = -1;
3360
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3361 3362 3363 3364 3365 3366 3367

    if(!strncmp(arg, "pal-", 4)) {
        norm = 0;
        arg += 4;
    } else if(!strncmp(arg, "ntsc-", 5)) {
        norm = 1;
        arg += 5;
3368 3369 3370
    } else if(!strncmp(arg, "film-", 5)) {
        norm = 2;
        arg += 5;
3371 3372 3373
    } else {
        int fr;
        /* Calculate FR via float to avoid int overflow */
3374
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3375 3376 3377 3378 3379 3380 3381 3382 3383 3384
        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++) {
3385
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3386 3387
                        if(c->codec_type != CODEC_TYPE_VIDEO)
                            continue;
michael's avatar
michael committed
3388
                        fr = c->time_base.den * 1000 / c->time_base.num;
3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402
                        if(fr == 25000) {
                            norm = 0;
                            break;
                        } else if((fr == 29970) || (fr == 23976)) {
                            norm = 1;
                            break;
                        }
                    }
                    if(norm >= 0)
                        break;
                }
            }
        }
        if(verbose && norm >= 0)
3403
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3404 3405 3406
    }

    if(norm < 0) {
3407 3408
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
        exit(1);
    }

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

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

        opt_frame_size(norm ? "352x240" : "352x288");
3420
        opt_frame_rate(frame_rates[norm]);
3421
        opt_default("gop", norm ? "18" : "15");
3422

3423
        opt_default("b", "1150000");
3424 3425
        opt_default("maxrate", "1150000");
        opt_default("minrate", "1150000");
3426
        opt_default("bufsize", "327680"); // 40*1024*8;
3427

3428
        opt_default("ab", "224000");
3429
        audio_sample_rate = 44100;
takis's avatar
takis committed
3430
        audio_channels = 2;
3431

3432
        opt_default("packetsize", "2324");
3433
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3434

3435 3436 3437 3438 3439 3440
        /* 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
3441 3442 3443 3444
    } else if(!strcmp(arg, "svcd")) {

        opt_video_codec("mpeg2video");
        opt_audio_codec("mp2");
3445
        opt_format("svcd");
3446 3447

        opt_frame_size(norm ? "480x480" : "480x576");
3448
        opt_frame_rate(frame_rates[norm]);
3449
        opt_default("gop", norm ? "18" : "15");
3450

3451
        opt_default("b", "2040000");
3452 3453
        opt_default("maxrate", "2516000");
        opt_default("minrate", "0"); //1145000;
3454
        opt_default("bufsize", "1835008"); //224*1024*8;
3455 3456
        opt_default("flags", "+SCAN_OFFSET");

3457

3458
        opt_default("ab", "224000");
3459 3460
        audio_sample_rate = 44100;

3461
        opt_default("packetsize", "2324");
3462

3463 3464 3465 3466
    } else if(!strcmp(arg, "dvd")) {

        opt_video_codec("mpeg2video");
        opt_audio_codec("ac3");
3467
        opt_format("dvd");
3468 3469

        opt_frame_size(norm ? "720x480" : "720x576");
3470
        opt_frame_rate(frame_rates[norm]);
3471
        opt_default("gop", norm ? "18" : "15");
3472

3473
        opt_default("b", "6000000");
3474 3475
        opt_default("maxrate", "9000000");
        opt_default("minrate", "0"); //1500000;
3476
        opt_default("bufsize", "1835008"); //224*1024*8;
3477

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

3481
        opt_default("ab", "448000");
3482 3483
        audio_sample_rate = 48000;

romansh's avatar
 
romansh committed
3484
    } else if(!strncmp(arg, "dv", 2)) {
3485 3486 3487 3488

        opt_format("dv");

        opt_frame_size(norm ? "720x480" : "720x576");
romansh's avatar
 
romansh committed
3489 3490
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
                                             (norm ? "yuv411p" : "yuv420p"));
3491 3492 3493 3494 3495
        opt_frame_rate(frame_rates[norm]);

        audio_sample_rate = 48000;
        audio_channels = 2;

3496 3497 3498 3499 3500 3501
    } else {
        fprintf(stderr, "Unknown target: %s\n", arg);
        exit(1);
    }
}

benoit's avatar
 
benoit committed
3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518
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);
}

3519 3520 3521 3522 3523 3524
static void opt_video_bsf(const char *arg)
{
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
    AVBitStreamFilterContext **bsfp;

    if(!bsfc){
alex's avatar
alex committed
3525
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542
        exit(1);
    }

    bsfp= &video_bitstream_filters;
    while(*bsfp)
        bsfp= &(*bsfp)->next;

    *bsfp= bsfc;
}

//FIXME avoid audio - video code duplication
static void opt_audio_bsf(const char *arg)
{
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
    AVBitStreamFilterContext **bsfp;

    if(!bsfc){
alex's avatar
alex committed
3543
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3544 3545 3546 3547 3548 3549 3550 3551 3552 3553
        exit(1);
    }

    bsfp= &audio_bitstream_filters;
    while(*bsfp)
        bsfp= &(*bsfp)->next;

    *bsfp= bsfc;
}

3554
static void opt_show_version(void)
michael's avatar
michael committed
3555
{
al's avatar
al committed
3556
    /* TODO: add function interface to avutil and avformat */
3557
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
al's avatar
al committed
3558
           "libavutil   %d\n"
michael's avatar
michael committed
3559
           "libavcodec  %d\n"
3560
           "libavformat %d\n",
al's avatar
al committed
3561
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
diego's avatar
diego committed
3562
    exit(0);
michael's avatar
michael committed
3563 3564
}

michael's avatar
michael committed
3565
static int opt_default(const char *opt, const char *arg){
3566
    int type;
3567 3568 3569 3570 3571 3572 3573 3574
    const AVOption *o= NULL;
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};

    for(type=0; type<CODEC_TYPE_NB; type++){
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
        if(o2)
            o = av_set_string(avctx_opts[type], opt, arg);
    }
3575 3576
    if(!o)
        o = av_set_string(avformat_opts, opt, arg);
benoit's avatar
benoit committed
3577
    if(!o)
3578
        o = av_set_string(sws_opts, opt, arg);
3579 3580 3581 3582 3583 3584 3585 3586
    if(!o){
        if(opt[0] == 'a')
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
        else if(opt[0] == 'v')
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
        else if(opt[0] == 's')
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
    }
michael's avatar
michael committed
3587 3588
    if(!o)
        return -1;
3589

3590
//    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
michael's avatar
michael committed
3591 3592 3593

    //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3594
    opt_names[opt_name_count++]= o->name;
3595

3596
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3597
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3598
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3599
        ffm_nopts = 1;
3600
#endif
3601

3602
    if(avctx_opts[0]->debug)
3603
        av_log_level = AV_LOG_DEBUG;
michael's avatar
michael committed
3604 3605 3606
    return 0;
}

glantau's avatar
merge  
glantau committed
3607
const OptionDef options[] = {
3608
    /* main options */
3609
    { "L", 0, {(void*)opt_show_license}, "show license" },
3610
    { "h", 0, {(void*)opt_show_help}, "show help" },
3611 3612
    { "version", 0, {(void*)opt_show_version}, "show version" },
    { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
glantau's avatar
glantau committed
3613 3614 3615
    { "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" },
3616
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3617
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
benoit's avatar
benoit committed
3618
    { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3619
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3620
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
michael's avatar
michael committed
3621
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
glantau's avatar
glantau committed
3622
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
romansh's avatar
 
romansh committed
3623
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
glantau's avatar
glantau committed
3624 3625 3626
    { "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" },
3627
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3628
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
glantau's avatar
glantau committed
3629
      "add timings for benchmarking" },
3630
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3631
      "dump each input packet" },
3632
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3633
      "when dumping packets, also dump the payload" },
bellard's avatar
bellard committed
3634
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3635
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3636
    { "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)", "" },
3637
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
romansh's avatar
 
romansh committed
3638
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3639
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
michael's avatar
michael committed
3640 3641
    { "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", "" },
michael's avatar
michael committed
3642
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3643
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3644
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3645
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3646
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3647 3648

    /* video options */
michael's avatar
michael committed
3649 3650
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3651 3652 3653
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
    { "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" },
benoit's avatar
 
benoit committed
3654
    { "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" },
3655 3656 3657 3658
    { "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" },
3659 3660 3661 3662 3663
    { "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" },
3664 3665
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
mru's avatar
mru committed
3666
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
diego's avatar
diego committed
3667 3668
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3669
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
bellard's avatar
bellard committed
3670
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3671
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3672
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3673
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3674
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3675 3676 3677
      "use same video quality as source (implies VBR)" },
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3678
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3679 3680
      "deinterlace pictures" },
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
benoit's avatar
 
benoit committed
3681 3682
    { "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" },
3683
#ifdef CONFIG_VHOOK
3684
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3685
#endif
3686 3687
    { "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" },
michael's avatar
michael committed
3688
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3689
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
michael's avatar
michael committed
3690
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3691
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3692
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3693 3694

    /* audio options */
3695
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3696
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3697 3698 3699 3700
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
    { "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" },
michael's avatar
michael committed
3701
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3702
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3703 3704
    { "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" },
3705

3706
    /* subtitle options */
3707
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3708 3709 3710
    { "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" },
3711

3712 3713 3714
    /* 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" },
3715
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3716 3717

    /* muxer options */
3718 3719
    { "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" },
3720 3721 3722 3723

    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },

michael's avatar
michael committed
3724
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
glantau's avatar
merge  
glantau committed
3725 3726 3727
    { NULL, },
};

3728 3729
static void show_banner(void)
{
diego's avatar
diego committed
3730
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
alex's avatar
alex committed
3731
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
al's avatar
al committed
3732
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
alex's avatar
alex committed
3733 3734
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3735
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3736
#ifdef __GNUC__
alex's avatar
alex committed
3737
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
3738
#else
3739
    fprintf(stderr, ", using a non-gcc compiler\n");
3740
#endif
3741 3742
}

3743
static void opt_show_license(void)
3744
{
3745
    show_license();
diego's avatar
diego committed
3746
    exit(0);
3747 3748
}

benoit's avatar
 
benoit committed
3749 3750 3751 3752 3753 3754 3755 3756 3757
/**
 * 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);
}

3758
static void show_help(void)
bellard's avatar
bellard committed
3759
{
benoit's avatar
 
benoit committed
3760
    av_log_set_callback(log_callback_help);
michael's avatar
michael committed
3761
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
bellard's avatar
bellard committed
3762 3763
           "Hyper fast Audio and Video encoder\n");
    printf("\n");
3764 3765 3766
    show_help_options(options, "Main options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
    show_help_options(options, "\nVideo options:\n",
3767
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3768 3769
                      OPT_VIDEO);
    show_help_options(options, "\nAdvanced Video options:\n",
3770
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3771 3772
                      OPT_VIDEO | OPT_EXPERT);
    show_help_options(options, "\nAudio options:\n",
3773
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3774 3775
                      OPT_AUDIO);
    show_help_options(options, "\nAdvanced Audio options:\n",
3776
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3777
                      OPT_AUDIO | OPT_EXPERT);
3778
    show_help_options(options, "\nSubtitle options:\n",
3779
                      OPT_SUBTITLE | OPT_GRAB,
3780
                      OPT_SUBTITLE);
3781
    show_help_options(options, "\nAudio/Video grab options:\n",
3782
                      OPT_GRAB,
3783 3784
                      OPT_GRAB);
    show_help_options(options, "\nAdvanced options:\n",
3785
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3786
                      OPT_EXPERT);
3787
    av_opt_show(avctx_opts[0], NULL);
3788
    av_opt_show(avformat_opts, NULL);
benoit's avatar
benoit committed
3789
    av_opt_show(sws_opts, NULL);
bellard's avatar
bellard committed
3790 3791
}

glantau's avatar
merge  
glantau committed
3792 3793
int main(int argc, char **argv)
{
bellard's avatar
bellard committed
3794
    int i;
kabi's avatar
kabi committed
3795
    int64_t ti;
3796

3797
    av_register_all();
3798

3799 3800 3801
    for(i=0; i<CODEC_TYPE_NB; i++){
        avctx_opts[i]= avcodec_alloc_context2(i);
    }
3802
    avformat_opts = av_alloc_format_context();
benoit's avatar
benoit committed
3803
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
glantau's avatar
merge  
glantau committed
3804

benoit's avatar
benoit committed
3805
    show_banner();
3806
    if (argc <= 1) {
glantau's avatar
merge  
glantau committed
3807
        show_help();
3808 3809
        exit(1);
    }
3810

3811
    /* parse options */
3812
    parse_options(argc, argv, options, opt_output_file);
glantau's avatar
merge  
glantau committed
3813

bellard's avatar
bellard committed
3814 3815 3816 3817 3818
    /* file converter / grab */
    if (nb_output_files <= 0) {
        fprintf(stderr, "Must supply at least one output file\n");
        exit(1);
    }
3819

bellard's avatar
bellard committed
3820
    if (nb_input_files == 0) {
3821 3822
        fprintf(stderr, "Must supply at least one input file\n");
        exit(1);
3823 3824 3825
    }

    ti = getutime();
3826
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3827 3828 3829 3830
              stream_maps, nb_stream_maps);
    ti = getutime() - ti;
    if (do_benchmark) {
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
glantau's avatar
merge  
glantau committed
3831 3832 3833 3834
    }

    /* close files */
    for(i=0;i<nb_output_files;i++) {
kabi's avatar
kabi committed
3835 3836
        /* maybe av_close_output_file ??? */
        AVFormatContext *s = output_files[i];
3837
        int j;
kabi's avatar
kabi committed
3838
        if (!(s->oformat->flags & AVFMT_NOFILE))
3839
            url_fclose(&s->pb);
3840 3841
        for(j=0;j<s->nb_streams;j++) {
            av_free(s->streams[j]->codec);
3842
            av_free(s->streams[j]);
3843
        }
kabi's avatar
kabi committed
3844
        av_free(s);
glantau's avatar
merge  
glantau committed
3845
    }
3846 3847
    for(i=0;i<nb_input_files;i++)
        av_close_input_file(input_files[i]);
glantau's avatar
merge  
glantau committed
3848

3849
    av_free_static();
3850

michael's avatar
michael committed
3851 3852
    av_free(intra_matrix);
    av_free(inter_matrix);
benoit's avatar
 
benoit committed
3853 3854 3855 3856 3857

    if (fvstats)
        fclose(fvstats);
    av_free(vstats_filename);

3858
    av_free(opt_names);
3859

3860 3861 3862 3863
    av_free(video_codec_name);
    av_free(audio_codec_name);
    av_free(subtitle_codec_name);

3864 3865
    av_free(video_standard);

3866
#ifdef CONFIG_POWERPC_PERF
3867 3868
    extern void powerpc_display_perf_report(void);
    powerpc_display_perf_report();
3869
#endif /* CONFIG_POWERPC_PERF */
3870

3871 3872 3873 3874 3875 3876
    if (received_sigterm) {
        fprintf(stderr,
            "Received signal %d: terminating.\n",
            (int) received_sigterm);
        exit (255);
    }
gpoirier's avatar
gpoirier committed
3877

3878
    exit(0); /* not all OS-es handle main() return value */
glantau's avatar
merge  
glantau committed
3879 3880
    return 0;
}