ffmpeg.c 111 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 8
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
glantau's avatar
merge  
glantau committed
9
 *
10
 * This library is distributed in the hope that it will be useful,
glantau's avatar
merge  
glantau committed
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
glantau's avatar
merge  
glantau committed
14
 *
15 16 17
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
glantau's avatar
merge  
glantau committed
18
 */
glantau's avatar
glantau committed
19 20
#define HAVE_AV_CONFIG_H
#include "avformat.h"
21
#include "framehook.h"
glantau's avatar
glantau committed
22

glantau's avatar
glantau committed
23
#ifndef CONFIG_WIN32
glantau's avatar
merge  
glantau committed
24 25 26 27 28
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <termios.h>
glantau's avatar
glantau committed
29
#include <sys/resource.h>
30
#include <signal.h>
glantau's avatar
glantau committed
31
#endif
32 33 34 35 36
#ifdef CONFIG_OS2
#include <sys/types.h>
#include <sys/select.h>
#include <stdlib.h>
#endif
37
#include <time.h>
glantau's avatar
merge  
glantau committed
38

bellard's avatar
bellard committed
39 40
#include "cmdutils.h"

41 42 43
#if !defined(INFINITY) && defined(HUGE_VAL)
#define INFINITY HUGE_VAL
#endif
glantau's avatar
merge  
glantau committed
44 45 46 47 48 49 50 51 52

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

extern const OptionDef options[];

53 54
static void show_help(void);
static void show_license(void);
glantau's avatar
merge  
glantau committed
55 56 57 58 59 60 61 62 63 64 65 66

#define MAX_FILES 20

static AVFormatContext *input_files[MAX_FILES];
static int nb_input_files = 0;

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

static AVStreamMap stream_maps[MAX_FILES];
static int nb_stream_maps;

67 68
static AVInputFormat *file_iformat;
static AVOutputFormat *file_oformat;
69
static AVImageFormat *image_format;
glantau's avatar
merge  
glantau committed
70 71
static int frame_width  = 160;
static int frame_height = 128;
romansh's avatar
 
romansh committed
72
static float frame_aspect_ratio = 0;
romansh's avatar
 
romansh committed
73
static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
74 75 76 77
static int frame_topBand  = 0;
static int frame_bottomBand = 0;
static int frame_leftBand  = 0;
static int frame_rightBand = 0;
78 79
static int frame_rate = 25;
static int frame_rate_base = 1;
michaelni's avatar
michaelni committed
80 81
static int video_bit_rate = 200*1000;
static int video_bit_rate_tolerance = 4000*1000;
82
static float video_qscale = 0;
michaelni's avatar
michaelni committed
83 84
static int video_qmin = 2;
static int video_qmax = 31;
michaelni's avatar
michaelni committed
85 86
static int video_mb_qmin = 2;
static int video_mb_qmax = 31;
87 88 89
static int video_qdiff = 3;
static float video_qblur = 0.5;
static float video_qcomp = 0.5;
90 91
static uint16_t *intra_matrix = NULL;
static uint16_t *inter_matrix = NULL;
92
#if 0 //experimental, (can be removed)
michaelni's avatar
michaelni committed
93 94 95
static float video_rc_qsquish=1.0;
static float video_rc_qmod_amp=0;
static int video_rc_qmod_freq=0;
96
#endif
michaelni's avatar
michaelni committed
97 98 99 100 101 102 103 104 105
static char *video_rc_override_string=NULL;
static char *video_rc_eq="tex^qComp";
static int video_rc_buffer_size=0;
static float video_rc_buffer_aggressivity=1.0;
static int video_rc_max_rate=0;
static int video_rc_min_rate=0;
static float video_rc_initial_cplx=0;
static float video_b_qfactor = 1.25;
static float video_b_qoffset = 1.25;
106
static float video_i_qfactor = -0.8;
michaelni's avatar
michaelni committed
107
static float video_i_qoffset = 0.0;
108 109
static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
110
static int me_method = ME_EPZS;
glantau's avatar
merge  
glantau committed
111 112 113
static int video_disable = 0;
static int video_codec_id = CODEC_ID_NONE;
static int same_quality = 0;
114
static int b_frames = 0;
115
static int mb_decision = FF_MB_DECISION_SIMPLE;
michael's avatar
michael committed
116
static int ildct_cmp = FF_CMP_VSAD;
117 118 119
static int mb_cmp = FF_CMP_SAD;
static int sub_cmp = FF_CMP_SAD;
static int cmp = FF_CMP_SAD;
120 121 122 123 124 125 126
static int pre_cmp = FF_CMP_SAD;
static int pre_me = 0;
static float lumi_mask = 0;
static float dark_mask = 0;
static float scplx_mask = 0;
static float tcplx_mask = 0;
static float p_mask = 0;
127
static int use_4mv = 0;
128
static int use_obmc = 0;
129
static int use_aic = 0;
michael's avatar
michael committed
130
static int use_aiv = 0;
131
static int use_umv = 0;
michael's avatar
michael committed
132
static int use_alt_scan = 0;
133
static int use_trell = 0;
michael's avatar
michael committed
134
static int use_scan_offset = 0;
michael's avatar
michael committed
135
static int qns = 0;
136
static int closed_gop = 0;
137
static int do_deinterlace = 0;
michael's avatar
michael committed
138 139
static int do_interlace_dct = 0;
static int do_interlace_me = 0;
140 141 142
static int workaround_bugs = FF_BUG_AUTODETECT;
static int error_resilience = 2;
static int error_concealment = 3;
143
static int dct_algo = 0;
144
static int idct_algo = 0;
145 146
static int use_part = 0;
static int packet_size = 0;
michael's avatar
michael committed
147
static int error_rate = 0;
michaelni's avatar
michaelni committed
148
static int strict = 0;
michael's avatar
michael committed
149 150
static int top_field_first = -1;
static int noise_reduction = 0;
151
static int sc_threshold = 0;
michaelni's avatar
michaelni committed
152
static int debug = 0;
153
static int debug_mv = 0;
bellard's avatar
bellard committed
154
extern int loop_input; /* currently a hack */
glantau's avatar
merge  
glantau committed
155 156 157 158 159 160 161 162 163

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

kabi's avatar
kabi committed
164
static int64_t recording_time = 0;
165
static int64_t start_time = 0;
glantau's avatar
merge  
glantau committed
166 167 168 169 170
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;
glantau's avatar
glantau committed
171
static int do_benchmark = 0;
172
static int do_hex_dump = 0;
173
static int do_pkt_dump = 0;
174
static int do_psnr = 0;
175
static int do_vstats = 0;
176
static int do_pass = 0;
177
static int bitexact = 0;
178
static char *pass_logfilename = NULL;
179 180
static int audio_stream_copy = 0;
static int video_stream_copy = 0;
181

182 183
static int rate_emu = 0;

184
static char *video_grab_format = "video4linux";
185
static char *video_device = NULL;
186
static int  video_channel = 0;
187
static char *video_standard = "ntsc";
188

189
static char *audio_grab_format = "audio_device";
190
static char *audio_device = NULL;
191

192
static int using_stdin = 0;
193
static int using_vhook = 0;
194
static int verbose = 1;
195
static int thread_count= 1;
196

197
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
glantau's avatar
merge  
glantau committed
198 199 200 201 202 203

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 */
204 205 206 207 208
    int encoding_needed;     /* true if encoding needed for this stream */
    int frame_number;
    /* input pts and corresponding output pts
       for A/V sync */
    double sync_ipts;
209
    double sync_ipts_offset;
kabi's avatar
kabi committed
210
    int64_t sync_opts;
glantau's avatar
merge  
glantau committed
211
    /* video only */
212 213
    int video_resample;      /* video_resample and video_crop are mutually exclusive */
    AVPicture pict_tmp;      /* temporary image for resampling */
glantau's avatar
merge  
glantau committed
214
    ImgReSampleContext *img_resample_ctx; /* for image resampling */
215 216 217 218

    int video_crop;          /* video_resample and video_crop are mutually exclusive */
    int topBand;             /* cropping area sizes */
    int leftBand;
glantau's avatar
merge  
glantau committed
219 220 221 222 223
    
    /* audio only */
    int audio_resample;
    ReSampleContext *resample; /* for audio resampling */
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
224
    FILE *logfile;
glantau's avatar
merge  
glantau committed
225 226 227 228 229 230 231 232
} 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
233
    int64_t sample_index;      /* current sample */
234 235 236

    int64_t       start;     /* time when read started */
    unsigned long frame;     /* current frame */
237 238
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
                                is not defined */
romansh's avatar
 
romansh committed
239
    int64_t       pts;       /* current pts */
glantau's avatar
merge  
glantau committed
240 241 242 243 244 245 246 247
} AVInputStream;

typedef struct AVInputFile {
    int eof_reached;      /* true if eof reached */
    int ist_index;        /* index of first stream in ist_table */
    int buffer_size;      /* current total buffer size */
    int buffer_size_max;  /* buffer size at which we consider we can stop
                             buffering */
248
    int nb_streams;       /* nb streams we are aware of */
glantau's avatar
merge  
glantau committed
249 250
} AVInputFile;

glantau's avatar
glantau committed
251 252
#ifndef CONFIG_WIN32

glantau's avatar
merge  
glantau committed
253 254 255 256 257 258 259 260
/* init terminal so that we can grab keys */
static struct termios oldtty;

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

261 262 263 264 265 266 267 268 269
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
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
static void term_init(void)
{
    struct termios tty;

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

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

288 289 290 291 292 293
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
    /*
    register a function to be called at normal program termination
    */
glantau's avatar
merge  
glantau committed
294
    atexit(term_exit);
295 296 297
#ifdef CONFIG_BEOS_NETSERVER
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
#endif
glantau's avatar
merge  
glantau committed
298 299 300 301 302
}

/* read a key without blocking */
static int read_key(void)
{
303
    int n = 1;
glantau's avatar
merge  
glantau committed
304
    unsigned char ch;
305 306
#ifndef CONFIG_BEOS_NETSERVER
    struct timeval tv;
glantau's avatar
merge  
glantau committed
307 308 309 310 311 312 313
    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);
314
#endif
glantau's avatar
merge  
glantau committed
315
    if (n > 0) {
316 317
        n = read(0, &ch, 1);
        if (n == 1)
glantau's avatar
merge  
glantau committed
318
            return ch;
319 320

        return n;
glantau's avatar
merge  
glantau committed
321 322 323 324
    }
    return -1;
}

325
#else
glantau's avatar
merge  
glantau committed
326

327 328
static volatile int received_sigterm = 0;

329 330
/* no interactive support */
static void term_exit(void)
glantau's avatar
merge  
glantau committed
331
{
332
}
glantau's avatar
merge  
glantau committed
333

334 335 336
static void term_init(void)
{
}
glantau's avatar
merge  
glantau committed
337

338 339
static int read_key(void)
{
340
    return 0;
glantau's avatar
merge  
glantau committed
341 342
}

343
#endif
glantau's avatar
glantau committed
344

345
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
glantau's avatar
merge  
glantau committed
346
{
347
    int i, err;
glantau's avatar
merge  
glantau committed
348 349
    AVFormatContext *ic;

350 351 352
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
    if (err < 0)
        return err;
glantau's avatar
merge  
glantau committed
353 354 355 356
    /* copy stream format */
    s->nb_streams = ic->nb_streams;
    for(i=0;i<ic->nb_streams;i++) {
        AVStream *st;
michaelni's avatar
michaelni committed
357

358
        st = av_mallocz(sizeof(AVStream));
glantau's avatar
merge  
glantau committed
359 360 361 362 363 364 365 366
        memcpy(st, ic->streams[i], sizeof(AVStream));
        s->streams[i] = st;
    }

    av_close_input_file(ic);
    return 0;
}

367
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
glantau's avatar
merge  
glantau committed
368 369 370 371 372 373

static void do_audio_out(AVFormatContext *s, 
                         AVOutputStream *ost, 
                         AVInputStream *ist,
                         unsigned char *buf, int size)
{
kabi's avatar
kabi committed
374
    uint8_t *buftmp;
375 376
    static uint8_t *audio_buf = NULL;
    static uint8_t *audio_out = NULL;
michaelni's avatar
10l  
michaelni committed
377
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
378

glantau's avatar
merge  
glantau committed
379 380 381
    int size_out, frame_bytes, ret;
    AVCodecContext *enc;

382 383 384 385
    /* 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
386
        audio_out = av_malloc(audio_out_size);
387 388 389 390
    if (!audio_buf || !audio_out)
        return;               /* Should signal an error ! */

    
glantau's avatar
merge  
glantau committed
391 392 393 394 395 396 397 398 399 400 401 402 403 404
    enc = &ost->st->codec;

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

    /* now encode as many frames as possible */
405
    if (enc->frame_size > 1) {
glantau's avatar
merge  
glantau committed
406 407 408 409 410 411 412 413
        /* output resampled raw samples */
        fifo_write(&ost->fifo, buftmp, size_out, 
                   &ost->fifo.wptr);

        frame_bytes = enc->frame_size * 2 * enc->channels;
        
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
                     &ost->fifo.rptr) == 0) {
michaelni's avatar
10l  
michaelni committed
414
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
415
                                       (short *)audio_buf);
416
            av_write_frame(s, ost->index, audio_out, ret);
glantau's avatar
merge  
glantau committed
417 418
        }
    } else {
419 420 421 422 423 424 425 426 427 428 429 430 431
        /* output a pcm frame */
        /* XXX: change encoding codec API to avoid this ? */
        switch(enc->codec->id) {
        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;
        }
        ret = avcodec_encode_audio(enc, audio_out, size_out, 
432
				   (short *)buftmp);
433
        av_write_frame(s, ost->index, audio_out, ret);
glantau's avatar
merge  
glantau committed
434 435 436
    }
}

437 438 439 440 441
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
{
    AVCodecContext *dec;
    AVPicture *picture2;
    AVPicture picture_tmp;
kabi's avatar
kabi committed
442
    uint8_t *buf = 0;
443 444 445 446

    dec = &ist->st->codec;

    /* deinterlace : must be done before any resize */
447
    if (do_deinterlace || using_vhook) {
448 449 450 451 452 453 454 455 456 457 458
        int size;

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

michaelni's avatar
10l  
michaelni committed
459 460 461 462 463 464 465 466 467
        if (do_deinterlace){
            if(avpicture_deinterlace(picture2, picture, 
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
                /* if error, do not deinterlace */
                av_free(buf);
                buf = NULL;
                picture2 = picture;
            }
        } else {
468 469 470 471 472 473 474 475
            if (img_convert(picture2, dec->pix_fmt, picture, 
                            dec->pix_fmt, dec->width, dec->height) < 0) {
                /* if error, do not copy */
                av_free(buf);
                buf = NULL;
                picture2 = picture;
            }
        }
476 477 478 479 480 481 482 483 484 485 486
    } else {
        picture2 = picture;
    }

    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);

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

487 488
/* we begin to correct av delay at this threshold */
#define AV_DELAY_MAX 0.100
glantau's avatar
merge  
glantau committed
489 490 491 492

static void do_video_out(AVFormatContext *s, 
                         AVOutputStream *ost, 
                         AVInputStream *ist,
493
                         AVFrame *in_picture,
494
                         int *frame_size, AVOutputStream *audio_sync)
glantau's avatar
merge  
glantau committed
495
{
496
    int nb_frames, i, ret;
497 498
    AVPicture *final_picture, *formatted_picture;
    AVPicture picture_format_temp, picture_crop_temp;
499
    static uint8_t *video_buffer= NULL;
kabi's avatar
kabi committed
500
    uint8_t *buf = NULL, *buf1 = NULL;
501
    AVCodecContext *enc, *dec;
romansh's avatar
 
romansh committed
502
    enum PixelFormat target_pixfmt;
glantau's avatar
merge  
glantau committed
503

michaelni's avatar
 
michaelni committed
504 505
#define VIDEO_BUFFER_SIZE (1024*1024)

glantau's avatar
merge  
glantau committed
506
    enc = &ost->st->codec;
507
    dec = &ist->st->codec;
glantau's avatar
merge  
glantau committed
508

509 510 511
    /* by default, we output a single frame */
    nb_frames = 1;

512 513
    *frame_size = 0;

514 515 516 517 518
    /* NOTE: the A/V sync is always done by considering the audio is
       the master clock. It is suffisant for transcoding or playing,
       but not for the general case */
    if (audio_sync) {
        /* compute the A-V delay and duplicate/remove frames if needed */
romansh's avatar
 
romansh committed
519 520 521 522 523 524 525 526 527 528 529 530 531 532
        double adelta, vdelta, av_delay;

        adelta = audio_sync->sync_ipts - ((double)audio_sync->sync_opts * 
            s->pts_num / s->pts_den);

        vdelta = ost->sync_ipts - ((double)ost->sync_opts *
            s->pts_num / s->pts_den);

        av_delay = adelta - vdelta;
        //            printf("delay=%f\n", av_delay);
        if (av_delay < -AV_DELAY_MAX)
            nb_frames = 2;
        else if (av_delay > AV_DELAY_MAX)
            nb_frames = 0;
533 534 535
    } else {
        double vdelta;

romansh's avatar
 
romansh committed
536 537 538 539 540 541 542 543 544 545
        vdelta = (double)(ost->st->pts.val) * s->pts_num / s->pts_den - (ost->sync_ipts - ost->sync_ipts_offset);
        if (vdelta < 100 && vdelta > -100 && ost->sync_ipts_offset) {
            if (vdelta < -AV_DELAY_MAX)
                nb_frames = 2;
            else if (vdelta > AV_DELAY_MAX)
                nb_frames = 0;
        } else {
            ost->sync_ipts_offset -= vdelta;
            if (!ost->sync_ipts_offset)
                ost->sync_ipts_offset = 0.000001; /* one microsecond */
546
        }
547
    }
romansh's avatar
 
romansh committed
548 549
    
#if defined(AVSYNC_DEBUG)
550 551 552 553 554 555 556 557 558 559 560
    {
        static char *action[] = { "drop frame", "copy frame", "dup frame" };
        if (audio_sync)
            fprintf(stderr, "Input APTS %12.6f, output APTS %12.6f, ",
                    (double) audio_sync->sync_ipts, 
                    (double) audio_sync->st->pts.val * s->pts_num / s->pts_den);
        fprintf(stderr, "Input VPTS %12.6f, output VPTS %12.6f: %s\n",
                (double) ost->sync_ipts, 
                (double) ost->st->pts.val * s->pts_num / s->pts_den,
                action[nb_frames]);
    }
romansh's avatar
 
romansh committed
561 562
#endif

563
    if (nb_frames <= 0) 
glantau's avatar
merge  
glantau committed
564
        return;
565

566
    if (!video_buffer)
567 568 569
        video_buffer = av_malloc(VIDEO_BUFFER_SIZE);
    if (!video_buffer)
        return;
570

571
    /* convert pixel format if needed */
romansh's avatar
 
romansh committed
572 573
    target_pixfmt = ost->video_resample ? PIX_FMT_YUV420P : enc->pix_fmt;
    if (dec->pix_fmt != target_pixfmt) {
574 575 576
        int size;

        /* create temporary picture */
romansh's avatar
 
romansh committed
577
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
glantau's avatar
glantau committed
578
        buf = av_malloc(size);
579 580
        if (!buf)
            return;
581
        formatted_picture = &picture_format_temp;
romansh's avatar
 
romansh committed
582
        avpicture_fill(formatted_picture, buf, target_pixfmt, dec->width, dec->height);
583
        
romansh's avatar
 
romansh committed
584
        if (img_convert(formatted_picture, target_pixfmt, 
585
                        (AVPicture *)in_picture, dec->pix_fmt, 
586 587 588 589 590
                        dec->width, dec->height) < 0) {
            fprintf(stderr, "pixel format conversion not handled\n");
            goto the_end;
        }
    } else {
591
        formatted_picture = (AVPicture *)in_picture;
592 593 594 595 596
    }

    /* XXX: resampling could be done before raw format convertion in
       some cases to go faster */
    /* XXX: only works for YUV420P */
glantau's avatar
merge  
glantau committed
597
    if (ost->video_resample) {
598 599
        final_picture = &ost->pict_tmp;
        img_resample(ost->img_resample_ctx, final_picture, formatted_picture);
romansh's avatar
 
romansh committed
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
	if (enc->pix_fmt != PIX_FMT_YUV420P) {
            int size;
	    
	    av_free(buf);
            /* create temporary picture */
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
            buf = av_malloc(size);
            if (!buf)
                return;
            final_picture = &picture_format_temp;
            avpicture_fill(final_picture, buf, enc->pix_fmt, enc->width, enc->height);
        
            if (img_convert(final_picture, enc->pix_fmt, 
                            &ost->pict_tmp, PIX_FMT_YUV420P, 
                            enc->width, enc->height) < 0) {
                fprintf(stderr, "pixel format conversion not handled\n");
                goto the_end;
            }
	}
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
    } else if (ost->video_crop) {
        picture_crop_temp.data[0] = formatted_picture->data[0] +
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;

        picture_crop_temp.data[1] = formatted_picture->data[1] +
                ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
                (ost->leftBand >> 1);

        picture_crop_temp.data[2] = formatted_picture->data[2] +
                ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
                (ost->leftBand >> 1);

        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
        final_picture = &picture_crop_temp;
glantau's avatar
merge  
glantau committed
635
    } else {
636
        final_picture = formatted_picture;
glantau's avatar
merge  
glantau committed
637 638 639
    }
    /* duplicates frame if needed */
    /* XXX: pb because no interleaving */
640
    for(i=0;i<nb_frames;i++) {
641 642 643 644
        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
645 646
            AVFrame* old_frame = enc->coded_frame;
	    enc->coded_frame = dec->coded_frame;
647 648
            av_write_frame(s, ost->index, 
                           (uint8_t *)final_picture, sizeof(AVPicture));
romansh's avatar
 
romansh committed
649
	    enc->coded_frame = old_frame;
650
        } else {
michaelni's avatar
michaelni committed
651
            AVFrame big_picture;
michaelni's avatar
michaelni committed
652
            
653
            avcodec_get_frame_defaults(&big_picture);
654
            *(AVPicture*)&big_picture= *final_picture;
655 656 657
            /* better than nothing: use input picture interlaced
               settings */
            big_picture.interlaced_frame = in_picture->interlaced_frame;
michael's avatar
michael committed
658 659 660 661 662 663
            if(do_interlace_me || do_interlace_dct){
                if(top_field_first == -1)
                    big_picture.top_field_first = in_picture->top_field_first;
                else
                    big_picture.top_field_first = 1;
            }
664

glantau's avatar
merge  
glantau committed
665 666 667
            /* handles sameq here. This is not correct because it may
               not be a global option */
            if (same_quality) {
michaelni's avatar
michaelni committed
668 669 670
                big_picture.quality = ist->st->quality;
            }else
                big_picture.quality = ost->st->quality;
671
            ret = avcodec_encode_video(enc, 
michaelni's avatar
 
michaelni committed
672
                                       video_buffer, VIDEO_BUFFER_SIZE,
michaelni's avatar
michaelni committed
673
                                       &big_picture);
674
            //enc->frame_number = enc->real_pict_num;
675
            av_write_frame(s, ost->index, video_buffer, ret);
676
            *frame_size = ret;
pulento's avatar
pulento committed
677
            //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
678
            //        enc->frame_number-1, enc->real_pict_num, ret,
pulento's avatar
pulento committed
679
            //        enc->pict_type);
680 681 682 683
            /* if two pass, output log */
            if (ost->logfile && enc->stats_out) {
                fprintf(ost->logfile, "%s", enc->stats_out);
            }
glantau's avatar
merge  
glantau committed
684
        }
685
        ost->frame_number++;
glantau's avatar
merge  
glantau committed
686
    }
687
 the_end:
glantau's avatar
glantau committed
688 689
    av_free(buf);
    av_free(buf1);
glantau's avatar
merge  
glantau committed
690 691
}

692 693
static double psnr(double d){
    if(d==0) return INFINITY;
694
    return -10.0*log(d)/log(10.0);
695 696
}

697 698
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost, 
                           int frame_size)
699 700
{
    static FILE *fvstats=NULL;
kabi's avatar
kabi committed
701
    static int64_t total_size = 0;
702
    char filename[40];
703 704
    time_t today2;
    struct tm *today;
705 706
    AVCodecContext *enc;
    int frame_number;
kabi's avatar
kabi committed
707
    int64_t ti;
708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
    double ti1, bitrate, avg_bitrate;
    
    if (!fvstats) {
        today2 = time(NULL);
        today = localtime(&today2);
        sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
                                               today->tm_min,
                                               today->tm_sec);
        fvstats = fopen(filename,"w");
        if (!fvstats) {
            perror("fopen");
            exit(1);
        }
    }
    
    ti = MAXINT64;
    enc = &ost->st->codec;
    total_size += frame_size;
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
727
        frame_number = ost->frame_number;
728
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
729
        if (enc->flags&CODEC_FLAG_PSNR)
michaelni's avatar
michaelni committed
730
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
731 732
        
        fprintf(fvstats,"f_size= %6d ", frame_size);
733 734
        /* compute pts value */
        ti1 = (double)ost->st->pts.val * os->pts_num / os->pts_den;
735 736 737
        if (ti1 < 0.01)
            ti1 = 0.01;
    
738
        bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
739 740 741
        avg_bitrate = (double)(total_size * 8) / ti1 / 1000.0;
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
            (double)total_size / 1024, ti1, bitrate, avg_bitrate);
mellum's avatar
mellum committed
742
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));        
743
    }
744 745
}

746 747 748
static void print_report(AVFormatContext **output_files,
			 AVOutputStream **ost_table, int nb_ostreams,
			 int is_last_report)
749 750 751 752
{
    char buf[1024];
    AVOutputStream *ost;
    AVFormatContext *oc, *os;
kabi's avatar
kabi committed
753
    int64_t total_size;
754 755 756
    AVCodecContext *enc;
    int frame_number, vid, i;
    double bitrate, ti1, pts;
kabi's avatar
kabi committed
757
    static int64_t last_time = -1;
758 759
    
    if (!is_last_report) {
kabi's avatar
kabi committed
760
        int64_t cur_time;
761 762 763 764 765 766 767 768 769 770 771
        /* display the report every 0.5 seconds */
        cur_time = av_gettime();
        if (last_time == -1) {
            last_time = cur_time;
            return;
        } 
        if ((cur_time - last_time) < 500000)
            return;
        last_time = cur_time;
    }

772

773 774 775 776 777 778 779 780 781 782 783
    oc = output_files[0];

    total_size = url_ftell(&oc->pb);
    
    buf[0] = '\0';
    ti1 = 1e10;
    vid = 0;
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        os = output_files[ost->file_index];
        enc = &ost->st->codec;
784
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
michaelni's avatar
michaelni committed
785
            sprintf(buf + strlen(buf), "q=%2.1f ",
786
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
787
        }
788 789
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
            frame_number = ost->frame_number;
michaelni's avatar
michaelni committed
790
            sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
791
                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814
            if(is_last_report)
                sprintf(buf + strlen(buf), "L");
            if (enc->flags&CODEC_FLAG_PSNR){
                int j;
                double error, error_sum=0;
                double scale, scale_sum=0;
                char type[3]= {'Y','U','V'};
                sprintf(buf + strlen(buf), "PSNR=");
                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;
                    sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
                }
                sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
            }
815 816 817 818
            vid = 1;
        }
        /* compute min output value */
        pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
819
        if ((pts < ti1) && (pts > 0))
820 821 822 823 824
            ti1 = pts;
    }
    if (ti1 < 0.01)
        ti1 = 0.01;
    
825 826 827 828
    if (verbose || is_last_report) {
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
        
        sprintf(buf + strlen(buf), 
829 830
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
            (double)total_size / 1024, ti1, bitrate);
831 832
        
        fprintf(stderr, "%s    \r", buf);
833 834
        fflush(stderr);
    }
835 836 837
        
    if (is_last_report)
        fprintf(stderr, "\n");
838 839
}

840 841 842 843 844 845 846 847 848 849 850 851 852 853
/* pkt = NULL means EOF (needed to flush decoder buffers) */
static int output_packet(AVInputStream *ist, int ist_index,
                         AVOutputStream **ost_table, int nb_ostreams,
                         AVPacket *pkt)
{
    AVFormatContext *os;
    AVOutputStream *ost;
    uint8_t *ptr;
    int len, ret, i;
    uint8_t *data_buf;
    int data_size, got_picture;
    AVFrame picture;
    short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
    void *buffer_to_free;
854
    
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
    if (pkt && pkt->pts != AV_NOPTS_VALUE) {
        ist->pts = pkt->pts;
    } else {
        ist->pts = ist->next_pts;
    }
    
    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;
        if (ist->decoding_needed) {
            switch(ist->st->codec.codec_type) {
            case CODEC_TYPE_AUDIO:
                    /* XXX: could avoid copy if PCM 16 bits with same
                       endianness as CPU */
                ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
                                           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;
                ist->next_pts += ((int64_t)AV_TIME_BASE * data_size) / 
                    (2 * ist->st->codec.channels);
                break;
            case CODEC_TYPE_VIDEO:
                    data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
                    /* XXX: allocate picture correctly */
899 900
                    avcodec_get_frame_defaults(&picture);

901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
                    ret = avcodec_decode_video(&ist->st->codec, 
                                               &picture, &got_picture, ptr, len);
                    ist->st->quality= picture.quality;
                    if (ret < 0) 
                        goto fail_decode;
                    if (!got_picture) {
                        /* no picture yet */
                        goto discard_packet;
                    }
                    if (ist->st->codec.frame_rate_base != 0) {
                        ist->next_pts += ((int64_t)AV_TIME_BASE * 
                                          ist->st->codec.frame_rate_base) /
                            ist->st->codec.frame_rate;
                    }
                    len = 0;
                    break;
                default:
                    goto fail_decode;
                }
            } else {
                data_buf = ptr;
                data_size = len;
                ret = len;
                len = 0;
            }

            buffer_to_free = NULL;
            if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
                pre_process_video_frame(ist, (AVPicture *)&picture, 
                                        &buffer_to_free);
            }

            /* frame rate emulation */
            if (ist->st->codec.rate_emu) {
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
                int64_t now = av_gettime() - ist->start;
                if (pts > now)
                    usleep(pts - now);

                ist->frame++;
            }

#if 0
            /* 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;
                }
            }
#endif
            /* 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;

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

#if 0
                        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 * os->pts_num / os->pts_den));
#endif
                        /* set the input output pts pairs */
                        ost->sync_ipts = (double)ist->pts / AV_TIME_BASE;
                        /* XXX: take into account the various fifos,
                           in particular for audio */
                        ost->sync_opts = ost->st->pts.val;
                        //printf("ipts=%lld sync_ipts=%f sync_opts=%lld pts.val=%lld pkt->pts=%lld\n", ist->pts, ost->sync_ipts, ost->sync_opts, ost->st->pts.val, pkt->pts); 

                        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:
                                /* find an audio stream for synchro */
                                {
                                    int i;
                                    AVOutputStream *audio_sync, *ost1;
                                    audio_sync = NULL;
                                    for(i=0;i<nb_ostreams;i++) {
                                        ost1 = ost_table[i];
                                        if (ost1->file_index == ost->file_index &&
                                            ost1->st->codec.codec_type == CODEC_TYPE_AUDIO) {
                                            audio_sync = ost1;
                                            break;
                                        }
                                    }

                                    do_video_out(os, ost, ist, &picture, &frame_size, audio_sync);
                                    if (do_vstats && frame_size)
                                        do_video_stats(os, ost, frame_size);
                                }
                                break;
                            default:
                                av_abort();
                            }
                        } else {
                            AVFrame avframe;
                                                
                            /* no reencoding needed : output the packet directly */
                            /* force the input stream PTS */
                        
1013
                            avcodec_get_frame_defaults(&avframe);
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
                            ost->st->codec.coded_frame= &avframe;
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
                        
                            av_write_frame(os, ost->index, data_buf, data_size);
                            ost->st->codec.frame_number++;
                            ost->frame_number++;
                        }
                    }
                }
            av_free(buffer_to_free);
        }
 discard_packet:
    return 0;
 fail_decode:
    return -1;
}


glantau's avatar
merge  
glantau committed
1032 1033 1034 1035 1036 1037 1038 1039 1040
/*
 * 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
1041
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
glantau's avatar
merge  
glantau committed
1042 1043 1044 1045
    AVFormatContext *is, *os;
    AVCodecContext *codec, *icodec;
    AVOutputStream *ost, **ost_table = NULL;
    AVInputStream *ist, **ist_table = NULL;
glantau's avatar
glantau committed
1046
    AVInputFile *file_table;
1047
    AVFormatContext *stream_no_data;
1048
    int key;
glantau's avatar
glantau committed
1049

1050
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
glantau's avatar
glantau committed
1051 1052
    if (!file_table)
        goto fail;
glantau's avatar
merge  
glantau committed
1053 1054 1055 1056 1057 1058

    /* input stream init */
    j = 0;
    for(i=0;i<nb_input_files;i++) {
        is = input_files[i];
        file_table[i].ist_index = j;
1059
        file_table[i].nb_streams = is->nb_streams;
glantau's avatar
merge  
glantau committed
1060 1061 1062 1063 1064 1065
        j += is->nb_streams;
    }
    nb_istreams = j;

    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
    if (!ist_table)
glantau's avatar
glantau committed
1066
        goto fail;
glantau's avatar
merge  
glantau committed
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
    
    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) */
1084 1085 1086 1087 1088

            if (ist->st->codec.rate_emu) {
                ist->start = av_gettime();
                ist->frame = 0;
            }
glantau's avatar
merge  
glantau committed
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
        }
    }

    /* output stream init */
    nb_ostreams = 0;
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
        nb_ostreams += os->nb_streams;
    }
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
        exit(1);
    }

1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
    /* 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;
        
        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);
        }
    }
    
glantau's avatar
merge  
glantau committed
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
    if (!ost_table)
        goto fail;
    for(i=0;i<nb_ostreams;i++) {
        ost = av_mallocz(sizeof(AVOutputStream));
        if (!ost)
            goto fail;
        ost_table[i] = ost;
    }
    
    n = 0;
    for(k=0;k<nb_output_files;k++) {
        os = output_files[k];
        for(i=0;i<os->nb_streams;i++) {
            int found;
            ost = ost_table[n++];
            ost->file_index = k;
            ost->index = i;
            ost->st = os->streams[i];
            if (nb_stream_maps > 0) {
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index + 
                    stream_maps[n-1].stream_index;
1137 1138 1139 1140 1141 1142 1143 1144 1145
                    
                /* Sanity check that the stream types match */
                if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
                    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);
                }
                
glantau's avatar
merge  
glantau committed
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
            } else {
                /* get corresponding input stream index : we select the first one with the right type */
                found = 0;
                for(j=0;j<nb_istreams;j++) {
                    ist = ist_table[j];
                    if (ist->discard && 
                        ist->st->codec.codec_type == ost->st->codec.codec_type) {
                        ost->source_index = j;
                        found = 1;
                    }
                }
                
                if (!found) {
                    /* try again and reuse existing stream */
                    for(j=0;j<nb_istreams;j++) {
                        ist = ist_table[j];
                        if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
                            ost->source_index = j;
                            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;
        }
    }

    /* for each output stream, we compute the right encoding parameters */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        ist = ist_table[ost->source_index];

        codec = &ost->st->codec;
        icodec = &ist->st->codec;

1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
        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;
            codec->codec_tag = icodec->codec_tag;
            codec->bit_rate = icodec->bit_rate;
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
                codec->sample_rate = icodec->sample_rate;
                codec->channels = icodec->channels;
                break;
            case CODEC_TYPE_VIDEO:
                codec->frame_rate = icodec->frame_rate;
1200
                codec->frame_rate_base = icodec->frame_rate_base;
1201 1202 1203 1204 1205 1206 1207 1208 1209
                codec->width = icodec->width;
                codec->height = icodec->height;
                break;
            default:
                av_abort();
            }
        } else {
            switch(codec->codec_type) {
            case CODEC_TYPE_AUDIO:
glantau's avatar
merge  
glantau committed
1210 1211
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
                    goto fail;
1212
                
glantau's avatar
merge  
glantau committed
1213 1214 1215 1216
                if (codec->channels == icodec->channels &&
                    codec->sample_rate == icodec->sample_rate) {
                    ost->audio_resample = 0;
                } else {
1217 1218 1219 1220
                    if (codec->channels != icodec->channels &&
                        icodec->codec_id == CODEC_ID_AC3) {
                        /* Special case for 5:1 AC3 input */
                        /* and mono or stereo output      */
1221 1222 1223 1224 1225 1226 1227 1228 1229
                        /* 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;
                            ost->resample = audio_resample_init(codec->channels, icodec->channels,
                                                        codec->sample_rate, 
                                                        icodec->sample_rate);
1230 1231 1232 1233 1234
			    if(!ost->resample)
			      {
				printf("Can't resample.  Aborting.\n");
				av_abort();
			      }
1235
                        }
1236 1237 1238 1239 1240
                        /* Request specific number of channels */
                        icodec->channels = codec->channels;
                    } else {
                        ost->audio_resample = 1; 
                        ost->resample = audio_resample_init(codec->channels, icodec->channels,
glantau's avatar
merge  
glantau committed
1241 1242
                                                        codec->sample_rate, 
                                                        icodec->sample_rate);
1243 1244 1245 1246 1247
			if(!ost->resample)
			  {
			    printf("Can't resample.  Aborting.\n");
			    av_abort();
			  }
1248
                    }
glantau's avatar
merge  
glantau committed
1249 1250 1251
                }
                ist->decoding_needed = 1;
                ost->encoding_needed = 1;
1252 1253
                break;
            case CODEC_TYPE_VIDEO:
glantau's avatar
merge  
glantau committed
1254
                if (codec->width == icodec->width &&
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
                    codec->height == icodec->height &&
                    frame_topBand == 0 &&
                    frame_bottomBand == 0 &&
                    frame_leftBand == 0 &&
                    frame_rightBand == 0)
                {
                    ost->video_resample = 0;
                    ost->video_crop = 0;
                } else if ((codec->width == icodec->width -
                                (frame_leftBand + frame_rightBand)) &&
                        (codec->height == icodec->height -
                                (frame_topBand  + frame_bottomBand)))
                {
glantau's avatar
merge  
glantau committed
1268
                    ost->video_resample = 0;
1269 1270 1271
                    ost->video_crop = 1;
                    ost->topBand = frame_topBand;
                    ost->leftBand = frame_leftBand;
glantau's avatar
merge  
glantau committed
1272 1273
                } else {
                    ost->video_resample = 1;
1274
                    ost->video_crop = 0; // cropping is handled as part of resample
michael's avatar
michael committed
1275
                    if( avpicture_alloc( &ost->pict_tmp, PIX_FMT_YUV420P,
1276
                                         codec->width, codec->height ) )
glantau's avatar
merge  
glantau committed
1277 1278
                        goto fail;

1279
                    ost->img_resample_ctx = img_resample_full_init( 
glantau's avatar
merge  
glantau committed
1280
                                      ost->st->codec.width, ost->st->codec.height,
1281 1282 1283
                                      ist->st->codec.width, ist->st->codec.height,
                                      frame_topBand, frame_bottomBand,
                                      frame_leftBand, frame_rightBand);
glantau's avatar
merge  
glantau committed
1284 1285 1286
                }
                ost->encoding_needed = 1;
                ist->decoding_needed = 1;
1287 1288 1289
                break;
            default:
                av_abort();
glantau's avatar
merge  
glantau committed
1290
            }
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
            /* two pass mode */
            if (ost->encoding_needed && 
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                char logfilename[1024];
                FILE *f;
                int size;
                char *logbuffer;
                
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 
                         pass_logfilename ? 
                         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);
                    }
1324
                    size = fread(logbuffer, 1, size, f);
1325 1326 1327
                    fclose(f);
                    logbuffer[size] = '\0';
                    codec->stats_in = logbuffer;
1328 1329 1330
                }
            }
        }
glantau's avatar
merge  
glantau committed
1331 1332
    }

1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
    /* 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 */
    fprintf(stderr, "Stream mapping:\n");
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
                ist_table[ost->source_index]->file_index,
                ist_table[ost->source_index]->index,
                ost->file_index, 
                ost->index);
    }

glantau's avatar
merge  
glantau committed
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375
    /* open each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
            AVCodec *codec;
            codec = avcodec_find_encoder(ost->st->codec.codec_id);
            if (!codec) {
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n", 
                        ost->file_index, ost->index);
                exit(1);
            }
            if (avcodec_open(&ost->st->codec, codec) < 0) {
                fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n", 
                        ost->file_index, ost->index);
                exit(1);
            }
        }
    }

    /* open each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
            AVCodec *codec;
            codec = avcodec_find_decoder(ist->st->codec.codec_id);
            if (!codec) {
1376 1377
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n", 
                        ist->st->codec.codec_id, ist->file_index, ist->index);
glantau's avatar
merge  
glantau committed
1378 1379 1380 1381 1382 1383 1384
                exit(1);
            }
            if (avcodec_open(&ist->st->codec, codec) < 0) {
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
                        ist->file_index, ist->index);
                exit(1);
            }
1385 1386
            //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
            //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
glantau's avatar
merge  
glantau committed
1387 1388 1389 1390 1391 1392
        }
    }

    /* init pts */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
romansh's avatar
 
romansh committed
1393
	is = input_files[ist->file_index];
romansh's avatar
 
romansh committed
1394
        ist->pts = 0;
1395
        ist->next_pts = 0;
glantau's avatar
merge  
glantau committed
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
    }
    
    /* compute buffer size max (should use a complete heuristic) */
    for(i=0;i<nb_input_files;i++) {
        file_table[i].buffer_size_max = 2048;
    }

    /* open files and write file headers */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
1406
        if (av_write_header(os) < 0) {
1407 1408 1409 1410
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
            ret = -EINVAL;
            goto fail;
        }
glantau's avatar
merge  
glantau committed
1411 1412
    }

1413
#ifndef CONFIG_WIN32
1414 1415
    if ( !using_stdin )
        fprintf(stderr, "Press [q] to stop encoding\n");
1416 1417 1418
#endif
    term_init();

1419
    stream_no_data = 0;
1420
    key = -1;
1421

1422
    for(; received_sigterm == 0;) {
glantau's avatar
merge  
glantau committed
1423 1424
        int file_index, ist_index;
        AVPacket pkt;
1425 1426
        double pts_min;
        
glantau's avatar
merge  
glantau committed
1427
    redo:
1428
        /* if 'q' pressed, exits */
1429
        if (!using_stdin) {
1430 1431 1432 1433 1434
            /* read_key() returns 0 on EOF */
            key = read_key();
            if (key == 'q')
                break;
        }
1435

1436 1437
        /* select the stream that we must read now by looking at the
           smallest output pts */
glantau's avatar
merge  
glantau committed
1438
        file_index = -1;
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
        pts_min = 1e10;
        for(i=0;i<nb_ostreams;i++) {
            double pts;
            ost = ost_table[i];
            os = output_files[ost->file_index];
            ist = ist_table[ost->source_index];
            pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
            if (!file_table[ist->file_index].eof_reached && 
                pts < pts_min) {
                pts_min = pts;
glantau's avatar
merge  
glantau committed
1449 1450 1451 1452
                file_index = ist->file_index;
            }
        }
        /* if none, if is finished */
1453
        if (file_index < 0) {
glantau's avatar
merge  
glantau committed
1454
            break;
1455 1456
        }

glantau's avatar
merge  
glantau committed
1457
        /* finish if recording time exhausted */
1458
        if (recording_time > 0 && pts_min >= (recording_time / 1000000.0))
glantau's avatar
merge  
glantau committed
1459
            break;
1460

1461
        /* read a frame from it and output it in the fifo */
glantau's avatar
merge  
glantau committed
1462
        is = input_files[file_index];
1463
        if (av_read_frame(is, &pkt) < 0) {
glantau's avatar
merge  
glantau committed
1464 1465 1466
            file_table[file_index].eof_reached = 1;
            continue;
        }
1467

1468 1469 1470 1471 1472
        if (!pkt.size) {
            stream_no_data = is;
        } else {
            stream_no_data = 0;
        }
1473 1474
        if (do_pkt_dump) {
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1475
        }
1476 1477 1478
        /* 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)
1479
            goto discard_packet;
glantau's avatar
merge  
glantau committed
1480 1481
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
        ist = ist_table[ist_index];
1482 1483
        if (ist->discard)
            goto discard_packet;
glantau's avatar
merge  
glantau committed
1484

1485
        //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1486 1487 1488 1489 1490
        if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
            fprintf(stderr, "Error while decoding stream #%d.%d\n",
                    ist->file_index, ist->index);
            av_free_packet(&pkt);
            goto redo;
michael's avatar
michael committed
1491
        }
1492
        
1493
    discard_packet:
glantau's avatar
merge  
glantau committed
1494 1495
        av_free_packet(&pkt);
        
1496 1497
        /* 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
1498
    }
1499 1500 1501 1502 1503 1504 1505 1506 1507

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

1508
    term_exit();
glantau's avatar
merge  
glantau committed
1509 1510

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

1513 1514 1515 1516 1517 1518
    /* write the trailer if needed and close file */
    for(i=0;i<nb_output_files;i++) {
        os = output_files[i];
        av_write_trailer(os);
    }

glantau's avatar
merge  
glantau committed
1519 1520 1521 1522
    /* close each encoder */
    for(i=0;i<nb_ostreams;i++) {
        ost = ost_table[i];
        if (ost->encoding_needed) {
1523
            av_freep(&ost->st->codec.stats_in);
glantau's avatar
merge  
glantau committed
1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
            avcodec_close(&ost->st->codec);
        }
    }
    
    /* close each decoder */
    for(i=0;i<nb_istreams;i++) {
        ist = ist_table[i];
        if (ist->decoding_needed) {
            avcodec_close(&ist->st->codec);
        }
    }

    /* finished ! */
    
    ret = 0;
 fail1:
glantau's avatar
glantau committed
1540
    av_free(file_table);
glantau's avatar
glantau committed
1541

glantau's avatar
merge  
glantau committed
1542 1543 1544
    if (ist_table) {
        for(i=0;i<nb_istreams;i++) {
            ist = ist_table[i];
glantau's avatar
glantau committed
1545
            av_free(ist);
glantau's avatar
merge  
glantau committed
1546
        }
glantau's avatar
glantau committed
1547
        av_free(ist_table);
glantau's avatar
merge  
glantau committed
1548 1549 1550 1551 1552
    }
    if (ost_table) {
        for(i=0;i<nb_ostreams;i++) {
            ost = ost_table[i];
            if (ost) {
1553 1554 1555 1556
                if (ost->logfile) {
                    fclose(ost->logfile);
                    ost->logfile = NULL;
                }
1557 1558
                fifo_free(&ost->fifo); /* works even if fifo is not
                                          initialized but set to zero */
glantau's avatar
glantau committed
1559
                av_free(ost->pict_tmp.data[0]);
glantau's avatar
merge  
glantau committed
1560 1561 1562 1563
                if (ost->video_resample)
                    img_resample_close(ost->img_resample_ctx);
                if (ost->audio_resample)
                    audio_resample_close(ost->resample);
glantau's avatar
glantau committed
1564
                av_free(ost);
glantau's avatar
merge  
glantau committed
1565 1566
            }
        }
glantau's avatar
glantau committed
1567
        av_free(ost_table);
glantau's avatar
merge  
glantau committed
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
    }
    return ret;
 fail:
    ret = -ENOMEM;
    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

1597
static void opt_image_format(const char *arg)
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
{
    AVImageFormat *f;
    
    for(f = first_image_format; f != NULL; f = f->next) {
        if (!strcmp(arg, f->name))
            break;
    }
    if (!f) {
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
        exit(1);
    }
    image_format = f;
}

1612
static void opt_format(const char *arg)
glantau's avatar
merge  
glantau committed
1613
{
1614 1615 1616 1617 1618 1619
    /* compatibility stuff for pgmyuv */
    if (!strcmp(arg, "pgmyuv")) {
        opt_image_format(arg);
        arg = "image";
    }

1620 1621 1622 1623
    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
1624 1625 1626 1627
        exit(1);
    }
}

1628
static void opt_video_bitrate(const char *arg)
glantau's avatar
merge  
glantau committed
1629 1630 1631 1632
{
    video_bit_rate = atoi(arg) * 1000;
}

1633
static void opt_video_bitrate_tolerance(const char *arg)
1634 1635 1636 1637
{
    video_bit_rate_tolerance = atoi(arg) * 1000;
}

1638
static void opt_video_bitrate_max(const char *arg)
michaelni's avatar
michaelni committed
1639 1640 1641 1642
{
    video_rc_max_rate = atoi(arg) * 1000;
}

1643
static void opt_video_bitrate_min(const char *arg)
michaelni's avatar
michaelni committed
1644 1645 1646 1647
{
    video_rc_min_rate = atoi(arg) * 1000;
}

1648
static void opt_video_buffer_size(const char *arg)
michaelni's avatar
michaelni committed
1649
{
michael's avatar
michael committed
1650
    video_rc_buffer_size = atoi(arg) * 8*1024;
michaelni's avatar
michaelni committed
1651 1652
}

1653
static void opt_video_rc_eq(char *arg)
michaelni's avatar
michaelni committed
1654 1655 1656 1657
{
    video_rc_eq = arg;
}

1658
static void opt_video_rc_override_string(char *arg)
1659 1660 1661 1662
{
    video_rc_override_string = arg;
}

michaelni's avatar
michaelni committed
1663

1664
static void opt_workaround_bugs(const char *arg)
1665 1666 1667 1668
{
    workaround_bugs = atoi(arg);
}

1669
static void opt_dct_algo(const char *arg)
1670 1671 1672 1673
{
    dct_algo = atoi(arg);
}

1674
static void opt_idct_algo(const char *arg)
1675 1676 1677 1678 1679
{
    idct_algo = atoi(arg);
}


1680
static void opt_error_resilience(const char *arg)
1681 1682 1683 1684
{
    error_resilience = atoi(arg);
}

1685
static void opt_error_concealment(const char *arg)
1686 1687 1688 1689
{
    error_concealment = atoi(arg);
}

1690
static void opt_debug(const char *arg)
michaelni's avatar
michaelni committed
1691 1692 1693
{
    debug = atoi(arg);
}
1694

1695 1696 1697 1698 1699
static void opt_vismv(const char *arg)
{
    debug_mv = atoi(arg);
}
    
1700 1701 1702 1703 1704
static void opt_verbose(const char *arg)
{
    verbose = atoi(arg);
}

1705
static void opt_frame_rate(const char *arg)
glantau's avatar
merge  
glantau committed
1706
{
romansh's avatar
 
romansh committed
1707 1708 1709 1710
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
        fprintf(stderr, "Incorrect frame rate\n");
	exit(1);
    }
glantau's avatar
merge  
glantau committed
1711 1712
}

1713
static void opt_frame_crop_top(const char *arg)
1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730
{
    frame_topBand = atoi(arg); 
    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){
    	fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
        exit(1);
    }
    frame_height -= frame_topBand;
}

1731
static void opt_frame_crop_bottom(const char *arg)
1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
{
    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");
        exit(1);        
    }
    if ((frame_bottomBand) >= frame_height){
    	fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
        exit(1);
    }
    frame_height -= frame_bottomBand;
}

1749
static void opt_frame_crop_left(const char *arg)
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766
{
    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){
    	fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
        exit(1);
    }
    frame_width -= frame_leftBand;
}

1767
static void opt_frame_crop_right(const char *arg)
1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784
{
    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");
        exit(1);        
    }
    if ((frame_rightBand) >= frame_width){
    	fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
        exit(1);
    }
    frame_width -= frame_rightBand;
}

1785
static void opt_frame_size(const char *arg)
glantau's avatar
merge  
glantau committed
1786
{
romansh's avatar
 
romansh committed
1787
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
glantau's avatar
merge  
glantau committed
1788 1789 1790 1791 1792 1793 1794 1795 1796
        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);
    }
}

romansh's avatar
 
romansh committed
1797 1798 1799 1800 1801
static void opt_frame_pix_fmt(const char *arg)
{
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
}

romansh's avatar
 
romansh committed
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824
static void opt_frame_aspect_ratio(const char *arg)
{
    int x = 0, y = 0;
    double ar = 0;
    const char *p;
    
    p = strchr(arg, ':');
    if (p) {
        x = strtol(arg, (char **)&arg, 10);
	if (arg == p)
	    y = strtol(arg+1, (char **)&arg, 10);
	if (x > 0 && y > 0)
	    ar = (double)x / (double)y;
    } else
        ar = strtod(arg, (char **)&arg);

    if (!ar) {
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
	exit(1);
    }
    frame_aspect_ratio = ar;
}

1825
static void opt_gop_size(const char *arg)
glantau's avatar
merge  
glantau committed
1826 1827 1828 1829
{
    gop_size = atoi(arg);
}

1830
static void opt_b_frames(const char *arg)
1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841
{
    b_frames = atoi(arg);
    if (b_frames > FF_MAX_B_FRAMES) {
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
        exit(1);
    } else if (b_frames < 1) {
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
        exit(1);
    }
}

1842 1843 1844 1845 1846
static void opt_mb_decision(const char *arg)
{
    mb_decision = atoi(arg);
}

1847 1848 1849 1850 1851
static void opt_mb_cmp(const char *arg)
{
    mb_cmp = atoi(arg);
}

michael's avatar
michael committed
1852 1853 1854 1855 1856
static void opt_ildct_cmp(const char *arg)
{
    ildct_cmp = atoi(arg);
}

1857 1858 1859 1860 1861 1862 1863 1864 1865 1866
static void opt_sub_cmp(const char *arg)
{
    sub_cmp = atoi(arg);
}

static void opt_cmp(const char *arg)
{
    cmp = atoi(arg);
}

1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
static void opt_pre_cmp(const char *arg)
{
    pre_cmp = atoi(arg);
}

static void opt_pre_me(const char *arg)
{
    pre_me = atoi(arg);
}

static void opt_lumi_mask(const char *arg)
{
    lumi_mask = atof(arg);
}

static void opt_dark_mask(const char *arg)
{
    dark_mask = atof(arg);
}

static void opt_scplx_mask(const char *arg)
{
    scplx_mask = atof(arg);
}

static void opt_tcplx_mask(const char *arg)
{
    tcplx_mask = atof(arg);
}

static void opt_p_mask(const char *arg)
{
    p_mask = atof(arg);
}

1902
static void opt_qscale(const char *arg)
glantau's avatar
merge  
glantau committed
1903
{
1904 1905 1906 1907
    video_qscale = atof(arg);
    if (video_qscale < 0.01 ||
        video_qscale > 255) {
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
glantau's avatar
merge  
glantau committed
1908 1909 1910 1911
        exit(1);
    }
}

1912
static void opt_qmin(const char *arg)
1913 1914 1915 1916 1917 1918 1919 1920 1921
{
    video_qmin = atoi(arg);
    if (video_qmin < 0 ||
        video_qmin > 31) {
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
        exit(1);
    }
}

1922
static void opt_qmax(const char *arg)
1923 1924 1925 1926 1927 1928 1929 1930 1931
{
    video_qmax = atoi(arg);
    if (video_qmax < 0 ||
        video_qmax > 31) {
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
        exit(1);
    }
}

1932
static void opt_mb_qmin(const char *arg)
michaelni's avatar
michaelni committed
1933 1934 1935 1936 1937 1938 1939 1940 1941
{
    video_mb_qmin = atoi(arg);
    if (video_mb_qmin < 0 ||
        video_mb_qmin > 31) {
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
        exit(1);
    }
}

1942
static void opt_mb_qmax(const char *arg)
michaelni's avatar
michaelni committed
1943 1944 1945 1946 1947 1948 1949 1950 1951
{
    video_mb_qmax = atoi(arg);
    if (video_mb_qmax < 0 ||
        video_mb_qmax > 31) {
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
        exit(1);
    }
}

1952
static void opt_qdiff(const char *arg)
1953 1954 1955 1956 1957 1958 1959 1960 1961
{
    video_qdiff = atoi(arg);
    if (video_qdiff < 0 ||
        video_qdiff > 31) {
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
        exit(1);
    }
}

1962
static void opt_qblur(const char *arg)
1963 1964 1965 1966
{
    video_qblur = atof(arg);
}

1967
static void opt_qcomp(const char *arg)
1968 1969 1970
{
    video_qcomp = atof(arg);
}
glantau's avatar
merge  
glantau committed
1971

1972
static void opt_rc_initial_cplx(const char *arg)
1973 1974 1975
{
    video_rc_initial_cplx = atof(arg);
}
1976
static void opt_b_qfactor(const char *arg)
1977 1978 1979
{
    video_b_qfactor = atof(arg);
}
1980
static void opt_i_qfactor(const char *arg)
1981 1982 1983
{
    video_i_qfactor = atof(arg);
}
1984
static void opt_b_qoffset(const char *arg)
1985 1986 1987
{
    video_b_qoffset = atof(arg);
}
1988
static void opt_i_qoffset(const char *arg)
1989 1990 1991 1992
{
    video_i_qoffset = atof(arg);
}

1993 1994 1995 1996 1997 1998 1999 2000 2001
static void opt_ibias(const char *arg)
{
    video_intra_quant_bias = atoi(arg);
}
static void opt_pbias(const char *arg)
{
    video_inter_quant_bias = atoi(arg);
}

2002
static void opt_packet_size(const char *arg)
2003 2004 2005 2006
{
    packet_size= atoi(arg);
}

michael's avatar
michael committed
2007 2008 2009 2010 2011
static void opt_error_rate(const char *arg)
{
    error_rate= atoi(arg);
}

2012
static void opt_strict(const char *arg)
michaelni's avatar
michaelni committed
2013 2014 2015 2016
{
    strict= atoi(arg);
}

michael's avatar
michael committed
2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
static void opt_top_field_first(const char *arg)
{
    top_field_first= atoi(arg);
}

static void opt_noise_reduction(const char *arg)
{
    noise_reduction= atoi(arg);
}

michael's avatar
michael committed
2027 2028 2029 2030 2031
static void opt_qns(const char *arg)
{
    qns= atoi(arg);
}

2032 2033 2034 2035 2036
static void opt_sc_threshold(const char *arg)
{
    sc_threshold= atoi(arg);
}

2037 2038 2039
static void opt_thread_count(const char *arg)
{
    thread_count= atoi(arg);
2040
#if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
michael's avatar
michael committed
2041 2042
    fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
#endif
2043 2044
}

2045
static void opt_audio_bitrate(const char *arg)
glantau's avatar
merge  
glantau committed
2046 2047 2048 2049
{
    audio_bit_rate = atoi(arg) * 1000;
}

2050
static void opt_audio_rate(const char *arg)
glantau's avatar
merge  
glantau committed
2051 2052 2053 2054
{
    audio_sample_rate = atoi(arg);
}

2055
static void opt_audio_channels(const char *arg)
glantau's avatar
merge  
glantau committed
2056 2057 2058 2059
{
    audio_channels = atoi(arg);
}

2060
static void opt_video_device(const char *arg)
glantau's avatar
merge  
glantau committed
2061
{
bellard's avatar
bellard committed
2062
    video_device = av_strdup(arg);
glantau's avatar
merge  
glantau committed
2063 2064
}

2065
static void opt_video_channel(const char *arg)
2066 2067 2068 2069
{
    video_channel = strtol(arg, NULL, 0);
}

2070 2071 2072 2073 2074
static void opt_video_standard(const char *arg)
{
    video_standard = av_strdup(arg);
}

2075
static void opt_audio_device(const char *arg)
glantau's avatar
merge  
glantau committed
2076
{
bellard's avatar
bellard committed
2077
    audio_device = av_strdup(arg);
glantau's avatar
merge  
glantau committed
2078 2079
}

2080
static void opt_dv1394(const char *arg)
2081 2082
{
    video_grab_format = "dv1394";
2083
    audio_grab_format = NULL;
2084 2085
}

2086
static void opt_audio_codec(const char *arg)
glantau's avatar
merge  
glantau committed
2087 2088 2089
{
    AVCodec *p;

2090 2091
    if (!strcmp(arg, "copy")) {
        audio_stream_copy = 1;
glantau's avatar
merge  
glantau committed
2092
    } else {
2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104
        p = first_avcodec;
        while (p) {
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
                break;
            p = p->next;
        }
        if (p == NULL) {
            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
            exit(1);
        } else {
            audio_codec_id = p->id;
        }
glantau's avatar
merge  
glantau committed
2105 2106 2107
    }
}

2108
static void add_frame_hooker(const char *arg)
2109 2110 2111 2112
{
    int argc = 0;
    char *argv[64];
    int i;
bellard's avatar
bellard committed
2113
    char *args = av_strdup(arg);
2114

2115 2116
    using_vhook = 1;

2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
    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);
    }
}

glantau's avatar
merge  
glantau committed
2129 2130 2131 2132 2133
const char *motion_str[] = {
    "zero",
    "full",
    "log",
    "phods",
michaelni's avatar
michaelni committed
2134 2135
    "epzs",
    "x1",
glantau's avatar
merge  
glantau committed
2136 2137 2138
    NULL,
};

2139
static void opt_motion_estimation(const char *arg)
glantau's avatar
merge  
glantau committed
2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151
{
    const char **p;
    p = motion_str;
    for(;;) {
        if (!*p) {
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
            exit(1);
        }
        if (!strcmp(*p, arg))
            break;
        p++;
    }
2152
    me_method = (p - motion_str) + 1;
glantau's avatar
merge  
glantau committed
2153 2154
}

2155
static void opt_video_codec(const char *arg)
glantau's avatar
merge  
glantau committed
2156 2157 2158
{
    AVCodec *p;

2159 2160
    if (!strcmp(arg, "copy")) {
        video_stream_copy = 1;
glantau's avatar
merge  
glantau committed
2161
    } else {
2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173
        p = first_avcodec;
        while (p) {
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
                break;
            p = p->next;
        }
        if (p == NULL) {
            fprintf(stderr, "Unknown video codec '%s'\n", arg);
            exit(1);
        } else {
            video_codec_id = p->id;
        }
glantau's avatar
merge  
glantau committed
2174 2175 2176
    }
}

2177
static void opt_map(const char *arg)
glantau's avatar
merge  
glantau committed
2178 2179 2180 2181 2182 2183 2184 2185 2186 2187
{
    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
2188 2189

    m->stream_index = strtol(p, (char **)&p, 0);
glantau's avatar
merge  
glantau committed
2190 2191
}

2192
static void opt_recording_time(const char *arg)
glantau's avatar
merge  
glantau committed
2193 2194 2195 2196
{
    recording_time = parse_date(arg, 1);
}

2197 2198 2199 2200 2201
static void opt_start_time(const char *arg)
{
    start_time = parse_date(arg, 1);
}

2202
static void opt_input_file(const char *filename)
glantau's avatar
merge  
glantau committed
2203 2204 2205
{
    AVFormatContext *ic;
    AVFormatParameters params, *ap = &params;
2206
    int err, i, ret, rfps, rfps_base;
glantau's avatar
merge  
glantau committed
2207

bellard's avatar
bellard committed
2208 2209 2210
    if (!strcmp(filename, "-"))
        filename = "pipe:";

2211 2212 2213
    using_stdin |= !strcmp(filename, "pipe:" ) || 
                   !strcmp( filename, "/dev/stdin" );

glantau's avatar
merge  
glantau committed
2214
    /* get default parameters from command line */
2215 2216 2217 2218
    memset(ap, 0, sizeof(*ap));
    ap->sample_rate = audio_sample_rate;
    ap->channels = audio_channels;
    ap->frame_rate = frame_rate;
2219
    ap->frame_rate_base = frame_rate_base;
2220 2221
    ap->width = frame_width;
    ap->height = frame_height;
2222
    ap->image_format = image_format;
romansh's avatar
 
romansh committed
2223
    ap->pix_fmt = frame_pix_fmt;
2224 2225 2226

    /* 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
2227
    if (err < 0) {
2228
        print_error(filename, err);
glantau's avatar
merge  
glantau committed
2229 2230 2231
        exit(1);
    }
    
2232 2233 2234
    /* 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);
glantau's avatar
merge  
glantau committed
2235 2236 2237 2238 2239
    if (ret < 0) {
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
        exit(1);
    }

2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
    /* if seeking requested, we execute it */
    if (start_time != 0) {
        int64_t timestamp;

        timestamp = start_time;
        /* add the stream start time */
        if (ic->start_time != AV_NOPTS_VALUE)
            timestamp += ic->start_time;
        ret = av_seek_frame(ic, -1, timestamp);
        if (ret < 0) {
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
                    filename, (double)timestamp / AV_TIME_BASE);
        }
        /* reset seek info */
        start_time = 0;
    }

glantau's avatar
merge  
glantau committed
2257 2258 2259
    /* update the current parameters so that they match the one of the input stream */
    for(i=0;i<ic->nb_streams;i++) {
        AVCodecContext *enc = &ic->streams[i]->codec;
michael's avatar
michael committed
2260 2261 2262 2263 2264
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
        if(thread_count>1)
            avcodec_thread_init(enc, thread_count);
#endif
        enc->thread_count= thread_count;
glantau's avatar
merge  
glantau committed
2265 2266
        switch(enc->codec_type) {
        case CODEC_TYPE_AUDIO:
2267
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
glantau's avatar
merge  
glantau committed
2268 2269 2270 2271 2272 2273
            audio_channels = enc->channels;
            audio_sample_rate = enc->sample_rate;
            break;
        case CODEC_TYPE_VIDEO:
            frame_height = enc->height;
            frame_width = enc->width;
michael's avatar
michael committed
2274
	    frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
romansh's avatar
 
romansh committed
2275
	    frame_pix_fmt = enc->pix_fmt;
2276 2277
            rfps      = ic->streams[i]->r_frame_rate;
            rfps_base = ic->streams[i]->r_frame_rate_base;
2278
            enc->workaround_bugs = workaround_bugs;
2279
            enc->error_resilience = error_resilience; 
2280
            enc->error_concealment = error_concealment; 
2281 2282 2283
            enc->idct_algo = idct_algo;
            enc->debug = debug;
            enc->debug_mv = debug_mv;            
2284 2285
            if(bitexact)
                enc->flags|= CODEC_FLAG_BITEXACT;
2286

2287 2288
            assert(enc->frame_rate_base == rfps_base); // should be true for now
            if (enc->frame_rate != rfps) { 
2289
                fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2290 2291
                    i, (float)enc->frame_rate / enc->frame_rate_base,
                    (float)rfps / rfps_base);
2292
            }
2293
            /* update the current frame rate to match the stream frame rate */
2294 2295
            frame_rate      = rfps;
            frame_rate_base = rfps_base;
2296 2297

            enc->rate_emu = rate_emu;
glantau's avatar
merge  
glantau committed
2298
            break;
2299 2300
        case CODEC_TYPE_DATA:
            break;
2301
        default:
2302
            av_abort();
glantau's avatar
merge  
glantau committed
2303 2304 2305 2306 2307 2308 2309
        }
    }
    
    input_files[nb_input_files] = ic;
    /* dump the file content */
    dump_format(ic, nb_input_files, filename, 0);
    nb_input_files++;
2310 2311
    file_iformat = NULL;
    file_oformat = NULL;
2312
    image_format = NULL;
2313 2314

    rate_emu = 0;
glantau's avatar
merge  
glantau committed
2315 2316
}

2317
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334
{
    int has_video, has_audio, i, j;
    AVFormatContext *ic;

    has_video = 0;
    has_audio = 0;
    for(j=0;j<nb_input_files;j++) {
        ic = input_files[j];
        for(i=0;i<ic->nb_streams;i++) {
            AVCodecContext *enc = &ic->streams[i]->codec;
            switch(enc->codec_type) {
            case CODEC_TYPE_AUDIO:
                has_audio = 1;
                break;
            case CODEC_TYPE_VIDEO:
                has_video = 1;
                break;
2335
            default:
2336
                av_abort();
2337 2338 2339 2340 2341 2342 2343
            }
        }
    }
    *has_video_ptr = has_video;
    *has_audio_ptr = has_audio;
}

2344
static void opt_output_file(const char *filename)
glantau's avatar
merge  
glantau committed
2345 2346 2347
{
    AVStream *st;
    AVFormatContext *oc;
2348
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
glantau's avatar
merge  
glantau committed
2349
    int codec_id;
2350
    AVFormatParameters params, *ap = &params;
glantau's avatar
merge  
glantau committed
2351 2352 2353 2354

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

2355
    oc = av_alloc_format_context();
glantau's avatar
merge  
glantau committed
2356

2357 2358 2359 2360 2361 2362 2363
    if (!file_oformat) {
        file_oformat = guess_format(NULL, filename, NULL);
        if (!file_oformat) {
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
                    filename);
            exit(1);
        }
glantau's avatar
merge  
glantau committed
2364 2365
    }
    
2366
    oc->oformat = file_oformat;
glantau's avatar
merge  
glantau committed
2367

2368
    if (!strcmp(file_oformat->name, "ffm") && 
glantau's avatar
merge  
glantau committed
2369 2370 2371 2372 2373 2374 2375 2376
        strstart(filename, "http:", NULL)) {
        /* 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 {
2377 2378
        use_video = file_oformat->video_codec != CODEC_ID_NONE;
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE;
2379

2380 2381 2382 2383 2384 2385 2386 2387 2388
        /* disable if no corresponding type found and at least one
           input file */
        if (nb_input_files > 0) {
            check_audio_video_inputs(&input_has_video, &input_has_audio);
            if (!input_has_video)
                use_video = 0;
            if (!input_has_audio)
                use_audio = 0;
        }
2389 2390

        /* manual disable */
glantau's avatar
merge  
glantau committed
2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406
        if (audio_disable) {
            use_audio = 0;
        }
        if (video_disable) {
            use_video = 0;
        }
        
        nb_streams = 0;
        if (use_video) {
            AVCodecContext *video_enc;
            
            st = av_mallocz(sizeof(AVStream));
            if (!st) {
                fprintf(stderr, "Could not alloc stream\n");
                exit(1);
            }
michaelni's avatar
michaelni committed
2407
            avcodec_get_context_defaults(&st->codec);
2408
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2409
            if(thread_count>1)
2410
                avcodec_thread_init(&st->codec, thread_count);
2411
#endif
glantau's avatar
merge  
glantau committed
2412

2413
            video_enc = &st->codec;
2414 2415 2416
            
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
                video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2417 2418 2419 2420
            if (video_stream_copy) {
                st->stream_copy = 1;
                video_enc->codec_type = CODEC_TYPE_VIDEO;
            } else {
2421 2422 2423
                char *p;
                int i;
            
2424 2425 2426 2427 2428 2429 2430 2431 2432
                codec_id = file_oformat->video_codec;
                if (video_codec_id != CODEC_ID_NONE)
                    codec_id = video_codec_id;
                
                video_enc->codec_id = codec_id;
                
                video_enc->bit_rate = video_bit_rate;
                video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
                video_enc->frame_rate = frame_rate; 
2433
                video_enc->frame_rate_base = frame_rate_base; 
2434 2435 2436
                
                video_enc->width = frame_width;
                video_enc->height = frame_height;
michael's avatar
10l  
michael committed
2437
		video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
romansh's avatar
 
romansh committed
2438
		video_enc->pix_fmt = frame_pix_fmt;
2439 2440 2441 2442 2443 2444 2445

                if (!intra_only)
                    video_enc->gop_size = gop_size;
                else
                    video_enc->gop_size = 0;
                if (video_qscale || same_quality) {
                    video_enc->flags |= CODEC_FLAG_QSCALE;
2446
                    st->quality = FF_QP2LAMBDA * video_qscale;
2447
                }
2448 2449 2450 2451 2452 2453

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

2454 2455 2456
                if(bitexact)
                    video_enc->flags |= CODEC_FLAG_BITEXACT;

2457
                video_enc->mb_decision = mb_decision;
2458
                video_enc->mb_cmp = mb_cmp;
michael's avatar
michael committed
2459
                video_enc->ildct_cmp = ildct_cmp;
2460 2461
                video_enc->me_sub_cmp = sub_cmp;
                video_enc->me_cmp = cmp;
2462 2463 2464 2465 2466 2467 2468
                video_enc->me_pre_cmp = pre_cmp;
                video_enc->pre_me = pre_me;
                video_enc->lumi_masking = lumi_mask;
                video_enc->dark_masking = dark_mask;
                video_enc->spatial_cplx_masking = scplx_mask;
                video_enc->temporal_cplx_masking = tcplx_mask;
                video_enc->p_masking = p_mask;
michael's avatar
michael committed
2469
                video_enc->quantizer_noise_shaping= qns;
2470
                
2471 2472 2473 2474 2475 2476
                if (use_umv) {
                    video_enc->flags |= CODEC_FLAG_H263P_UMV;
                }
           	if (use_aic) {
                    video_enc->flags |= CODEC_FLAG_H263P_AIC;
                }
michael's avatar
michael committed
2477 2478 2479
           	if (use_aiv) {
                    video_enc->flags |= CODEC_FLAG_H263P_AIV;
                }
2480 2481 2482
                if (use_4mv) {
                    video_enc->flags |= CODEC_FLAG_4MV;
                }
2483 2484 2485 2486
                if (use_obmc) {
                    video_enc->flags |= CODEC_FLAG_OBMC;
                }
            
2487
                if(use_part) {
2488
                    video_enc->flags |= CODEC_FLAG_PART;
2489
                }
michael's avatar
michael committed
2490 2491 2492
           	if (use_alt_scan) {
                    video_enc->flags |= CODEC_FLAG_ALT_SCAN;
                }
2493 2494 2495
           	if (use_trell) {
                    video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
                }
michael's avatar
michael committed
2496 2497 2498
           	if (use_scan_offset) {
                    video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
                }
2499 2500 2501
           	if (closed_gop) {
                    video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
                }
2502 2503 2504 2505
                if (b_frames) {
                    video_enc->max_b_frames = b_frames;
                    video_enc->b_frame_strategy = 0;
                    video_enc->b_quant_factor = 2.0;
2506
                }
michael's avatar
michael committed
2507
                if (do_interlace_dct) {
2508 2509
                    video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
                }
michael's avatar
michael committed
2510 2511 2512
                if (do_interlace_me) {
                    video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
                }
2513 2514
                video_enc->qmin = video_qmin;
                video_enc->qmax = video_qmax;
michaelni's avatar
michaelni committed
2515 2516
                video_enc->mb_qmin = video_mb_qmin;
                video_enc->mb_qmax = video_mb_qmax;
2517 2518 2519 2520
                video_enc->max_qdiff = video_qdiff;
                video_enc->qblur = video_qblur;
                video_enc->qcompress = video_qcomp;
                video_enc->rc_eq = video_rc_eq;
2521
                video_enc->debug = debug;
2522 2523
                video_enc->debug_mv = debug_mv;
                video_enc->thread_count = thread_count;
2524 2525 2526 2527 2528 2529 2530 2531 2532
                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);
                    }
                    video_enc->rc_override= 
bellard's avatar
bellard committed
2533 2534
                        av_realloc(video_enc->rc_override, 
                                   sizeof(RcOverride)*(i+1));
2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549
                    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;

2550 2551 2552 2553
                video_enc->rc_max_rate = video_rc_max_rate;
                video_enc->rc_min_rate = video_rc_min_rate;
                video_enc->rc_buffer_size = video_rc_buffer_size;
                video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
2554
                video_enc->rc_initial_cplx= video_rc_initial_cplx;
2555 2556 2557 2558
                video_enc->i_quant_factor = video_i_qfactor;
                video_enc->b_quant_factor = video_b_qfactor;
                video_enc->i_quant_offset = video_i_qoffset;
                video_enc->b_quant_offset = video_b_qoffset;
2559 2560
                video_enc->intra_quant_bias = video_intra_quant_bias;
                video_enc->inter_quant_bias = video_inter_quant_bias;
2561 2562
                video_enc->dct_algo = dct_algo;
                video_enc->idct_algo = idct_algo;
michaelni's avatar
michaelni committed
2563
                video_enc->strict_std_compliance = strict;
michael's avatar
michael committed
2564
                video_enc->error_rate = error_rate;
michael's avatar
michael committed
2565
                video_enc->noise_reduction= noise_reduction;
2566
                video_enc->scenechange_threshold= sc_threshold;
2567 2568 2569 2570
                if(packet_size){
                    video_enc->rtp_mode= 1;
                    video_enc->rtp_payload_size= packet_size;
                }
2571
            
2572
                if (do_psnr)
2573
                    video_enc->flags|= CODEC_FLAG_PSNR;
2574
            
2575
                video_enc->me_method = me_method;
2576

2577 2578 2579 2580 2581 2582 2583
                /* two pass mode */
                if (do_pass) {
                    if (do_pass == 1) {
                        video_enc->flags |= CODEC_FLAG_PASS1;
                    } else {
                        video_enc->flags |= CODEC_FLAG_PASS2;
                    }
2584
                }
2585
            }
glantau's avatar
merge  
glantau committed
2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597
            oc->streams[nb_streams] = st;
            nb_streams++;
        }
    
        if (use_audio) {
            AVCodecContext *audio_enc;

            st = av_mallocz(sizeof(AVStream));
            if (!st) {
                fprintf(stderr, "Could not alloc stream\n");
                exit(1);
            }
michaelni's avatar
michaelni committed
2598
            avcodec_get_context_defaults(&st->codec);
2599
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2600
            if(thread_count>1)
2601
                avcodec_thread_init(&st->codec, thread_count);
2602
#endif
2603

glantau's avatar
merge  
glantau committed
2604 2605
            audio_enc = &st->codec;
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
2606 2607 2608

            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
                audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2609 2610 2611 2612 2613 2614 2615 2616 2617 2618
            if (audio_stream_copy) {
                st->stream_copy = 1;
            } else {
                codec_id = file_oformat->audio_codec;
                if (audio_codec_id != CODEC_ID_NONE)
                    codec_id = audio_codec_id;
                audio_enc->codec_id = codec_id;
                
                audio_enc->bit_rate = audio_bit_rate;
                audio_enc->sample_rate = audio_sample_rate;
2619
                audio_enc->strict_std_compliance = strict;
2620
                audio_enc->thread_count = thread_count;
2621 2622 2623 2624 2625 2626 2627
                /* For audio codecs other than AC3 we limit */
                /* the number of coded channels to stereo   */
                if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
                    audio_enc->channels = 2;
                } else
                    audio_enc->channels = audio_channels;
            }
glantau's avatar
merge  
glantau committed
2628 2629 2630 2631 2632 2633 2634
            oc->streams[nb_streams] = st;
            nb_streams++;
        }

        oc->nb_streams = nb_streams;

        if (!nb_streams) {
2635
            fprintf(stderr, "No audio or video streams available\n");
glantau's avatar
merge  
glantau committed
2636 2637 2638 2639
            exit(1);
        }

        if (str_title)
2640
            pstrcpy(oc->title, sizeof(oc->title), str_title);
glantau's avatar
merge  
glantau committed
2641
        if (str_author)
2642
            pstrcpy(oc->author, sizeof(oc->author), str_author);
glantau's avatar
merge  
glantau committed
2643
        if (str_copyright)
2644
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
glantau's avatar
merge  
glantau committed
2645
        if (str_comment)
2646
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
glantau's avatar
merge  
glantau committed
2647 2648
    }

2649
    output_files[nb_output_files++] = oc;
glantau's avatar
merge  
glantau committed
2650 2651

    strcpy(oc->filename, filename);
2652 2653

    /* check filename in case of an image number is expected */
2654 2655 2656
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
        if (filename_number_test(oc->filename) < 0) {
            print_error(oc->filename, AVERROR_NUMEXPECTED);
2657
            exit(1);
2658
        }
2659 2660
    }

2661
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
glantau's avatar
merge  
glantau committed
2662 2663 2664 2665 2666 2667 2668
        /* test if it already exists to avoid loosing precious files */
        if (!file_overwrite && 
            (strchr(filename, ':') == NULL ||
             strstart(filename, "file:", NULL))) {
            if (url_exist(filename)) {
                int c;
                
2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679
                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);
                    }
				}
				else {
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
glantau's avatar
merge  
glantau committed
2680
                    exit(1);
2681
				}
glantau's avatar
merge  
glantau committed
2682 2683 2684 2685 2686 2687 2688 2689 2690 2691
            }
        }
        
        /* open the file */
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
            fprintf(stderr, "Could not open '%s'\n", filename);
            exit(1);
        }
    }

2692 2693 2694 2695 2696 2697 2698 2699
    memset(ap, 0, sizeof(*ap));
    ap->image_format = image_format;
    if (av_set_parameters(oc, ap) < 0) {
        fprintf(stderr, "%s: Invalid encoding parameters\n",
                oc->filename);
        exit(1);
    }

glantau's avatar
merge  
glantau committed
2700
    /* reset some options */
2701 2702
    file_oformat = NULL;
    file_iformat = NULL;
2703
    image_format = NULL;
glantau's avatar
merge  
glantau committed
2704 2705 2706 2707
    audio_disable = 0;
    video_disable = 0;
    audio_codec_id = CODEC_ID_NONE;
    video_codec_id = CODEC_ID_NONE;
2708 2709
    audio_stream_copy = 0;
    video_stream_copy = 0;
glantau's avatar
merge  
glantau committed
2710 2711
}

2712
/* prepare dummy protocols for grab */
2713
static void prepare_grab(void)
2714 2715 2716 2717
{
    int has_video, has_audio, i, j;
    AVFormatContext *oc;
    AVFormatContext *ic;
2718
    AVFormatParameters vp1, *vp = &vp1;
2719
    AVFormatParameters ap1, *ap = &ap1;
2720
    
2721 2722 2723 2724
    /* see if audio/video inputs are needed */
    has_video = 0;
    has_audio = 0;
    memset(ap, 0, sizeof(*ap));
2725
    memset(vp, 0, sizeof(*vp));
2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738
    for(j=0;j<nb_output_files;j++) {
        oc = output_files[j];
        for(i=0;i<oc->nb_streams;i++) {
            AVCodecContext *enc = &oc->streams[i]->codec;
            switch(enc->codec_type) {
            case CODEC_TYPE_AUDIO:
                if (enc->sample_rate > ap->sample_rate)
                    ap->sample_rate = enc->sample_rate;
                if (enc->channels > ap->channels)
                    ap->channels = enc->channels;
                has_audio = 1;
                break;
            case CODEC_TYPE_VIDEO:
2739 2740 2741 2742
                if (enc->width > vp->width)
                    vp->width = enc->width;
                if (enc->height > vp->height)
                    vp->height = enc->height;
2743 2744 2745 2746 2747 2748
                
                assert(enc->frame_rate_base == DEFAULT_FRAME_RATE_BASE);
                if (enc->frame_rate > vp->frame_rate){
                    vp->frame_rate      = enc->frame_rate;
                    vp->frame_rate_base = enc->frame_rate_base;
                }
2749 2750
                has_video = 1;
                break;
2751
            default:
2752
                av_abort();
2753 2754 2755 2756 2757 2758 2759 2760 2761 2762
            }
        }
    }
    
    if (has_video == 0 && has_audio == 0) {
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
        exit(1);
    }
    
    if (has_video) {
2763
        AVInputFormat *fmt1;
2764
        fmt1 = av_find_input_format(video_grab_format);
2765 2766
        vp->device  = video_device;
        vp->channel = video_channel;
2767
	vp->standard = video_standard;
2768
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
2769
            fprintf(stderr, "Could not find video grab device\n");
2770 2771
            exit(1);
        }
romansh's avatar
 
romansh committed
2772 2773 2774 2775 2776 2777
        /* If not enough info to get the stream parameters, we decode the
           first frames to get it. */
	if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
            fprintf(stderr, "Could not find video grab parameters\n");
            exit(1);
        }
2778
        /* by now video grab has one stream */
2779 2780
        ic->streams[0]->r_frame_rate      = vp->frame_rate;
        ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
2781
        input_files[nb_input_files] = ic;
2782
        dump_format(ic, nb_input_files, "", 0);
2783 2784
        nb_input_files++;
    }
2785
    if (has_audio && audio_grab_format) {
2786
        AVInputFormat *fmt1;
2787
        fmt1 = av_find_input_format(audio_grab_format);
2788
        ap->device = audio_device;
2789
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
2790
            fprintf(stderr, "Could not find audio grab device\n");
2791 2792 2793
            exit(1);
        }
        input_files[nb_input_files] = ic;
2794
        dump_format(ic, nb_input_files, "", 0);
2795 2796 2797 2798
        nb_input_files++;
    }
}

2799
/* same option as mencoder */
2800
static void opt_pass(const char *pass_str)
2801 2802 2803 2804 2805 2806 2807 2808 2809
{
    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;
}
2810

2811
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
kabi's avatar
kabi committed
2812
static int64_t getutime(void)
glantau's avatar
glantau committed
2813
{
2814
  return av_gettime();
glantau's avatar
glantau committed
2815
}
glantau's avatar
glantau committed
2816
#else
kabi's avatar
kabi committed
2817
static int64_t getutime(void)
glantau's avatar
glantau committed
2818
{
2819 2820 2821 2822
    struct rusage rusage;

    getrusage(RUSAGE_SELF, &rusage);
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
glantau's avatar
glantau committed
2823 2824
}
#endif
glantau's avatar
glantau committed
2825

2826 2827
extern int ffm_nopts;

2828
static void opt_bitexact(void)
2829
{
2830
    bitexact=1;
2831 2832 2833 2834
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
    ffm_nopts = 1;
}

2835
static void show_formats(void)
glantau's avatar
merge  
glantau committed
2836
{
2837 2838
    AVInputFormat *ifmt;
    AVOutputFormat *ofmt;
2839
    AVImageFormat *image_fmt;
glantau's avatar
merge  
glantau committed
2840
    URLProtocol *up;
michael's avatar
michael committed
2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875
    AVCodec *p, *p2;
    const char **pp, *last_name;

    printf("File formats:\n");
    last_name= "000";
    for(;;){
        int decode=0;
        int encode=0;
        const char *name=NULL;

        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;
                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;
                encode=0;
            }
            if(name && strcmp(ifmt->name, name)==0)
                decode=1;
        }
        if(name==NULL)
            break;
        last_name= name;
        
        printf(
            " %s%s %s\n", 
            decode ? "D":" ", 
            encode ? "E":" ", 
            name);
2876 2877 2878
    }
    printf("\n");

michael's avatar
michael committed
2879
    printf("Image formats:\n");
2880 2881
    for(image_fmt = first_image_format; image_fmt != NULL; 
        image_fmt = image_fmt->next) {
michael's avatar
michael committed
2882 2883 2884 2885 2886
        printf(
            " %s%s %s\n",
            image_fmt->img_read  ? "D":" ",
            image_fmt->img_write ? "E":" ",
            image_fmt->name);
2887 2888 2889
    }
    printf("\n");

glantau's avatar
merge  
glantau committed
2890
    printf("Codecs:\n");
michael's avatar
michael committed
2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925
    last_name= "000";
    for(;;){
        int decode=0;
        int encode=0;
        int cap=0;

        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;
        
        printf(
            " %s%s%s%s%s%s %s", 
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
            encode ? "E":" ", 
            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
            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
2926 2927 2928
    }
    printf("\n");

michael's avatar
michael committed
2929
    printf("Supported file protocols:\n");
glantau's avatar
merge  
glantau committed
2930 2931 2932 2933
    for(up = first_protocol; up != NULL; up = up->next)
        printf(" %s:", up->name);
    printf("\n");
    
michael's avatar
michael committed
2934 2935
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
    printf("Motion estimation methods:\n");
glantau's avatar
merge  
glantau committed
2936 2937 2938
    pp = motion_str;
    while (*pp) {
        printf(" %s", *pp);
2939
        if ((pp - motion_str + 1) == ME_ZERO) 
glantau's avatar
merge  
glantau committed
2940
            printf("(fastest)");
2941
        else if ((pp - motion_str + 1) == ME_FULL) 
glantau's avatar
merge  
glantau committed
2942
            printf("(slowest)");
2943
        else if ((pp - motion_str + 1) == ME_EPZS) 
glantau's avatar
merge  
glantau committed
2944 2945 2946
            printf("(default)");
        pp++;
    }
michael's avatar
michael committed
2947 2948 2949 2950 2951 2952 2953
    printf("\n\n");
    printf(
"Note, the names of encoders and decoders dont always match, so there are\n"
"several cases where the above table shows encoder only or decoder only entries\n"
"even though both encoding and decoding are supported for example, the h263\n"
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
"worse\n");
glantau's avatar
merge  
glantau committed
2954 2955 2956
    exit(1);
}

2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985
void parse_matrix_coeffs(uint16_t *dest, const char *str)
{
    int i;
    const char *p = str;
    for(i = 0;; i++) {
        dest[i] = atoi(p);
        if(i == 63)
            break;
        p = strchr(p, ',');
        if(!p) {
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
            exit(1);
        }
        p++;
    }
}

void opt_inter_matrix(const char *arg)
{
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(inter_matrix, arg);
}

void opt_intra_matrix(const char *arg)
{
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
    parse_matrix_coeffs(intra_matrix, arg);
}

2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
static void opt_target(const char *arg)
{
    int norm = -1;

    if(!strncmp(arg, "pal-", 4)) {
        norm = 0;
        arg += 4;
    } else if(!strncmp(arg, "ntsc-", 5)) {
        norm = 1;
        arg += 5;
    } else {
        int fr;
        /* Calculate FR via float to avoid int overflow */
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
        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++) {
                        AVCodecContext *c = &input_files[j]->streams[i]->codec;
                        if(c->codec_type != CODEC_TYPE_VIDEO)
                            continue;
                        fr = c->frame_rate * 1000 / c->frame_rate_base;
                        if(fr == 25000) {
                            norm = 0;
                            break;
                        } else if((fr == 29970) || (fr == 23976)) {
                            norm = 1;
                            break;
                        }
                    }
                    if(norm >= 0)
                        break;
                }
            }
        }
        if(verbose && norm >= 0)
            printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
    }

    if(norm < 0) {
        fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
        fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
        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");

        video_bit_rate = 1150000;
        video_rc_max_rate = 1150000;
        video_rc_min_rate = 1150000;
michael's avatar
michael committed
3049
        video_rc_buffer_size = 40*1024*8;
3050 3051 3052 3053 3054 3055 3056 3057

        audio_bit_rate = 224000;
        audio_sample_rate = 44100;

    } else if(!strcmp(arg, "svcd")) {

        opt_video_codec("mpeg2video");
        opt_audio_codec("mp2");
3058
        opt_format("svcd");
3059 3060 3061 3062 3063 3064

        opt_frame_size(norm ? "480x480" : "480x576");
        opt_gop_size(norm ? "18" : "15");

        video_bit_rate = 2040000;
        video_rc_max_rate = 2516000;
3065
        video_rc_min_rate = 0; //1145000;
michael's avatar
michael committed
3066
        video_rc_buffer_size = 224*1024*8;
michael's avatar
michael committed
3067
        use_scan_offset = 1;
3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082

        audio_bit_rate = 224000;
        audio_sample_rate = 44100;

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

        opt_video_codec("mpeg2video");
        opt_audio_codec("ac3");
        opt_format("vob");

        opt_frame_size(norm ? "720x480" : "720x576");
        opt_gop_size(norm ? "18" : "15");

        video_bit_rate = 6000000;
        video_rc_max_rate = 9000000;
3083
        video_rc_min_rate = 0; //1500000;
michael's avatar
michael committed
3084
        video_rc_buffer_size = 224*1024*8;
3085 3086 3087 3088 3089 3090 3091 3092 3093 3094

        audio_bit_rate = 448000;
        audio_sample_rate = 48000;

    } else {
        fprintf(stderr, "Unknown target: %s\n", arg);
        exit(1);
    }
}

glantau's avatar
merge  
glantau committed
3095
const OptionDef options[] = {
3096 3097
    /* main options */
    { "L", 0, {(void*)show_license}, "show license" },
glantau's avatar
glantau committed
3098 3099 3100
    { "h", 0, {(void*)show_help}, "show help" },
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3101
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
glantau's avatar
glantau committed
3102 3103 3104 3105
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3106
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
glantau's avatar
glantau committed
3107 3108 3109 3110
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
    { "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" },
michaelni's avatar
10l  
michaelni committed
3111
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3112
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
glantau's avatar
glantau committed
3113
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
glantau's avatar
glantau committed
3114
      "add timings for benchmarking" },
3115
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
3116
      "dump each input packet" },
3117 3118
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
      "when dumping packets, also dump the payload" },
3119
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
bellard's avatar
bellard committed
3120 3121
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3122
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3123
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
3124
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151

    /* video options */
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
    { "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" },
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
    { "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" },
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
    { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
    { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3152 3153
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3154 3155
//    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
bellard's avatar
bellard committed
3156
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3157 3158 3159
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
michael's avatar
michael committed
3160
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kByte)", "size" },
3161 3162 3163 3164 3165 3166
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
      "method" },
    { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
    { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
    { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
bellard's avatar
bellard committed
3167
    { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3168
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3169 3170
    { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
    { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3171
    { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
michael's avatar
michael committed
3172
    { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3173 3174
    { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
    { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3175 3176 3177 3178 3179 3180 3181
    { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
    { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
    { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
    { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
    { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "teporal complexity masking", "" },
    { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3182
    { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3183
    { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3184
    { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3185 3186
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
michael's avatar
michael committed
3187
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3188 3189 3190 3191 3192 3193 3194
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standarts", "strictness" },
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
      "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" },
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
      "deinterlace pictures" },
michael's avatar
michael committed
3195 3196 3197 3198
    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 
      "force interlaced dct support in encoder (MPEG2/MPEG4)" },
    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 
      "force interlacied me support in encoder MPEG2" },
3199 3200 3201 3202
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
    { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
michael's avatar
michael committed
3203
    { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3204
    { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
michael's avatar
michael committed
3205
    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (mpeg2)" },
3206
    { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3207
    { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
michael's avatar
michael committed
3208
    { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3209 3210
    { "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
3211 3212
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
michael's avatar
michael committed
3213
    { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3214
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228

    /* audio options */
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
    { "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" },

    /* grab options */
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
    { "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" },
    { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
glantau's avatar
merge  
glantau committed
3229 3230 3231
    { NULL, },
};

3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258
static void show_banner(void)
{
    printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2003 Fabrice Bellard\n");
}

static void show_license(void)
{
    show_banner();
    printf(
    "This library is free software; you can redistribute it and/or\n"
    "modify it under the terms of the GNU Lesser General Public\n"
    "License as published by the Free Software Foundation; either\n"
    "version 2 of the License, or (at your option) any later version.\n"
    "\n"
    "This library is distributed in the hope that it will be useful,\n"
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
    "Lesser General Public License for more details.\n"
    "\n"
    "You should have received a copy of the GNU Lesser General Public\n"
    "License along with this library; if not, write to the Free Software\n"
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
    );
    exit(1);
}

static void show_help(void)
bellard's avatar
bellard committed
3259
{
3260
    show_banner();
bellard's avatar
bellard committed
3261 3262 3263
    printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
           "Hyper fast Audio and Video encoder\n");
    printf("\n");
3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283
    show_help_options(options, "Main options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
    show_help_options(options, "\nVideo options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
                      OPT_VIDEO);
    show_help_options(options, "\nAdvanced Video options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
                      OPT_VIDEO | OPT_EXPERT);
    show_help_options(options, "\nAudio options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
                      OPT_AUDIO);
    show_help_options(options, "\nAdvanced Audio options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
                      OPT_AUDIO | OPT_EXPERT);
    show_help_options(options, "\nAudio/Video grab options:\n",
                      OPT_GRAB, 
                      OPT_GRAB);
    show_help_options(options, "\nAdvanced options:\n",
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
                      OPT_EXPERT);
bellard's avatar
bellard committed
3284 3285 3286 3287 3288 3289 3290 3291
    exit(1);
}

void parse_arg_file(const char *filename)
{
    opt_output_file(filename);
}

glantau's avatar
merge  
glantau committed
3292 3293
int main(int argc, char **argv)
{
bellard's avatar
bellard committed
3294
    int i;
kabi's avatar
kabi committed
3295
    int64_t ti;
3296

3297
    av_register_all();
glantau's avatar
merge  
glantau committed
3298 3299 3300

    if (argc <= 1)
        show_help();
3301 3302
    
    /* parse options */
bellard's avatar
bellard committed
3303
    parse_options(argc, argv, options);
glantau's avatar
merge  
glantau committed
3304

bellard's avatar
bellard committed
3305 3306 3307 3308 3309 3310 3311 3312
    /* file converter / grab */
    if (nb_output_files <= 0) {
        fprintf(stderr, "Must supply at least one output file\n");
        exit(1);
    }
    
    if (nb_input_files == 0) {
        prepare_grab();
3313 3314 3315 3316 3317 3318 3319 3320
    }

    ti = getutime();
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
              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
3321 3322 3323 3324
    }

    /* close files */
    for(i=0;i<nb_output_files;i++) {
kabi's avatar
kabi committed
3325 3326 3327 3328 3329 3330 3331 3332
        /* maybe av_close_output_file ??? */
        AVFormatContext *s = output_files[i];
	int j;
        if (!(s->oformat->flags & AVFMT_NOFILE))
	    url_fclose(&s->pb);
	for(j=0;j<s->nb_streams;j++)
	    av_free(s->streams[j]);
        av_free(s);
glantau's avatar
merge  
glantau committed
3333
    }
3334 3335
    for(i=0;i<nb_input_files;i++)
        av_close_input_file(input_files[i]);
glantau's avatar
merge  
glantau committed
3336

3337
    av_free_static();
3338

3339 3340 3341 3342
    if(intra_matrix)
        av_free(intra_matrix);
    if(inter_matrix)
        av_free(inter_matrix);
3343
    
3344
#ifdef POWERPC_PERFORMANCE_REPORT
3345 3346
    extern void powerpc_display_perf_report(void);
    powerpc_display_perf_report();
3347
#endif /* POWERPC_PERFORMANCE_REPORT */
3348

3349 3350 3351 3352 3353 3354 3355 3356 3357
#ifndef CONFIG_WIN32
    if (received_sigterm) {
        fprintf(stderr,
            "Received signal %d: terminating.\n",
            (int) received_sigterm);
        exit (255);
    }
#endif
    exit(0); /* not all OS-es handle main() return value */
glantau's avatar
merge  
glantau committed
3358 3359
    return 0;
}