Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b2a2197e

History | View | Annotate | Download (139 KB)

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

    
25
#ifndef CONFIG_WIN32
26
#include <unistd.h>
27
#include <fcntl.h>
28
#include <sys/ioctl.h>
29
#include <sys/time.h>
30
#include <termios.h>
31
#include <sys/resource.h>
32
#include <signal.h>
33
#endif
34
#ifdef CONFIG_OS2
35
#include <sys/types.h>
36
#include <sys/select.h>
37
#include <stdlib.h>
38
#endif
39
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
40
#include <time.h>
41

    
42
#include "cmdutils.h"
43

    
44
#undef NDEBUG
45
#include <assert.h>
46

    
47
#if !defined(INFINITY) && defined(HUGE_VAL)
48
#define INFINITY HUGE_VAL
49
#endif
50

    
51
/* select an input stream for an output stream */
52
typedef struct AVStreamMap {
53
    int file_index;
54
    int stream_index;
55
} AVStreamMap;
56

    
57
/** select an input file for an output file */
58
typedef struct AVMetaDataMap {
59
    int out_file;
60
    int in_file;
61
} AVMetaDataMap;
62

    
63
extern const OptionDef options[];
64

    
65
static void show_help(void);
66
static void show_license(void);
67

    
68
#define MAX_FILES 20
69

    
70
static AVFormatContext *input_files[MAX_FILES];
71
static int64_t input_files_ts_offset[MAX_FILES];
72
static int nb_input_files = 0;
73

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

    
77
static AVStreamMap stream_maps[MAX_FILES];
78
static int nb_stream_maps;
79

    
80
static AVMetaDataMap meta_data_maps[MAX_FILES];
81
static int nb_meta_data_maps;
82

    
83
static AVInputFormat *file_iformat;
84
static AVOutputFormat *file_oformat;
85
static AVImageFormat *image_format;
86
static int frame_width  = 160;
87
static int frame_height = 128;
88
static float frame_aspect_ratio = 0;
89
static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
90
static int frame_padtop  = 0;
91
static int frame_padbottom = 0;
92
static int frame_padleft  = 0;
93
static int frame_padright = 0;
94
static int padcolor[3] = {16,128,128}; /* default to black */
95
static int frame_topBand  = 0;
96
static int frame_bottomBand = 0;
97
static int frame_leftBand  = 0;
98
static int frame_rightBand = 0;
99
static int frame_rate = 25;
100
static int frame_rate_base = 1;
101
static int video_bit_rate = 200*1000;
102
static int video_bit_rate_tolerance = 4000*1000;
103
static float video_qscale = 0;
104
static int video_qmin = 2;
105
static int video_qmax = 31;
106
static int video_lmin = 2*FF_QP2LAMBDA;
107
static int video_lmax = 31*FF_QP2LAMBDA;
108
static int video_mb_qmin = 2;
109
static int video_mb_qmax = 31;
110
static int video_qdiff = 3;
111
static float video_qblur = 0.5;
112
static float video_qcomp = 0.5;
113
static uint16_t *intra_matrix = NULL;
114
static uint16_t *inter_matrix = NULL;
115
#if 0 //experimental, (can be removed)
116
static float video_rc_qsquish=1.0;
117
static float video_rc_qmod_amp=0;
118
static int video_rc_qmod_freq=0;
119
#endif
120
static char *video_rc_override_string=NULL;
121
static char *video_rc_eq="tex^qComp";
122
static int video_rc_buffer_size=0;
123
static float video_rc_buffer_aggressivity=1.0;
124
static int video_rc_max_rate=0;
125
static int video_rc_min_rate=0;
126
static float video_rc_initial_cplx=0;
127
static float video_b_qfactor = 1.25;
128
static float video_b_qoffset = 1.25;
129
static float video_i_qfactor = -0.8;
130
static float video_i_qoffset = 0.0;
131
static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
132
static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
133
static int me_method = ME_EPZS;
134
static int video_disable = 0;
135
static int video_codec_id = CODEC_ID_NONE;
136
static int video_codec_tag = 0;
137
static int same_quality = 0;
138
static int b_frames = 0;
139
static int mb_decision = FF_MB_DECISION_SIMPLE;
140
static int ildct_cmp = FF_CMP_VSAD;
141
static int mb_cmp = FF_CMP_SAD;
142
static int sub_cmp = FF_CMP_SAD;
143
static int cmp = FF_CMP_SAD;
144
static int pre_cmp = FF_CMP_SAD;
145
static int pre_me = 0;
146
static float lumi_mask = 0;
147
static float dark_mask = 0;
148
static float scplx_mask = 0;
149
static float tcplx_mask = 0;
150
static float p_mask = 0;
151
static int use_4mv = 0;
152
static int use_obmc = 0;
153
static int use_loop = 0;
154
static int use_aic = 0;
155
static int use_aiv = 0;
156
static int use_umv = 0;
157
static int use_ss = 0;
158
static int use_alt_scan = 0;
159
static int use_trell = 0;
160
static int use_scan_offset = 0;
161
static int use_qpel = 0;
162
static int use_qprd = 0;
163
static int use_cbprd = 0;
164
static int qns = 0;
165
static int closed_gop = 0;
166
static int strict_gop = 0;
167
static int do_deinterlace = 0;
168
static int do_interlace_dct = 0;
169
static int do_interlace_me = 0;
170
static int workaround_bugs = FF_BUG_AUTODETECT;
171
static int error_resilience = 2;
172
static int error_concealment = 3;
173
static int dct_algo = 0;
174
static int idct_algo = 0;
175
static int use_part = 0;
176
static int packet_size = 0;
177
static int error_rate = 0;
178
static int strict = 0;
179
static int top_field_first = -1;
180
static int noise_reduction = 0;
181
static int sc_threshold = 0;
182
static int debug = 0;
183
static int debug_mv = 0;
184
static int me_threshold = 0;
185
static int mb_threshold = 0;
186
static int intra_dc_precision = 8;
187
static int coder = 0;
188
static int context = 0;
189
static int predictor = 0;
190
static int video_profile = FF_PROFILE_UNKNOWN;
191
static int video_level = FF_LEVEL_UNKNOWN;
192
static int nsse_weight = 8;
193
static int subpel_quality= 8;
194
static int lowres= 0;
195
extern int loop_input; /* currently a hack */
196

    
197
static int gop_size = 12;
198
static int intra_only = 0;
199
static int audio_sample_rate = 44100;
200
static int audio_bit_rate = 64000;
201
static int audio_disable = 0;
202
static int audio_channels = 1;
203
static int audio_codec_id = CODEC_ID_NONE;
204
static int audio_codec_tag = 0;
205

    
206
static int mux_rate= 0;
207
static int mux_packet_size= 0;
208

    
209
static int64_t recording_time = 0;
210
static int64_t start_time = 0;
211
static int64_t rec_timestamp = 0;
212
static int64_t input_ts_offset = 0;
213
static int file_overwrite = 0;
214
static char *str_title = NULL;
215
static char *str_author = NULL;
216
static char *str_copyright = NULL;
217
static char *str_comment = NULL;
218
static int do_benchmark = 0;
219
static int do_hex_dump = 0;
220
static int do_pkt_dump = 0;
221
static int do_psnr = 0;
222
static int do_vstats = 0;
223
static int do_pass = 0;
224
static int bitexact = 0;
225
static char *pass_logfilename = NULL;
226
static int audio_stream_copy = 0;
227
static int video_stream_copy = 0;
228
static int video_sync_method= 1;
229
static int audio_sync_method= 0;
230
static int copy_ts= 0;
231

    
232
static int rate_emu = 0;
233

    
234
static char *video_grab_format = "video4linux";
235
static char *video_device = NULL;
236
static int  video_channel = 0;
237
static char *video_standard = "ntsc";
238

    
239
static char *audio_grab_format = "audio_device";
240
static char *audio_device = NULL;
241

    
242
static int using_stdin = 0;
243
static int using_vhook = 0;
244
static int verbose = 1;
245
static int thread_count= 1;
246
static int q_pressed = 0;
247
static int me_range = 0;
248
static int64_t video_size = 0;
249
static int64_t audio_size = 0;
250
static int64_t extra_size = 0;
251
static int nb_frames_dup = 0;
252
static int nb_frames_drop = 0;
253
static int input_sync;
254

    
255
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
256

    
257
typedef struct AVOutputStream {
258
    int file_index;          /* file index */
259
    int index;               /* stream index in the output file */
260
    int source_index;        /* AVInputStream index */
261
    AVStream *st;            /* stream in the output file */
262
    int encoding_needed;     /* true if encoding needed for this stream */
263
    int frame_number;
264
    /* input pts and corresponding output pts
265
       for A/V sync */
266
    double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
267
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
268
    /* video only */
269
    int video_resample;      /* video_resample and video_crop are mutually exclusive */
270
    AVFrame pict_tmp;      /* temporary image for resampling */
271
    ImgReSampleContext *img_resample_ctx; /* for image resampling */
272

    
273
    int video_crop;          /* video_resample and video_crop are mutually exclusive */
274
    int topBand;             /* cropping area sizes */
275
    int leftBand;
276
    
277
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
278
    int padtop;              /* padding area sizes */
279
    int padbottom;
280
    int padleft;
281
    int padright;
282
    
283
    /* audio only */
284
    int audio_resample;
285
    ReSampleContext *resample; /* for audio resampling */
286
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
287
    FILE *logfile;
288
} AVOutputStream;
289

    
290
typedef struct AVInputStream {
291
    int file_index;
292
    int index;
293
    AVStream *st;
294
    int discard;             /* true if stream data should be discarded */
295
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
296
    int64_t sample_index;      /* current sample */
297

    
298
    int64_t       start;     /* time when read started */
299
    unsigned long frame;     /* current frame */
300
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
301
                                is not defined */
302
    int64_t       pts;       /* current pts */
303
    int is_start;            /* is 1 at the start and after a discontinuity */
304
} AVInputStream;
305

    
306
typedef struct AVInputFile {
307
    int eof_reached;      /* true if eof reached */
308
    int ist_index;        /* index of first stream in ist_table */
309
    int buffer_size;      /* current total buffer size */
310
    int buffer_size_max;  /* buffer size at which we consider we can stop
311
                             buffering */
312
    int nb_streams;       /* nb streams we are aware of */
313
} AVInputFile;
314

    
315
#ifndef CONFIG_WIN32
316

    
317
/* init terminal so that we can grab keys */
318
static struct termios oldtty;
319

    
320
static void term_exit(void)
321
{
322
    tcsetattr (0, TCSANOW, &oldtty);
323
}
324

    
325
static volatile sig_atomic_t received_sigterm = 0;
326

    
327
static void
328
sigterm_handler(int sig)
329
{
330
    received_sigterm = sig;
331
    term_exit();
332
}
333

    
334
static void term_init(void)
335
{
336
    struct termios tty;
337

    
338
    tcgetattr (0, &tty);
339
    oldtty = tty;
340

    
341
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
342
                          |INLCR|IGNCR|ICRNL|IXON);
343
    tty.c_oflag |= OPOST;
344
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
345
    tty.c_cflag &= ~(CSIZE|PARENB);
346
    tty.c_cflag |= CS8;
347
    tty.c_cc[VMIN] = 1;
348
    tty.c_cc[VTIME] = 0;
349
    
350
    tcsetattr (0, TCSANOW, &tty);
351

    
352
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
353
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
354
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
355
    /*
356
    register a function to be called at normal program termination
357
    */
358
    atexit(term_exit);
359
#ifdef CONFIG_BEOS_NETSERVER
360
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
361
#endif
362
}
363

    
364
/* read a key without blocking */
365
static int read_key(void)
366
{
367
    int n = 1;
368
    unsigned char ch;
369
#ifndef CONFIG_BEOS_NETSERVER
370
    struct timeval tv;
371
    fd_set rfds;
372

    
373
    FD_ZERO(&rfds);
374
    FD_SET(0, &rfds);
375
    tv.tv_sec = 0;
376
    tv.tv_usec = 0;
377
    n = select(1, &rfds, NULL, NULL, &tv);
378
#endif
379
    if (n > 0) {
380
        n = read(0, &ch, 1);
381
        if (n == 1)
382
            return ch;
383

    
384
        return n;
385
    }
386
    return -1;
387
}
388

    
389
static int decode_interrupt_cb(void)
390
{
391
    return q_pressed || (q_pressed = read_key() == 'q');
392
}
393

    
394
#else
395

    
396
static volatile int received_sigterm = 0;
397

    
398
/* no interactive support */
399
static void term_exit(void)
400
{
401
}
402

    
403
static void term_init(void)
404
{
405
}
406

    
407
static int read_key(void)
408
{
409
    return 0;
410
}
411

    
412
#endif
413

    
414
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
415
{
416
    int i, err;
417
    AVFormatContext *ic;
418

    
419
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
420
    if (err < 0)
421
        return err;
422
    /* copy stream format */
423
    s->nb_streams = ic->nb_streams;
424
    for(i=0;i<ic->nb_streams;i++) {
425
        AVStream *st;
426

    
427
        st = av_mallocz(sizeof(AVStream));
428
        memcpy(st, ic->streams[i], sizeof(AVStream));
429
        s->streams[i] = st;
430
    }
431

    
432
    av_close_input_file(ic);
433
    return 0;
434
}
435

    
436
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
437

    
438
static void do_audio_out(AVFormatContext *s, 
439
                         AVOutputStream *ost, 
440
                         AVInputStream *ist,
441
                         unsigned char *buf, int size)
442
{
443
    uint8_t *buftmp;
444
    static uint8_t *audio_buf = NULL;
445
    static uint8_t *audio_out = NULL;
446
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
447

    
448
    int size_out, frame_bytes, ret;
449
    AVCodecContext *enc= &ost->st->codec;
450

    
451
    /* SC: dynamic allocation of buffers */
452
    if (!audio_buf)
453
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
454
    if (!audio_out)
455
        audio_out = av_malloc(audio_out_size);
456
    if (!audio_buf || !audio_out)
457
        return;               /* Should signal an error ! */
458

    
459
    if(audio_sync_method){
460
        double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts 
461
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
462
        double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
463
        int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
464

    
465
        //FIXME resample delay
466
        if(fabs(delta) > 50){
467
            if(ist->is_start){
468
                if(byte_delta < 0){
469
                    byte_delta= FFMAX(byte_delta, -size);
470
                    size += byte_delta;
471
                    buf  -= byte_delta;
472
                    if(verbose > 2)
473
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
474
                    if(!size)
475
                        return;
476
                    ist->is_start=0;
477
                }else{
478
                    static uint8_t *input_tmp= NULL;
479
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
480

    
481
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
482
                        ist->is_start=0;
483
                    else
484
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
485

    
486
                    memset(input_tmp, 0, byte_delta);
487
                    memcpy(input_tmp + byte_delta, buf, size);
488
                    buf= input_tmp;
489
                    size += byte_delta;
490
                    if(verbose > 2)
491
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
492
                }
493
            }else if(audio_sync_method>1){
494
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
495
                assert(ost->audio_resample);
496
                if(verbose > 2)
497
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
498
//                fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(ost->sync_ipts * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2));
499
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
500
            }
501
        } 
502
    }else
503
        ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
504
                        - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
505

    
506
    if (ost->audio_resample) {
507
        buftmp = audio_buf;
508
        size_out = audio_resample(ost->resample, 
509
                                  (short *)buftmp, (short *)buf,
510
                                  size / (ist->st->codec.channels * 2));
511
        size_out = size_out * enc->channels * 2;
512
    } else {
513
        buftmp = buf;
514
        size_out = size;
515
    }
516

    
517
    /* now encode as many frames as possible */
518
    if (enc->frame_size > 1) {
519
        /* output resampled raw samples */
520
        fifo_write(&ost->fifo, buftmp, size_out, 
521
                   &ost->fifo.wptr);
522

    
523
        frame_bytes = enc->frame_size * 2 * enc->channels;
524
        
525
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
526
                     &ost->fifo.rptr) == 0) {
527
            AVPacket pkt;
528
            av_init_packet(&pkt);
529

    
530
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
531
                                       (short *)audio_buf);
532
            audio_size += ret;
533
            pkt.stream_index= ost->index;
534
            pkt.data= audio_out;
535
            pkt.size= ret;
536
            if(enc->coded_frame)
537
                pkt.pts= enc->coded_frame->pts;
538
            pkt.flags |= PKT_FLAG_KEY;
539
            av_interleaved_write_frame(s, &pkt);
540
            
541
            ost->sync_opts += enc->frame_size;
542
        }
543
    } else {
544
        AVPacket pkt;
545
        av_init_packet(&pkt);
546

    
547
        ost->sync_opts += size_out / (2 * enc->channels);
548

    
549
        /* output a pcm frame */
550
        /* XXX: change encoding codec API to avoid this ? */
551
        switch(enc->codec->id) {
552
        case CODEC_ID_PCM_S16LE:
553
        case CODEC_ID_PCM_S16BE:
554
        case CODEC_ID_PCM_U16LE:
555
        case CODEC_ID_PCM_U16BE:
556
            break;
557
        default:
558
            size_out = size_out >> 1;
559
            break;
560
        }
561
        ret = avcodec_encode_audio(enc, audio_out, size_out, 
562
                                   (short *)buftmp);
563
        audio_size += ret;
564
        pkt.stream_index= ost->index;
565
        pkt.data= audio_out;
566
        pkt.size= ret;
567
        if(enc->coded_frame)
568
            pkt.pts= enc->coded_frame->pts;
569
        pkt.flags |= PKT_FLAG_KEY;
570
        av_interleaved_write_frame(s, &pkt);
571
    }
572
}
573

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

    
581
    dec = &ist->st->codec;
582

    
583
    /* deinterlace : must be done before any resize */
584
    if (do_deinterlace || using_vhook) {
585
        int size;
586

    
587
        /* create temporary picture */
588
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
589
        buf = av_malloc(size);
590
        if (!buf)
591
            return;
592
        
593
        picture2 = &picture_tmp;
594
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
595

    
596
        if (do_deinterlace){
597
            if(avpicture_deinterlace(picture2, picture, 
598
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
599
                /* if error, do not deinterlace */
600
                av_free(buf);
601
                buf = NULL;
602
                picture2 = picture;
603
            }
604
        } else {
605
            if (img_convert(picture2, dec->pix_fmt, picture, 
606
                            dec->pix_fmt, dec->width, dec->height) < 0) {
607
                /* if error, do not copy */
608
                av_free(buf);
609
                buf = NULL;
610
                picture2 = picture;
611
            }
612
        }
613
    } else {
614
        picture2 = picture;
615
    }
616

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

    
619
    if (picture != picture2)
620
        *picture = *picture2;
621
    *bufp = buf;
622
}
623

    
624
/* we begin to correct av delay at this threshold */
625
#define AV_DELAY_MAX 0.100
626

    
627

    
628
/* Expects img to be yuv420 */
629
static void fill_pad_region(AVPicture* img, int height, int width,
630
        int padtop, int padbottom, int padleft, int padright, int *color) {
631
  
632
    int i, y, shift;
633
    uint8_t *optr;
634
    
635
    for (i = 0; i < 3; i++) {
636
        shift = (i == 0) ? 0 : 1;
637
        
638
        if (padtop || padleft) {
639
            memset(img->data[i], color[i], (((img->linesize[i] * padtop) + 
640
                            padleft) >> shift));
641
        }
642

    
643
        if (padleft || padright) {
644
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
645
                (img->linesize[i] - (padright >> shift));
646

    
647
            for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
648
                memset(optr, color[i], (padleft + padright) >> shift);
649
                optr += img->linesize[i];
650
            }
651
        }
652
      
653
        if (padbottom) {
654
            optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
655
            memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
656
        }
657
    }
658
}
659

    
660
static uint8_t *bit_buffer= NULL;
661

    
662
static void do_video_out(AVFormatContext *s, 
663
                         AVOutputStream *ost, 
664
                         AVInputStream *ist,
665
                         AVFrame *in_picture,
666
                         int *frame_size)
667
{
668
    int nb_frames, i, ret;
669
    AVFrame *final_picture, *formatted_picture;
670
    AVFrame picture_format_temp, picture_crop_temp;
671
    uint8_t *buf = NULL, *buf1 = NULL;
672
    AVCodecContext *enc, *dec;
673
    enum PixelFormat target_pixfmt;
674
    
675
#define VIDEO_BUFFER_SIZE (1024*1024)
676

    
677
    avcodec_get_frame_defaults(&picture_format_temp);
678
    avcodec_get_frame_defaults(&picture_crop_temp);
679

    
680
    enc = &ost->st->codec;
681
    dec = &ist->st->codec;
682

    
683
    /* by default, we output a single frame */
684
    nb_frames = 1;
685

    
686
    *frame_size = 0;
687

    
688
    if(video_sync_method){
689
        double vdelta;
690
        vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
691
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
692
        if (vdelta < -1.1)
693
            nb_frames = 0;
694
        else if (vdelta > 1.1)
695
            nb_frames = lrintf(vdelta - 1.1 + 0.5);
696
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
697
        if (nb_frames == 0){
698
            ++nb_frames_drop;
699
            if (verbose>2)
700
                fprintf(stderr, "*** drop!\n");
701
        }else if (nb_frames > 1) {
702
            nb_frames_dup += nb_frames;
703
            if (verbose>2)
704
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
705
        }
706
    }else
707
        ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
708

    
709
    if (nb_frames <= 0) 
710
        return;
711

    
712
    /* convert pixel format if needed */
713
    target_pixfmt = ost->video_resample || ost->video_pad
714
        ? PIX_FMT_YUV420P : enc->pix_fmt;
715
    if (dec->pix_fmt != target_pixfmt) {
716
        int size;
717

    
718
        /* create temporary picture */
719
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
720
        buf = av_malloc(size);
721
        if (!buf)
722
            return;
723
        formatted_picture = &picture_format_temp;
724
        avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
725
        
726
        if (img_convert((AVPicture*)formatted_picture, target_pixfmt, 
727
                        (AVPicture *)in_picture, dec->pix_fmt, 
728
                        dec->width, dec->height) < 0) {
729

    
730
            if (verbose >= 0)
731
                fprintf(stderr, "pixel format conversion not handled\n");
732

    
733
            goto the_end;
734
        }
735
    } else {
736
        formatted_picture = in_picture;
737
    }
738

    
739
    /* XXX: resampling could be done before raw format conversion in
740
       some cases to go faster */
741
    /* XXX: only works for YUV420P */
742
    if (ost->video_resample) {
743
        final_picture = &ost->pict_tmp;
744
        img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
745
       
746
        if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
747
            fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
748
                    ost->padtop, ost->padbottom, ost->padleft, ost->padright,
749
                    padcolor);
750
        }
751
        
752
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
753
            int size;
754
            
755
            av_free(buf);
756
            /* create temporary picture */
757
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
758
            buf = av_malloc(size);
759
            if (!buf)
760
                return;
761
            final_picture = &picture_format_temp;
762
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
763
        
764
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
765
                            (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
766
                            enc->width, enc->height) < 0) {
767

    
768
                if (verbose >= 0)
769
                    fprintf(stderr, "pixel format conversion not handled\n");
770

    
771
                goto the_end;
772
            }
773
        }
774
    } else if (ost->video_crop) {
775
        picture_crop_temp.data[0] = formatted_picture->data[0] +
776
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
777

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

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

    
786
        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
787
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
788
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
789
        final_picture = &picture_crop_temp;
790
    } else if (ost->video_pad) {
791
        final_picture = &ost->pict_tmp;
792

    
793
        for (i = 0; i < 3; i++) {
794
            uint8_t *optr, *iptr;
795
            int shift = (i == 0) ? 0 : 1;
796
            int y, yheight;
797
            
798
            /* set offset to start writing image into */
799
            optr = final_picture->data[i] + (((final_picture->linesize[i] * 
800
                            ost->padtop) + ost->padleft) >> shift);
801
            iptr = formatted_picture->data[i];
802

    
803
            yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
804
            for (y = 0; y < yheight; y++) {
805
                /* copy unpadded image row into padded image row */
806
                memcpy(optr, iptr, formatted_picture->linesize[i]);
807
                optr += final_picture->linesize[i];
808
                iptr += formatted_picture->linesize[i];
809
            }
810
        }
811

    
812
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
813
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
814
                padcolor);
815
        
816
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
817
            int size;
818

    
819
            av_free(buf);
820
            /* create temporary picture */
821
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
822
            buf = av_malloc(size);
823
            if (!buf)
824
                return;
825
            final_picture = &picture_format_temp;
826
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
827

    
828
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
829
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
830
                        enc->width, enc->height) < 0) {
831

    
832
                if (verbose >= 0)
833
                    fprintf(stderr, "pixel format conversion not handled\n");
834

    
835
                goto the_end;
836
            }
837
        }
838
    } else {
839
        final_picture = formatted_picture;
840
    }
841
    /* duplicates frame if needed */
842
    for(i=0;i<nb_frames;i++) {
843
        AVPacket pkt;
844
        av_init_packet(&pkt);
845
        pkt.stream_index= ost->index;
846

    
847
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
848
            /* raw pictures are written as AVPicture structure to
849
               avoid any copies. We support temorarily the older
850
               method. */
851
            AVFrame* old_frame = enc->coded_frame;
852
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
853
            pkt.data= (uint8_t *)final_picture;
854
            pkt.size=  sizeof(AVPicture);
855
            if(dec->coded_frame)
856
                pkt.pts= dec->coded_frame->pts;
857
            if(dec->coded_frame && dec->coded_frame->key_frame)
858
                pkt.flags |= PKT_FLAG_KEY;
859

    
860
            av_interleaved_write_frame(s, &pkt);
861
            enc->coded_frame = old_frame;
862
        } else {
863
            AVFrame big_picture;
864

    
865
            big_picture= *final_picture;
866
            /* better than nothing: use input picture interlaced
867
               settings */
868
            big_picture.interlaced_frame = in_picture->interlaced_frame;
869
            if(do_interlace_me || do_interlace_dct){
870
                if(top_field_first == -1)
871
                    big_picture.top_field_first = in_picture->top_field_first;
872
                else
873
                    big_picture.top_field_first = top_field_first;
874
            }
875

    
876
            /* handles sameq here. This is not correct because it may
877
               not be a global option */
878
            if (same_quality) {
879
                big_picture.quality = ist->st->quality;
880
            }else
881
                big_picture.quality = ost->st->quality;
882
            if(!me_threshold)
883
                big_picture.pict_type = 0;
884
//            big_picture.pts = AV_NOPTS_VALUE;
885
            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
886
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
887
            ret = avcodec_encode_video(enc, 
888
                                       bit_buffer, VIDEO_BUFFER_SIZE,
889
                                       &big_picture);
890
            //enc->frame_number = enc->real_pict_num;
891
            if(ret){
892
                pkt.data= bit_buffer;
893
                pkt.size= ret;
894
                if(enc->coded_frame)
895
                    pkt.pts= enc->coded_frame->pts;
896
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n", 
897
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
898
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
899

    
900
                if(enc->coded_frame && enc->coded_frame->key_frame)
901
                    pkt.flags |= PKT_FLAG_KEY;
902
                av_interleaved_write_frame(s, &pkt);
903
                *frame_size = ret;
904
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
905
                //        enc->frame_number-1, enc->real_pict_num, ret,
906
                //        enc->pict_type);
907
                /* if two pass, output log */
908
                if (ost->logfile && enc->stats_out) {
909
                    fprintf(ost->logfile, "%s", enc->stats_out);
910
                }
911
            }
912
        }
913
        ost->sync_opts++;
914
        ost->frame_number++;
915
    }
916
 the_end:
917
    av_free(buf);
918
    av_free(buf1);
919
}
920

    
921
static double psnr(double d){
922
    if(d==0) return INFINITY;
923
    return -10.0*log(d)/log(10.0);
924
}
925

    
926
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost, 
927
                           int frame_size)
928
{
929
    static FILE *fvstats=NULL;
930
    char filename[40];
931
    time_t today2;
932
    struct tm *today;
933
    AVCodecContext *enc;
934
    int frame_number;
935
    int64_t ti;
936
    double ti1, bitrate, avg_bitrate;
937
    
938
    if (!fvstats) {
939
        today2 = time(NULL);
940
        today = localtime(&today2);
941
        sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
942
                                               today->tm_min,
943
                                               today->tm_sec);
944
        fvstats = fopen(filename,"w");
945
        if (!fvstats) {
946
            perror("fopen");
947
            exit(1);
948
        }
949
    }
950
    
951
    ti = MAXINT64;
952
    enc = &ost->st->codec;
953
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
954
        frame_number = ost->frame_number;
955
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
956
        if (enc->flags&CODEC_FLAG_PSNR)
957
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
958
        
959
        fprintf(fvstats,"f_size= %6d ", frame_size);
960
        /* compute pts value */
961
        ti1 = (double)ost->sync_opts *enc->frame_rate_base / enc->frame_rate;
962
        if (ti1 < 0.01)
963
            ti1 = 0.01;
964
    
965
        bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
966
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
967
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
968
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
969
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));        
970
    }
971
}
972

    
973
static void print_report(AVFormatContext **output_files,
974
                         AVOutputStream **ost_table, int nb_ostreams,
975
                         int is_last_report)
976
{
977
    char buf[1024];
978
    AVOutputStream *ost;
979
    AVFormatContext *oc, *os;
980
    int64_t total_size;
981
    AVCodecContext *enc;
982
    int frame_number, vid, i;
983
    double bitrate, ti1, pts;
984
    static int64_t last_time = -1;
985
    
986
    if (!is_last_report) {
987
        int64_t cur_time;
988
        /* display the report every 0.5 seconds */
989
        cur_time = av_gettime();
990
        if (last_time == -1) {
991
            last_time = cur_time;
992
            return;
993
        } 
994
        if ((cur_time - last_time) < 500000)
995
            return;
996
        last_time = cur_time;
997
    }
998

    
999

    
1000
    oc = output_files[0];
1001

    
1002
    total_size = url_ftell(&oc->pb);
1003
    
1004
    buf[0] = '\0';
1005
    ti1 = 1e10;
1006
    vid = 0;
1007
    for(i=0;i<nb_ostreams;i++) {
1008
        ost = ost_table[i];
1009
        os = output_files[ost->file_index];
1010
        enc = &ost->st->codec;
1011
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1012
            sprintf(buf + strlen(buf), "q=%2.1f ",
1013
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1014
        }
1015
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1016
            frame_number = ost->frame_number;
1017
            sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
1018
                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1019
            if(is_last_report)
1020
                sprintf(buf + strlen(buf), "L");
1021
            if (enc->flags&CODEC_FLAG_PSNR){
1022
                int j;
1023
                double error, error_sum=0;
1024
                double scale, scale_sum=0;
1025
                char type[3]= {'Y','U','V'};
1026
                sprintf(buf + strlen(buf), "PSNR=");
1027
                for(j=0; j<3; j++){
1028
                    if(is_last_report){
1029
                        error= enc->error[j];
1030
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1031
                    }else{
1032
                        error= enc->coded_frame->error[j];
1033
                        scale= enc->width*enc->height*255.0*255.0;
1034
                    }
1035
                    if(j) scale/=4;
1036
                    error_sum += error;
1037
                    scale_sum += scale;
1038
                    sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1039
                }
1040
                sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1041
            }
1042
            vid = 1;
1043
        }
1044
        /* compute min output value */
1045
        pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1046
        if ((pts < ti1) && (pts > 0))
1047
            ti1 = pts;
1048
    }
1049
    if (ti1 < 0.01)
1050
        ti1 = 0.01;
1051
    
1052
    if (verbose || is_last_report) {
1053
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1054
        
1055
        sprintf(buf + strlen(buf), 
1056
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1057
            (double)total_size / 1024, ti1, bitrate);
1058

    
1059
        if (verbose > 1)
1060
          sprintf(buf + strlen(buf), " dup=%d drop=%d",
1061
                  nb_frames_dup, nb_frames_drop);
1062
        
1063
        if (verbose >= 0)
1064
            fprintf(stderr, "%s    \r", buf);
1065

    
1066
        fflush(stderr);
1067
    }
1068
        
1069
    if (is_last_report && verbose >= 0){
1070
        int64_t raw= audio_size + video_size + extra_size;
1071
        fprintf(stderr, "\n");
1072
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1073
                video_size/1024.0,
1074
                audio_size/1024.0,
1075
                extra_size/1024.0,
1076
                100.0*(total_size - raw)/raw
1077
        );
1078
    }
1079
}
1080

    
1081
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1082
static int output_packet(AVInputStream *ist, int ist_index,
1083
                         AVOutputStream **ost_table, int nb_ostreams,
1084
                         const AVPacket *pkt)
1085
{
1086
    AVFormatContext *os;
1087
    AVOutputStream *ost;
1088
    uint8_t *ptr;
1089
    int len, ret, i;
1090
    uint8_t *data_buf;
1091
    int data_size, got_picture;
1092
    AVFrame picture;
1093
    void *buffer_to_free;
1094
    static int samples_size= 0;
1095
    static short *samples= NULL;
1096
    
1097
    if(!pkt){
1098
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1099
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1100
        ist->next_pts = ist->pts = pkt->dts;
1101
    } else {
1102
        assert(ist->pts == ist->next_pts);
1103
    }
1104
    
1105
    if (pkt == NULL) {
1106
        /* EOF handling */
1107
        ptr = NULL;
1108
        len = 0;
1109
        goto handle_eof;
1110
    }
1111

    
1112
    len = pkt->size;
1113
    ptr = pkt->data;
1114
    while (len > 0) {
1115
    handle_eof:
1116
        /* decode the packet if needed */
1117
        data_buf = NULL; /* fail safe */
1118
        data_size = 0;
1119
        if (ist->decoding_needed) {
1120
            switch(ist->st->codec.codec_type) {
1121
            case CODEC_TYPE_AUDIO:{
1122
                if(pkt) 
1123
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1124
                    /* XXX: could avoid copy if PCM 16 bits with same
1125
                       endianness as CPU */
1126
                ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1127
                                           ptr, len);
1128
                if (ret < 0)
1129
                    goto fail_decode;
1130
                ptr += ret;
1131
                len -= ret;
1132
                /* Some bug in mpeg audio decoder gives */
1133
                /* data_size < 0, it seems they are overflows */
1134
                if (data_size <= 0) {
1135
                    /* no audio frame */
1136
                    continue;
1137
                }
1138
                data_buf = (uint8_t *)samples;
1139
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) / 
1140
                    (ist->st->codec.sample_rate * ist->st->codec.channels);
1141
                break;}
1142
            case CODEC_TYPE_VIDEO:
1143
                    data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1144
                    /* XXX: allocate picture correctly */
1145
                    avcodec_get_frame_defaults(&picture);
1146

    
1147
                    ret = avcodec_decode_video(&ist->st->codec, 
1148
                                               &picture, &got_picture, ptr, len);
1149
                    ist->st->quality= picture.quality;
1150
                    if (ret < 0) 
1151
                        goto fail_decode;
1152
                    if (!got_picture) {
1153
                        /* no picture yet */
1154
                        goto discard_packet;
1155
                    }
1156
                    if (ist->st->codec.frame_rate_base != 0) {
1157
                        ist->next_pts += ((int64_t)AV_TIME_BASE * 
1158
                                          ist->st->codec.frame_rate_base) /
1159
                            ist->st->codec.frame_rate;
1160
                    }
1161
                    len = 0;
1162
                    break;
1163
                default:
1164
                    goto fail_decode;
1165
                }
1166
            } else {
1167
                data_buf = ptr;
1168
                data_size = len;
1169
                ret = len;
1170
                len = 0;
1171
            }
1172

    
1173
            buffer_to_free = NULL;
1174
            if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1175
                pre_process_video_frame(ist, (AVPicture *)&picture, 
1176
                                        &buffer_to_free);
1177
            }
1178

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

    
1186
                ist->frame++;
1187
            }
1188

    
1189
#if 0
1190
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1191
               is the one of the next displayed one */
1192
            /* XXX: add mpeg4 too ? */
1193
            if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1194
                if (ist->st->codec.pict_type != B_TYPE) {
1195
                    int64_t tmp;
1196
                    tmp = ist->last_ip_pts;
1197
                    ist->last_ip_pts  = ist->frac_pts.val;
1198
                    ist->frac_pts.val = tmp;
1199
                }
1200
            }
1201
#endif
1202
            /* if output time reached then transcode raw format, 
1203
               encode packets and output them */
1204
            if (start_time == 0 || ist->pts >= start_time)
1205
                for(i=0;i<nb_ostreams;i++) {
1206
                    int frame_size;
1207

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

    
1212
#if 0
1213
                        printf("%d: got pts=%0.3f %0.3f\n", i, 
1214
                               (double)pkt->pts / AV_TIME_BASE, 
1215
                               ((double)ist->pts / AV_TIME_BASE) - 
1216
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1217
#endif
1218
                        /* set the input output pts pairs */
1219
                        ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1220

    
1221
                        if (ost->encoding_needed) {
1222
                            switch(ost->st->codec.codec_type) {
1223
                            case CODEC_TYPE_AUDIO:
1224
                                do_audio_out(os, ost, ist, data_buf, data_size);
1225
                                break;
1226
                            case CODEC_TYPE_VIDEO:
1227
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1228
                                    video_size += frame_size;
1229
                                    if (do_vstats && frame_size)
1230
                                        do_video_stats(os, ost, frame_size);
1231
                                break;
1232
                            default:
1233
                                av_abort();
1234
                            }
1235
                        } else {
1236
                            AVFrame avframe; //FIXME/XXX remove this
1237
                            AVPacket opkt;
1238
                            av_init_packet(&opkt);
1239

    
1240
                            /* no reencoding needed : output the packet directly */
1241
                            /* force the input stream PTS */
1242
                        
1243
                            avcodec_get_frame_defaults(&avframe);
1244
                            ost->st->codec.coded_frame= &avframe;
1245
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1246

    
1247
                            if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1248
                                audio_size += data_size;
1249
                            else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1250
                                video_size += data_size;
1251

    
1252
                            opkt.stream_index= ost->index;
1253
                            opkt.data= data_buf;
1254
                            opkt.size= data_size;
1255
                            if(pkt->pts != AV_NOPTS_VALUE)
1256
                                opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1257
                            else
1258
                                opkt.pts= AV_NOPTS_VALUE;
1259
                            opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1260
                            opkt.flags= pkt->flags;
1261
                            
1262
                            av_interleaved_write_frame(os, &opkt);
1263
                            ost->st->codec.frame_number++;
1264
                            ost->frame_number++;
1265
                        }
1266
                    }
1267
                }
1268
            av_free(buffer_to_free);
1269
        }
1270
 discard_packet:
1271
    if (pkt == NULL) {
1272
        /* EOF handling */
1273
  
1274
        for(i=0;i<nb_ostreams;i++) {
1275
            ost = ost_table[i];
1276
            if (ost->source_index == ist_index) {
1277
                AVCodecContext *enc= &ost->st->codec;
1278
                os = output_files[ost->file_index];
1279
                
1280
                if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1281
                    continue;
1282
                if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1283
                    continue;
1284

    
1285
                if (ost->encoding_needed) {
1286
                    for(;;) {
1287
                        AVPacket pkt;
1288
                        av_init_packet(&pkt);
1289
                        pkt.stream_index= ost->index;
1290
 
1291
                        switch(ost->st->codec.codec_type) {
1292
                        case CODEC_TYPE_AUDIO:        
1293
                            ret = avcodec_encode_audio(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1294
                            audio_size += ret;
1295
                            pkt.flags |= PKT_FLAG_KEY;
1296
                            break;
1297
                        case CODEC_TYPE_VIDEO:
1298
                            ret = avcodec_encode_video(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1299
                            video_size += ret;
1300
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1301
                                pkt.flags |= PKT_FLAG_KEY;
1302
                            if (ost->logfile && enc->stats_out) {
1303
                                fprintf(ost->logfile, "%s", enc->stats_out);
1304
                            }
1305
                            break;
1306
                        default:
1307
                            ret=-1;
1308
                        }
1309
                            
1310
                        if(ret<=0)
1311
                            break;
1312
                        pkt.data= bit_buffer;
1313
                        pkt.size= ret;
1314
                        if(enc->coded_frame)
1315
                            pkt.pts= enc->coded_frame->pts;
1316
                        av_interleaved_write_frame(os, &pkt);
1317
                    }
1318
                }
1319
            }
1320
        }
1321
    }
1322
 
1323
    return 0;
1324
 fail_decode:
1325
    return -1;
1326
}
1327

    
1328

    
1329
/*
1330
 * The following code is the main loop of the file converter
1331
 */
1332
static int av_encode(AVFormatContext **output_files,
1333
                     int nb_output_files,
1334
                     AVFormatContext **input_files,
1335
                     int nb_input_files,
1336
                     AVStreamMap *stream_maps, int nb_stream_maps)
1337
{
1338
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1339
    AVFormatContext *is, *os;
1340
    AVCodecContext *codec, *icodec;
1341
    AVOutputStream *ost, **ost_table = NULL;
1342
    AVInputStream *ist, **ist_table = NULL;
1343
    AVInputFile *file_table;
1344
    AVFormatContext *stream_no_data;
1345
    int key;
1346

    
1347
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1348
    if (!file_table)
1349
        goto fail;
1350

    
1351
    if (!bit_buffer)
1352
        bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
1353
    if (!bit_buffer)
1354
        goto fail;
1355
        
1356
    /* input stream init */
1357
    j = 0;
1358
    for(i=0;i<nb_input_files;i++) {
1359
        is = input_files[i];
1360
        file_table[i].ist_index = j;
1361
        file_table[i].nb_streams = is->nb_streams;
1362
        j += is->nb_streams;
1363
    }
1364
    nb_istreams = j;
1365

    
1366
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1367
    if (!ist_table)
1368
        goto fail;
1369
    
1370
    for(i=0;i<nb_istreams;i++) {
1371
        ist = av_mallocz(sizeof(AVInputStream));
1372
        if (!ist)
1373
            goto fail;
1374
        ist_table[i] = ist;
1375
    }
1376
    j = 0;
1377
    for(i=0;i<nb_input_files;i++) {
1378
        is = input_files[i];
1379
        for(k=0;k<is->nb_streams;k++) {
1380
            ist = ist_table[j++];
1381
            ist->st = is->streams[k];
1382
            ist->file_index = i;
1383
            ist->index = k;
1384
            ist->discard = 1; /* the stream is discarded by default
1385
                                 (changed later) */
1386

    
1387
            if (ist->st->codec.rate_emu) {
1388
                ist->start = av_gettime();
1389
                ist->frame = 0;
1390
            }
1391
        }
1392
    }
1393

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

    
1405
    /* Sanity check the mapping args -- do the input files & streams exist? */
1406
    for(i=0;i<nb_stream_maps;i++) {
1407
        int fi = stream_maps[i].file_index;
1408
        int si = stream_maps[i].stream_index;
1409
        
1410
        if (fi < 0 || fi > nb_input_files - 1 ||
1411
            si < 0 || si > file_table[fi].nb_streams - 1) {
1412
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1413
            exit(1);
1414
        }
1415
    }
1416
    
1417
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1418
    if (!ost_table)
1419
        goto fail;
1420
    for(i=0;i<nb_ostreams;i++) {
1421
        ost = av_mallocz(sizeof(AVOutputStream));
1422
        if (!ost)
1423
            goto fail;
1424
        ost_table[i] = ost;
1425
    }
1426
    
1427
    n = 0;
1428
    for(k=0;k<nb_output_files;k++) {
1429
        os = output_files[k];
1430
        for(i=0;i<os->nb_streams;i++) {
1431
            int found;
1432
            ost = ost_table[n++];
1433
            ost->file_index = k;
1434
            ost->index = i;
1435
            ost->st = os->streams[i];
1436
            if (nb_stream_maps > 0) {
1437
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index + 
1438
                    stream_maps[n-1].stream_index;
1439
                    
1440
                /* Sanity check that the stream types match */
1441
                if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1442
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1443
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1444
                        ost->file_index, ost->index);
1445
                    exit(1);
1446
                }
1447
                
1448
            } else {
1449
                /* get corresponding input stream index : we select the first one with the right type */
1450
                found = 0;
1451
                for(j=0;j<nb_istreams;j++) {
1452
                    ist = ist_table[j];
1453
                    if (ist->discard && 
1454
                        ist->st->codec.codec_type == ost->st->codec.codec_type) {
1455
                        ost->source_index = j;
1456
                        found = 1;
1457
                        break;
1458
                    }
1459
                }
1460
                
1461
                if (!found) {
1462
                    /* try again and reuse existing stream */
1463
                    for(j=0;j<nb_istreams;j++) {
1464
                        ist = ist_table[j];
1465
                        if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1466
                            ost->source_index = j;
1467
                            found = 1;
1468
                        }
1469
                    }
1470
                    if (!found) {
1471
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1472
                                ost->file_index, ost->index);
1473
                        exit(1);
1474
                    }
1475
                }
1476
            }
1477
            ist = ist_table[ost->source_index];
1478
            ist->discard = 0;
1479
        }
1480
    }
1481

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

    
1487
        codec = &ost->st->codec;
1488
        icodec = &ist->st->codec;
1489

    
1490
        if (ost->st->stream_copy) {
1491
            /* if stream_copy is selected, no need to decode or encode */
1492
            codec->codec_id = icodec->codec_id;
1493
            codec->codec_type = icodec->codec_type;
1494
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1495
            codec->bit_rate = icodec->bit_rate;
1496
            switch(codec->codec_type) {
1497
            case CODEC_TYPE_AUDIO:
1498
                codec->sample_rate = icodec->sample_rate;
1499
                codec->channels = icodec->channels;
1500
                codec->frame_size = icodec->frame_size;
1501
                break;
1502
            case CODEC_TYPE_VIDEO:
1503
                codec->frame_rate = icodec->frame_rate;
1504
                codec->frame_rate_base = icodec->frame_rate_base;
1505
                codec->width = icodec->width;
1506
                codec->height = icodec->height;
1507
                break;
1508
            default:
1509
                av_abort();
1510
            }
1511
        } else {
1512
            switch(codec->codec_type) {
1513
            case CODEC_TYPE_AUDIO:
1514
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1515
                    goto fail;
1516
                
1517
                if (codec->channels == icodec->channels &&
1518
                    codec->sample_rate == icodec->sample_rate) {
1519
                    ost->audio_resample = 0;
1520
                } else {
1521
                    if (codec->channels != icodec->channels &&
1522
                        (icodec->codec_id == CODEC_ID_AC3 ||
1523
                         icodec->codec_id == CODEC_ID_DTS)) {
1524
                        /* Special case for 5:1 AC3 and DTS input */
1525
                        /* and mono or stereo output      */
1526
                        /* Request specific number of channels */
1527
                        icodec->channels = codec->channels;
1528
                        if (codec->sample_rate == icodec->sample_rate)
1529
                            ost->audio_resample = 0;
1530
                        else {
1531
                            ost->audio_resample = 1;
1532
                        }
1533
                    } else {
1534
                        ost->audio_resample = 1; 
1535
                    }
1536
                }
1537
                if(audio_sync_method>1)
1538
                    ost->audio_resample = 1;
1539

    
1540
                if(ost->audio_resample){
1541
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1542
                                                    codec->sample_rate, icodec->sample_rate);
1543
                    if(!ost->resample){
1544
                        printf("Can't resample.  Aborting.\n");
1545
                        av_abort();
1546
                    }
1547
                }
1548
                ist->decoding_needed = 1;
1549
                ost->encoding_needed = 1;
1550
                break;
1551
            case CODEC_TYPE_VIDEO:
1552
                if (codec->width == icodec->width &&
1553
                    codec->height == icodec->height &&
1554
                    frame_topBand == 0 &&
1555
                    frame_bottomBand == 0 &&
1556
                    frame_leftBand == 0 &&
1557
                    frame_rightBand == 0 && 
1558
                    frame_padtop == 0 &&
1559
                    frame_padbottom == 0 &&
1560
                    frame_padleft == 0 &&
1561
                    frame_padright == 0)
1562
                {
1563
                    ost->video_resample = 0;
1564
                    ost->video_crop = 0;
1565
                    ost->video_pad = 0;
1566
                } else if ((codec->width == icodec->width -
1567
                                (frame_leftBand + frame_rightBand)) &&
1568
                        (codec->height == icodec->height -
1569
                                (frame_topBand  + frame_bottomBand)))
1570
                {
1571
                    ost->video_resample = 0;
1572
                    ost->video_crop = 1;
1573
                    ost->topBand = frame_topBand;
1574
                    ost->leftBand = frame_leftBand;
1575
                } else if ((codec->width == icodec->width + 
1576
                                (frame_padleft + frame_padright)) &&
1577
                        (codec->height == icodec->height +
1578
                                (frame_padtop + frame_padbottom))) {
1579
                    ost->video_resample = 0;
1580
                    ost->video_crop = 0;
1581
                    ost->video_pad = 1;
1582
                    ost->padtop = frame_padtop;
1583
                    ost->padleft = frame_padleft;
1584
                    ost->padbottom = frame_padbottom;
1585
                    ost->padright = frame_padright;
1586
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1587
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1588
                                codec->width, codec->height ) )
1589
                        goto fail;
1590
                } else {
1591
                    ost->video_resample = 1;
1592
                    ost->video_crop = 0; // cropping is handled as part of resample
1593
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1594
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1595
                                         codec->width, codec->height ) )
1596
                        goto fail;
1597

    
1598
                    ost->img_resample_ctx = img_resample_full_init( 
1599
                                      ost->st->codec.width, ost->st->codec.height,
1600
                                      ist->st->codec.width, ist->st->codec.height,
1601
                                      frame_topBand, frame_bottomBand,
1602
                            frame_leftBand, frame_rightBand, 
1603
                            frame_padtop, frame_padbottom, 
1604
                            frame_padleft, frame_padright);
1605
                    
1606
                    ost->padtop = frame_padtop;
1607
                    ost->padleft = frame_padleft;
1608
                    ost->padbottom = frame_padbottom;
1609
                    ost->padright = frame_padright;
1610
                   
1611
                }
1612
                ost->encoding_needed = 1;
1613
                ist->decoding_needed = 1;
1614
                break;
1615
            default:
1616
                av_abort();
1617
            }
1618
            /* two pass mode */
1619
            if (ost->encoding_needed && 
1620
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1621
                char logfilename[1024];
1622
                FILE *f;
1623
                int size;
1624
                char *logbuffer;
1625
                
1626
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 
1627
                         pass_logfilename ? 
1628
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1629
                if (codec->flags & CODEC_FLAG_PASS1) {
1630
                    f = fopen(logfilename, "w");
1631
                    if (!f) {
1632
                        perror(logfilename);
1633
                        exit(1);
1634
                    }
1635
                    ost->logfile = f;
1636
                } else {
1637
                    /* read the log file */
1638
                    f = fopen(logfilename, "r");
1639
                    if (!f) {
1640
                        perror(logfilename);
1641
                        exit(1);
1642
                    }
1643
                    fseek(f, 0, SEEK_END);
1644
                    size = ftell(f);
1645
                    fseek(f, 0, SEEK_SET);
1646
                    logbuffer = av_malloc(size + 1);
1647
                    if (!logbuffer) {
1648
                        fprintf(stderr, "Could not allocate log buffer\n");
1649
                        exit(1);
1650
                    }
1651
                    size = fread(logbuffer, 1, size, f);
1652
                    fclose(f);
1653
                    logbuffer[size] = '\0';
1654
                    codec->stats_in = logbuffer;
1655
                }
1656
            }
1657
        }
1658
    }
1659

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

    
1666
    /* dump the stream mapping */
1667
    if (verbose >= 0) {
1668
        fprintf(stderr, "Stream mapping:\n");
1669
        for(i=0;i<nb_ostreams;i++) {
1670
            ost = ost_table[i];
1671
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1672
                    ist_table[ost->source_index]->file_index,
1673
                    ist_table[ost->source_index]->index,
1674
                    ost->file_index, 
1675
                    ost->index);
1676
        }
1677
    }
1678

    
1679
    /* open each encoder */
1680
    for(i=0;i<nb_ostreams;i++) {
1681
        ost = ost_table[i];
1682
        if (ost->encoding_needed) {
1683
            AVCodec *codec;
1684
            codec = avcodec_find_encoder(ost->st->codec.codec_id);
1685
            if (!codec) {
1686
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n", 
1687
                        ost->file_index, ost->index);
1688
                exit(1);
1689
            }
1690
            if (avcodec_open(&ost->st->codec, codec) < 0) {
1691
                fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n", 
1692
                        ost->file_index, ost->index);
1693
                exit(1);
1694
            }
1695
            extra_size += ost->st->codec.extradata_size;
1696
        }
1697
    }
1698

    
1699
    /* open each decoder */
1700
    for(i=0;i<nb_istreams;i++) {
1701
        ist = ist_table[i];
1702
        if (ist->decoding_needed) {
1703
            AVCodec *codec;
1704
            codec = avcodec_find_decoder(ist->st->codec.codec_id);
1705
            if (!codec) {
1706
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n", 
1707
                        ist->st->codec.codec_id, ist->file_index, ist->index);
1708
                exit(1);
1709
            }
1710
            if (avcodec_open(&ist->st->codec, codec) < 0) {
1711
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
1712
                        ist->file_index, ist->index);
1713
                exit(1);
1714
            }
1715
            //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1716
            //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1717
        }
1718
    }
1719

    
1720
    /* init pts */
1721
    for(i=0;i<nb_istreams;i++) {
1722
        ist = ist_table[i];
1723
        is = input_files[ist->file_index];
1724
        ist->pts = 0;
1725
        ist->next_pts = ist->st->start_time;
1726
        if(ist->next_pts == AV_NOPTS_VALUE) 
1727
            ist->next_pts=0;
1728
        ist->is_start = 1;
1729
    }
1730

    
1731
    /* compute buffer size max (should use a complete heuristic) */
1732
    for(i=0;i<nb_input_files;i++) {
1733
        file_table[i].buffer_size_max = 2048;
1734
    }
1735

    
1736
    /* set meta data information from input file if required */
1737
    for (i=0;i<nb_meta_data_maps;i++) {
1738
        AVFormatContext *out_file;
1739
        AVFormatContext *in_file;
1740

    
1741
        int out_file_index = meta_data_maps[i].out_file;
1742
        int in_file_index = meta_data_maps[i].in_file;
1743
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1744
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1745
            ret = -EINVAL;
1746
            goto fail;
1747
        }
1748
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1749
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1750
            ret = -EINVAL;
1751
            goto fail;
1752
        }                
1753
                 
1754
        out_file = output_files[out_file_index];
1755
        in_file = input_files[in_file_index];
1756

    
1757
        strcpy(out_file->title, in_file->title);
1758
        strcpy(out_file->author, in_file->author);
1759
        strcpy(out_file->copyright, in_file->copyright);
1760
        strcpy(out_file->comment, in_file->comment);
1761
        strcpy(out_file->album, in_file->album);
1762
        out_file->year = in_file->year;
1763
        out_file->track = in_file->track;
1764
        strcpy(out_file->genre, in_file->genre);
1765
    }
1766
        
1767
    /* open files and write file headers */
1768
    for(i=0;i<nb_output_files;i++) {
1769
        os = output_files[i];
1770
        if (av_write_header(os) < 0) {
1771
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1772
            ret = -EINVAL;
1773
            goto fail;
1774
        }
1775
    }
1776

    
1777
#ifndef CONFIG_WIN32
1778
    if ( !using_stdin && verbose >= 0) {
1779
        fprintf(stderr, "Press [q] to stop encoding\n");
1780
        url_set_interrupt_cb(decode_interrupt_cb);
1781
    }
1782
#endif
1783
    term_init();
1784

    
1785
    stream_no_data = 0;
1786
    key = -1;
1787

    
1788
    for(; received_sigterm == 0;) {
1789
        int file_index, ist_index;
1790
        AVPacket pkt;
1791
        double ipts_min;
1792
        double opts_min;
1793

    
1794
    redo:
1795
        ipts_min= 1e100;
1796
        opts_min= 1e100;
1797
        /* if 'q' pressed, exits */
1798
        if (!using_stdin) {
1799
            if (q_pressed)
1800
                break;
1801
            /* read_key() returns 0 on EOF */
1802
            key = read_key();
1803
            if (key == 'q')
1804
                break;
1805
        }
1806

    
1807
        /* select the stream that we must read now by looking at the
1808
           smallest output pts */
1809
        file_index = -1;
1810
        for(i=0;i<nb_ostreams;i++) {
1811
            double ipts, opts;
1812
            ost = ost_table[i];
1813
            os = output_files[ost->file_index];
1814
            ist = ist_table[ost->source_index];
1815
            if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1816
                opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1817
            else
1818
                opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1819
            ipts = (double)ist->pts;
1820
            if (!file_table[ist->file_index].eof_reached){
1821
                if(ipts < ipts_min) {
1822
                    ipts_min = ipts;
1823
                    if(input_sync ) file_index = ist->file_index;
1824
                }
1825
                if(opts < opts_min) {
1826
                    opts_min = opts;
1827
                    if(!input_sync) file_index = ist->file_index;
1828
                }
1829
            }
1830
        }
1831
        /* if none, if is finished */
1832
        if (file_index < 0) {
1833
            break;
1834
        }
1835

    
1836
        /* finish if recording time exhausted */
1837
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1838
            break;
1839

    
1840
        /* read a frame from it and output it in the fifo */
1841
        is = input_files[file_index];
1842
        if (av_read_frame(is, &pkt) < 0) {
1843
            file_table[file_index].eof_reached = 1;
1844
            continue;
1845
        }
1846

    
1847
        if (!pkt.size) {
1848
            stream_no_data = is;
1849
        } else {
1850
            stream_no_data = 0;
1851
        }
1852
        if (do_pkt_dump) {
1853
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1854
        }
1855
        /* the following test is needed in case new streams appear
1856
           dynamically in stream : we ignore them */
1857
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1858
            goto discard_packet;
1859
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1860
        ist = ist_table[ist_index];
1861
        if (ist->discard)
1862
            goto discard_packet;
1863

    
1864
//        fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec.codec_type);
1865
        if (pkt.dts != AV_NOPTS_VALUE) {
1866
            int64_t delta= pkt.dts - ist->next_pts;
1867
            if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1868
                input_files_ts_offset[ist->file_index]-= delta;
1869
                if (verbose > 2)
1870
                    fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1871
                for(i=0; i<file_table[file_index].nb_streams; i++){
1872
                    int index= file_table[file_index].ist_index + i;
1873
                    ist_table[index]->next_pts += delta;
1874
                    ist_table[index]->is_start=1;
1875
                }
1876
            }
1877
        }
1878

    
1879
        //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1880
        if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1881

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

    
1886
            av_free_packet(&pkt);
1887
            goto redo;
1888
        }
1889
        
1890
    discard_packet:
1891
        av_free_packet(&pkt);
1892
        
1893
        /* dump report by using the output first video and audio streams */
1894
        print_report(output_files, ost_table, nb_ostreams, 0);
1895
    }
1896

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

    
1905
    term_exit();
1906

    
1907
    /* write the trailer if needed and close file */
1908
    for(i=0;i<nb_output_files;i++) {
1909
        os = output_files[i];
1910
        av_write_trailer(os);
1911
    }
1912

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

    
1916
    /* close each encoder */
1917
    for(i=0;i<nb_ostreams;i++) {
1918
        ost = ost_table[i];
1919
        if (ost->encoding_needed) {
1920
            av_freep(&ost->st->codec.stats_in);
1921
            avcodec_close(&ost->st->codec);
1922
        }
1923
    }
1924
    
1925
    /* close each decoder */
1926
    for(i=0;i<nb_istreams;i++) {
1927
        ist = ist_table[i];
1928
        if (ist->decoding_needed) {
1929
            avcodec_close(&ist->st->codec);
1930
        }
1931
    }
1932

    
1933
    /* finished ! */
1934
    
1935
    ret = 0;
1936
 fail1:
1937
    av_free(file_table);
1938

    
1939
    if (ist_table) {
1940
        for(i=0;i<nb_istreams;i++) {
1941
            ist = ist_table[i];
1942
            av_free(ist);
1943
        }
1944
        av_free(ist_table);
1945
    }
1946
    if (ost_table) {
1947
        for(i=0;i<nb_ostreams;i++) {
1948
            ost = ost_table[i];
1949
            if (ost) {
1950
                if (ost->logfile) {
1951
                    fclose(ost->logfile);
1952
                    ost->logfile = NULL;
1953
                }
1954
                fifo_free(&ost->fifo); /* works even if fifo is not
1955
                                          initialized but set to zero */
1956
                av_free(ost->pict_tmp.data[0]);
1957
                if (ost->video_resample)
1958
                    img_resample_close(ost->img_resample_ctx);
1959
                if (ost->audio_resample)
1960
                    audio_resample_close(ost->resample);
1961
                av_free(ost);
1962
            }
1963
        }
1964
        av_free(ost_table);
1965
    }
1966
    return ret;
1967
 fail:
1968
    ret = -ENOMEM;
1969
    goto fail1;
1970
}
1971

    
1972
#if 0
1973
int file_read(const char *filename)
1974
{
1975
    URLContext *h;
1976
    unsigned char buffer[1024];
1977
    int len, i;
1978

1979
    if (url_open(&h, filename, O_RDONLY) < 0) {
1980
        printf("could not open '%s'\n", filename);
1981
        return -1;
1982
    }
1983
    for(;;) {
1984
        len = url_read(h, buffer, sizeof(buffer));
1985
        if (len <= 0)
1986
            break;
1987
        for(i=0;i<len;i++) putchar(buffer[i]);
1988
    }
1989
    url_close(h);
1990
    return 0;
1991
}
1992
#endif
1993

    
1994
static void opt_image_format(const char *arg)
1995
{
1996
    AVImageFormat *f;
1997
    
1998
    for(f = first_image_format; f != NULL; f = f->next) {
1999
        if (!strcmp(arg, f->name))
2000
            break;
2001
    }
2002
    if (!f) {
2003
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2004
        exit(1);
2005
    }
2006
    image_format = f;
2007
}
2008

    
2009
static void opt_format(const char *arg)
2010
{
2011
    /* compatibility stuff for pgmyuv */
2012
    if (!strcmp(arg, "pgmyuv")) {
2013
        opt_image_format(arg);
2014
        arg = "image";
2015
    }
2016

    
2017
    file_iformat = av_find_input_format(arg);
2018
    file_oformat = guess_format(arg, NULL, NULL);
2019
    if (!file_iformat && !file_oformat) {
2020
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2021
        exit(1);
2022
    }
2023
}
2024

    
2025
static void opt_video_bitrate(const char *arg)
2026
{
2027
    video_bit_rate = atoi(arg) * 1000;
2028
}
2029

    
2030
static void opt_video_bitrate_tolerance(const char *arg)
2031
{
2032
    video_bit_rate_tolerance = atoi(arg) * 1000;
2033
}
2034

    
2035
static void opt_video_bitrate_max(const char *arg)
2036
{
2037
    video_rc_max_rate = atoi(arg) * 1000;
2038
}
2039

    
2040
static void opt_video_bitrate_min(const char *arg)
2041
{
2042
    video_rc_min_rate = atoi(arg) * 1000;
2043
}
2044

    
2045
static void opt_video_buffer_size(const char *arg)
2046
{
2047
    video_rc_buffer_size = atoi(arg) * 8*1024;
2048
}
2049

    
2050
static void opt_video_rc_eq(char *arg)
2051
{
2052
    video_rc_eq = arg;
2053
}
2054

    
2055
static void opt_video_rc_override_string(char *arg)
2056
{
2057
    video_rc_override_string = arg;
2058
}
2059

    
2060

    
2061
static void opt_workaround_bugs(const char *arg)
2062
{
2063
    workaround_bugs = atoi(arg);
2064
}
2065

    
2066
static void opt_dct_algo(const char *arg)
2067
{
2068
    dct_algo = atoi(arg);
2069
}
2070

    
2071
static void opt_idct_algo(const char *arg)
2072
{
2073
    idct_algo = atoi(arg);
2074
}
2075

    
2076
static void opt_me_threshold(const char *arg)
2077
{
2078
    me_threshold = atoi(arg);
2079
}
2080

    
2081
static void opt_mb_threshold(const char *arg)
2082
{
2083
    mb_threshold = atoi(arg);
2084
}
2085

    
2086
static void opt_error_resilience(const char *arg)
2087
{
2088
    error_resilience = atoi(arg);
2089
}
2090

    
2091
static void opt_error_concealment(const char *arg)
2092
{
2093
    error_concealment = atoi(arg);
2094
}
2095

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

    
2101
static void opt_vismv(const char *arg)
2102
{
2103
    debug_mv = atoi(arg);
2104
}
2105
    
2106
static void opt_verbose(const char *arg)
2107
{
2108
    verbose = atoi(arg);
2109
    av_log_set_level(atoi(arg));
2110
}
2111

    
2112
static void opt_frame_rate(const char *arg)
2113
{
2114
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2115
        fprintf(stderr, "Incorrect frame rate\n");
2116
        exit(1);
2117
    }
2118
}
2119

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

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

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

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

    
2192
static void opt_frame_size(const char *arg)
2193
{
2194
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2195
        fprintf(stderr, "Incorrect frame size\n");
2196
        exit(1);
2197
    }
2198
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2199
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2200
        exit(1);
2201
    }
2202
}
2203

    
2204

    
2205
#define SCALEBITS 10
2206
#define ONE_HALF  (1 << (SCALEBITS - 1))
2207
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
2208

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

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

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

    
2221
static void opt_pad_color(const char *arg) {
2222
    /* Input is expected to be six hex digits similar to
2223
       how colors are expressed in html tags (but without the #) */
2224
    int rgb = strtol(arg, NULL, 16);
2225
    int r,g,b;
2226
    
2227
    r = (rgb >> 16); 
2228
    g = ((rgb >> 8) & 255);
2229
    b = (rgb & 255);
2230

    
2231
    padcolor[0] = RGB_TO_Y(r,g,b);
2232
    padcolor[1] = RGB_TO_U(r,g,b,0);
2233
    padcolor[2] = RGB_TO_V(r,g,b,0);
2234
}
2235

    
2236
static void opt_frame_pad_top(const char *arg)
2237
{
2238
    frame_padtop = atoi(arg); 
2239
    if (frame_padtop < 0) {
2240
        fprintf(stderr, "Incorrect top pad size\n");
2241
        exit(1);
2242
    }
2243
    if ((frame_padtop % 2) != 0) {
2244
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2245
        exit(1);
2246
    }
2247
}
2248

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

    
2262

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

    
2276

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

    
2290

    
2291
static void opt_frame_pix_fmt(const char *arg)
2292
{
2293
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2294
}
2295

    
2296
static void opt_frame_aspect_ratio(const char *arg)
2297
{
2298
    int x = 0, y = 0;
2299
    double ar = 0;
2300
    const char *p;
2301
    
2302
    p = strchr(arg, ':');
2303
    if (p) {
2304
        x = strtol(arg, (char **)&arg, 10);
2305
        if (arg == p)
2306
            y = strtol(arg+1, (char **)&arg, 10);
2307
        if (x > 0 && y > 0)
2308
            ar = (double)x / (double)y;
2309
    } else
2310
        ar = strtod(arg, (char **)&arg);
2311

    
2312
    if (!ar) {
2313
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2314
        exit(1);
2315
    }
2316
    frame_aspect_ratio = ar;
2317
}
2318

    
2319
static void opt_gop_size(const char *arg)
2320
{
2321
    gop_size = atoi(arg);
2322
}
2323

    
2324
static void opt_b_frames(const char *arg)
2325
{
2326
    b_frames = atoi(arg);
2327
    if (b_frames > FF_MAX_B_FRAMES) {
2328
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2329
        exit(1);
2330
    } else if (b_frames < 1) {
2331
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2332
        exit(1);
2333
    }
2334
}
2335

    
2336
static void opt_mb_decision(const char *arg)
2337
{
2338
    mb_decision = atoi(arg);
2339
}
2340

    
2341
static void opt_mb_cmp(const char *arg)
2342
{
2343
    mb_cmp = atoi(arg);
2344
}
2345

    
2346
static void opt_ildct_cmp(const char *arg)
2347
{
2348
    ildct_cmp = atoi(arg);
2349
}
2350

    
2351
static void opt_sub_cmp(const char *arg)
2352
{
2353
    sub_cmp = atoi(arg);
2354
}
2355

    
2356
static void opt_cmp(const char *arg)
2357
{
2358
    cmp = atoi(arg);
2359
}
2360

    
2361
static void opt_pre_cmp(const char *arg)
2362
{
2363
    pre_cmp = atoi(arg);
2364
}
2365

    
2366
static void opt_pre_me(const char *arg)
2367
{
2368
    pre_me = atoi(arg);
2369
}
2370

    
2371
static void opt_lumi_mask(const char *arg)
2372
{
2373
    lumi_mask = atof(arg);
2374
}
2375

    
2376
static void opt_dark_mask(const char *arg)
2377
{
2378
    dark_mask = atof(arg);
2379
}
2380

    
2381
static void opt_scplx_mask(const char *arg)
2382
{
2383
    scplx_mask = atof(arg);
2384
}
2385

    
2386
static void opt_tcplx_mask(const char *arg)
2387
{
2388
    tcplx_mask = atof(arg);
2389
}
2390

    
2391
static void opt_p_mask(const char *arg)
2392
{
2393
    p_mask = atof(arg);
2394
}
2395

    
2396
static void opt_qscale(const char *arg)
2397
{
2398
    video_qscale = atof(arg);
2399
    if (video_qscale < 0.01 ||
2400
        video_qscale > 255) {
2401
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2402
        exit(1);
2403
    }
2404
}
2405

    
2406
static void opt_lmax(const char *arg)
2407
{
2408
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2409
}
2410

    
2411
static void opt_lmin(const char *arg)
2412
{
2413
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2414
}
2415

    
2416
static void opt_qmin(const char *arg)
2417
{
2418
    video_qmin = atoi(arg);
2419
    if (video_qmin < 0 ||
2420
        video_qmin > 31) {
2421
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2422
        exit(1);
2423
    }
2424
}
2425

    
2426
static void opt_qmax(const char *arg)
2427
{
2428
    video_qmax = atoi(arg);
2429
    if (video_qmax < 0 ||
2430
        video_qmax > 31) {
2431
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2432
        exit(1);
2433
    }
2434
}
2435

    
2436
static void opt_mb_qmin(const char *arg)
2437
{
2438
    video_mb_qmin = atoi(arg);
2439
    if (video_mb_qmin < 0 ||
2440
        video_mb_qmin > 31) {
2441
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2442
        exit(1);
2443
    }
2444
}
2445

    
2446
static void opt_mb_qmax(const char *arg)
2447
{
2448
    video_mb_qmax = atoi(arg);
2449
    if (video_mb_qmax < 0 ||
2450
        video_mb_qmax > 31) {
2451
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2452
        exit(1);
2453
    }
2454
}
2455

    
2456
static void opt_qdiff(const char *arg)
2457
{
2458
    video_qdiff = atoi(arg);
2459
    if (video_qdiff < 0 ||
2460
        video_qdiff > 31) {
2461
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2462
        exit(1);
2463
    }
2464
}
2465

    
2466
static void opt_qblur(const char *arg)
2467
{
2468
    video_qblur = atof(arg);
2469
}
2470

    
2471
static void opt_qcomp(const char *arg)
2472
{
2473
    video_qcomp = atof(arg);
2474
}
2475

    
2476
static void opt_rc_initial_cplx(const char *arg)
2477
{
2478
    video_rc_initial_cplx = atof(arg);
2479
}
2480
static void opt_b_qfactor(const char *arg)
2481
{
2482
    video_b_qfactor = atof(arg);
2483
}
2484
static void opt_i_qfactor(const char *arg)
2485
{
2486
    video_i_qfactor = atof(arg);
2487
}
2488
static void opt_b_qoffset(const char *arg)
2489
{
2490
    video_b_qoffset = atof(arg);
2491
}
2492
static void opt_i_qoffset(const char *arg)
2493
{
2494
    video_i_qoffset = atof(arg);
2495
}
2496

    
2497
static void opt_ibias(const char *arg)
2498
{
2499
    video_intra_quant_bias = atoi(arg);
2500
}
2501
static void opt_pbias(const char *arg)
2502
{
2503
    video_inter_quant_bias = atoi(arg);
2504
}
2505

    
2506
static void opt_packet_size(const char *arg)
2507
{
2508
    packet_size= atoi(arg);
2509
}
2510

    
2511
static void opt_error_rate(const char *arg)
2512
{
2513
    error_rate= atoi(arg);
2514
}
2515

    
2516
static void opt_strict(const char *arg)
2517
{
2518
    strict= atoi(arg);
2519
}
2520

    
2521
static void opt_top_field_first(const char *arg)
2522
{
2523
    top_field_first= atoi(arg);
2524
}
2525

    
2526
static void opt_noise_reduction(const char *arg)
2527
{
2528
    noise_reduction= atoi(arg);
2529
}
2530

    
2531
static void opt_qns(const char *arg)
2532
{
2533
    qns= atoi(arg);
2534
}
2535

    
2536
static void opt_sc_threshold(const char *arg)
2537
{
2538
    sc_threshold= atoi(arg);
2539
}
2540

    
2541
static void opt_me_range(const char *arg)
2542
{
2543
    me_range = atoi(arg);
2544
}
2545

    
2546
static void opt_thread_count(const char *arg)
2547
{
2548
    thread_count= atoi(arg);
2549
#if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2550
    if (verbose >= 0)
2551
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2552
#endif
2553
}
2554

    
2555
static void opt_audio_bitrate(const char *arg)
2556
{
2557
    audio_bit_rate = atoi(arg) * 1000;
2558
}
2559

    
2560
static void opt_audio_rate(const char *arg)
2561
{
2562
    audio_sample_rate = atoi(arg);
2563
}
2564

    
2565
static void opt_audio_channels(const char *arg)
2566
{
2567
    audio_channels = atoi(arg);
2568
}
2569

    
2570
static void opt_video_device(const char *arg)
2571
{
2572
    video_device = av_strdup(arg);
2573
}
2574

    
2575
static void opt_video_channel(const char *arg)
2576
{
2577
    video_channel = strtol(arg, NULL, 0);
2578
}
2579

    
2580
static void opt_video_standard(const char *arg)
2581
{
2582
    video_standard = av_strdup(arg);
2583
}
2584

    
2585
static void opt_audio_device(const char *arg)
2586
{
2587
    audio_device = av_strdup(arg);
2588
}
2589

    
2590
static void opt_dv1394(const char *arg)
2591
{
2592
    video_grab_format = "dv1394";
2593
    audio_grab_format = NULL;
2594
}
2595

    
2596
static void opt_audio_codec(const char *arg)
2597
{
2598
    AVCodec *p;
2599

    
2600
    if (!strcmp(arg, "copy")) {
2601
        audio_stream_copy = 1;
2602
    } else {
2603
        p = first_avcodec;
2604
        while (p) {
2605
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2606
                break;
2607
            p = p->next;
2608
        }
2609
        if (p == NULL) {
2610
            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2611
            exit(1);
2612
        } else {
2613
            audio_codec_id = p->id;
2614
        }
2615
    }
2616
}
2617

    
2618
static void opt_audio_tag(const char *arg)
2619
{
2620
    char *tail;
2621
    audio_codec_tag= strtol(arg, &tail, 0);
2622

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

    
2627
static void opt_video_tag(const char *arg)
2628
{
2629
    char *tail;
2630
    video_codec_tag= strtol(arg, &tail, 0);
2631

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

    
2636
static void add_frame_hooker(const char *arg)
2637
{
2638
    int argc = 0;
2639
    char *argv[64];
2640
    int i;
2641
    char *args = av_strdup(arg);
2642

    
2643
    using_vhook = 1;
2644

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

    
2649
    i = frame_hook_add(argc, argv);
2650

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

    
2657
const char *motion_str[] = {
2658
    "zero",
2659
    "full",
2660
    "log",
2661
    "phods",
2662
    "epzs",
2663
    "x1",
2664
    NULL,
2665
};
2666

    
2667
static void opt_motion_estimation(const char *arg)
2668
{
2669
    const char **p;
2670
    p = motion_str;
2671
    for(;;) {
2672
        if (!*p) {
2673
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2674
            exit(1);
2675
        }
2676
        if (!strcmp(*p, arg))
2677
            break;
2678
        p++;
2679
    }
2680
    me_method = (p - motion_str) + 1;
2681
}
2682

    
2683
static void opt_video_codec(const char *arg)
2684
{
2685
    AVCodec *p;
2686

    
2687
    if (!strcmp(arg, "copy")) {
2688
        video_stream_copy = 1;
2689
    } else {
2690
        p = first_avcodec;
2691
        while (p) {
2692
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2693
                break;
2694
            p = p->next;
2695
        }
2696
        if (p == NULL) {
2697
            fprintf(stderr, "Unknown video codec '%s'\n", arg);
2698
            exit(1);
2699
        } else {
2700
            video_codec_id = p->id;
2701
        }
2702
    }
2703
}
2704

    
2705
static void opt_map(const char *arg)
2706
{
2707
    AVStreamMap *m;
2708
    const char *p;
2709

    
2710
    p = arg;
2711
    m = &stream_maps[nb_stream_maps++];
2712

    
2713
    m->file_index = strtol(arg, (char **)&p, 0);
2714
    if (*p)
2715
        p++;
2716

    
2717
    m->stream_index = strtol(p, (char **)&p, 0);
2718
}
2719

    
2720
static void opt_map_meta_data(const char *arg)
2721
{
2722
    AVMetaDataMap *m;
2723
    const char *p;
2724
        
2725
    p = arg;
2726
    m = &meta_data_maps[nb_meta_data_maps++];
2727

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

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

    
2735
static void opt_recording_time(const char *arg)
2736
{
2737
    recording_time = parse_date(arg, 1);
2738
}
2739

    
2740
static void opt_start_time(const char *arg)
2741
{
2742
    start_time = parse_date(arg, 1);
2743
}
2744

    
2745
static void opt_rec_timestamp(const char *arg)
2746
{
2747
    rec_timestamp = parse_date(arg, 0) / 1000000;
2748
}
2749

    
2750
static void opt_input_ts_offset(const char *arg)
2751
{
2752
    input_ts_offset = parse_date(arg, 1);
2753
}
2754

    
2755
static void opt_input_file(const char *filename)
2756
{
2757
    AVFormatContext *ic;
2758
    AVFormatParameters params, *ap = &params;
2759
    int err, i, ret, rfps, rfps_base;
2760
    int64_t timestamp;
2761

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

    
2765
    using_stdin |= !strcmp(filename, "pipe:" ) || 
2766
                   !strcmp( filename, "/dev/stdin" );
2767

    
2768
    /* get default parameters from command line */
2769
    memset(ap, 0, sizeof(*ap));
2770
    ap->sample_rate = audio_sample_rate;
2771
    ap->channels = audio_channels;
2772
    ap->frame_rate = frame_rate;
2773
    ap->frame_rate_base = frame_rate_base;
2774
    ap->width = frame_width + frame_padleft + frame_padright;
2775
    ap->height = frame_height + frame_padtop + frame_padbottom;
2776
    ap->image_format = image_format;
2777
    ap->pix_fmt = frame_pix_fmt;
2778

    
2779
    /* open the input file with generic libav function */
2780
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2781
    if (err < 0) {
2782
        print_error(filename, err);
2783
        exit(1);
2784
    }
2785
    
2786
    /* If not enough info to get the stream parameters, we decode the
2787
       first frames to get it. (used in mpeg case for example) */
2788
    ret = av_find_stream_info(ic);
2789
    if (ret < 0 && verbose >= 0) {
2790
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2791
        exit(1);
2792
    }
2793

    
2794
    timestamp = start_time;
2795
    /* add the stream start time */
2796
    if (ic->start_time != AV_NOPTS_VALUE)
2797
        timestamp += ic->start_time;
2798

    
2799
    /* if seeking requested, we execute it */
2800
    if (start_time != 0) {
2801
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2802
        if (ret < 0) {
2803
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
2804
                    filename, (double)timestamp / AV_TIME_BASE);
2805
        }
2806
        /* reset seek info */
2807
        start_time = 0;
2808
    }
2809

    
2810
    /* update the current parameters so that they match the one of the input stream */
2811
    for(i=0;i<ic->nb_streams;i++) {
2812
        AVCodecContext *enc = &ic->streams[i]->codec;
2813
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2814
        if(thread_count>1)
2815
            avcodec_thread_init(enc, thread_count);
2816
#endif
2817
        enc->thread_count= thread_count;
2818
        switch(enc->codec_type) {
2819
        case CODEC_TYPE_AUDIO:
2820
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2821
            audio_channels = enc->channels;
2822
            audio_sample_rate = enc->sample_rate;
2823
            break;
2824
        case CODEC_TYPE_VIDEO:
2825
            frame_height = enc->height;
2826
            frame_width = enc->width;
2827
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2828
            frame_pix_fmt = enc->pix_fmt;
2829
            rfps      = ic->streams[i]->r_frame_rate;
2830
            rfps_base = ic->streams[i]->r_frame_rate_base;
2831
            enc->workaround_bugs = workaround_bugs;
2832
            enc->error_resilience = error_resilience; 
2833
            enc->error_concealment = error_concealment; 
2834
            enc->idct_algo = idct_algo;
2835
            enc->debug = debug;
2836
            enc->debug_mv = debug_mv;            
2837
            enc->lowres= lowres;
2838
            if(bitexact)
2839
                enc->flags|= CODEC_FLAG_BITEXACT;
2840
            if(me_threshold)
2841
                enc->debug |= FF_DEBUG_MV;
2842

    
2843
            assert(enc->frame_rate_base == rfps_base); // should be true for now
2844
            if (enc->frame_rate != rfps) { 
2845

    
2846
                if (verbose >= 0)
2847
                    fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2848
                            i, (float)enc->frame_rate / enc->frame_rate_base,
2849

    
2850
                    (float)rfps / rfps_base);
2851
            }
2852
            /* update the current frame rate to match the stream frame rate */
2853
            frame_rate      = rfps;
2854
            frame_rate_base = rfps_base;
2855

    
2856
            enc->rate_emu = rate_emu;
2857
            break;
2858
        case CODEC_TYPE_DATA:
2859
            break;
2860
        default:
2861
            av_abort();
2862
        }
2863
    }
2864
    
2865
    input_files[nb_input_files] = ic;
2866
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2867
    /* dump the file content */
2868
    if (verbose >= 0)
2869
        dump_format(ic, nb_input_files, filename, 0);
2870

    
2871
    nb_input_files++;
2872
    file_iformat = NULL;
2873
    file_oformat = NULL;
2874
    image_format = NULL;
2875

    
2876
    rate_emu = 0;
2877
}
2878

    
2879
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2880
{
2881
    int has_video, has_audio, i, j;
2882
    AVFormatContext *ic;
2883

    
2884
    has_video = 0;
2885
    has_audio = 0;
2886
    for(j=0;j<nb_input_files;j++) {
2887
        ic = input_files[j];
2888
        for(i=0;i<ic->nb_streams;i++) {
2889
            AVCodecContext *enc = &ic->streams[i]->codec;
2890
            switch(enc->codec_type) {
2891
            case CODEC_TYPE_AUDIO:
2892
                has_audio = 1;
2893
                break;
2894
            case CODEC_TYPE_VIDEO:
2895
                has_video = 1;
2896
                break;
2897
            case CODEC_TYPE_DATA:
2898
                break;
2899
            default:
2900
                av_abort();
2901
            }
2902
        }
2903
    }
2904
    *has_video_ptr = has_video;
2905
    *has_audio_ptr = has_audio;
2906
}
2907

    
2908
static void opt_output_file(const char *filename)
2909
{
2910
    AVStream *st;
2911
    AVFormatContext *oc;
2912
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2913
    int codec_id;
2914
    AVFormatParameters params, *ap = &params;
2915

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

    
2919
    oc = av_alloc_format_context();
2920

    
2921
    if (!file_oformat) {
2922
        file_oformat = guess_format(NULL, filename, NULL);
2923
        if (!file_oformat) {
2924
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2925
                    filename);
2926
            exit(1);
2927
        }
2928
    }
2929
    
2930
    oc->oformat = file_oformat;
2931

    
2932
    if (!strcmp(file_oformat->name, "ffm") && 
2933
        strstart(filename, "http:", NULL)) {
2934
        /* special case for files sent to ffserver: we get the stream
2935
           parameters from ffserver */
2936
        if (read_ffserver_streams(oc, filename) < 0) {
2937
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2938
            exit(1);
2939
        }
2940
    } else {
2941
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2942
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2943

    
2944
        /* disable if no corresponding type found and at least one
2945
           input file */
2946
        if (nb_input_files > 0) {
2947
            check_audio_video_inputs(&input_has_video, &input_has_audio);
2948
            if (!input_has_video)
2949
                use_video = 0;
2950
            if (!input_has_audio)
2951
                use_audio = 0;
2952
        }
2953

    
2954
        /* manual disable */
2955
        if (audio_disable) {
2956
            use_audio = 0;
2957
        }
2958
        if (video_disable) {
2959
            use_video = 0;
2960
        }
2961
        
2962
        nb_streams = 0;
2963
        if (use_video) {
2964
            AVCodecContext *video_enc;
2965
            
2966
            st = av_new_stream(oc, nb_streams++);
2967
            if (!st) {
2968
                fprintf(stderr, "Could not alloc stream\n");
2969
                exit(1);
2970
            }
2971
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2972
            if(thread_count>1)
2973
                avcodec_thread_init(&st->codec, thread_count);
2974
#endif
2975

    
2976
            video_enc = &st->codec;
2977
            
2978
            if(video_codec_tag)
2979
                video_enc->codec_tag= video_codec_tag;
2980
                
2981
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2982
                video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2983
            if (video_stream_copy) {
2984
                st->stream_copy = 1;
2985
                video_enc->codec_type = CODEC_TYPE_VIDEO;
2986
            } else {
2987
                char *p;
2988
                int i;
2989
                AVCodec *codec;
2990
            
2991
                codec_id = file_oformat->video_codec;
2992
                if (video_codec_id != CODEC_ID_NONE)
2993
                    codec_id = video_codec_id;
2994
                
2995
                video_enc->codec_id = codec_id;
2996
                codec = avcodec_find_encoder(codec_id);
2997
                
2998
                video_enc->bit_rate = video_bit_rate;
2999
                video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3000
                video_enc->frame_rate = frame_rate; 
3001
                video_enc->frame_rate_base = frame_rate_base; 
3002
                if(codec && codec->supported_framerates){
3003
                    const AVRational *p= codec->supported_framerates;
3004
                    AVRational req= (AVRational){frame_rate, frame_rate_base};
3005
                    const AVRational *best=NULL;
3006
                    AVRational best_error= (AVRational){INT_MAX, 1};
3007
                    for(; p->den!=0; p++){
3008
                        AVRational error= av_sub_q(req, *p);
3009
                        if(error.num <0) error.num *= -1;
3010
                        if(av_cmp_q(error, best_error) < 0){
3011
                            best_error= error;
3012
                            best= p;
3013
                        }
3014
                    }
3015
                    video_enc->frame_rate     = best->num;
3016
                    video_enc->frame_rate_base= best->den;
3017
                }
3018
                
3019
                video_enc->width = frame_width + frame_padright + frame_padleft;
3020
                video_enc->height = frame_height + frame_padtop + frame_padbottom;
3021
                video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3022
                video_enc->pix_fmt = frame_pix_fmt;
3023

    
3024
                if(codec && codec->pix_fmts){
3025
                    const enum PixelFormat *p= codec->pix_fmts;
3026
                    for(; *p!=-1; p++){
3027
                        if(*p == video_enc->pix_fmt)
3028
                            break;
3029
                    }
3030
                    if(*p == -1)
3031
                        video_enc->pix_fmt = codec->pix_fmts[0];
3032
                }
3033

    
3034
                if (!intra_only)
3035
                    video_enc->gop_size = gop_size;
3036
                else
3037
                    video_enc->gop_size = 0;
3038
                if (video_qscale || same_quality) {
3039
                    video_enc->flags |= CODEC_FLAG_QSCALE;
3040
                    st->quality = FF_QP2LAMBDA * video_qscale;
3041
                }
3042

    
3043
                if(intra_matrix)
3044
                    video_enc->intra_matrix = intra_matrix;
3045
                if(inter_matrix)
3046
                    video_enc->inter_matrix = inter_matrix;
3047

    
3048
                if(bitexact)
3049
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
3050

    
3051
                video_enc->mb_decision = mb_decision;
3052
                video_enc->mb_cmp = mb_cmp;
3053
                video_enc->ildct_cmp = ildct_cmp;
3054
                video_enc->me_sub_cmp = sub_cmp;
3055
                video_enc->me_cmp = cmp;
3056
                video_enc->me_pre_cmp = pre_cmp;
3057
                video_enc->pre_me = pre_me;
3058
                video_enc->lumi_masking = lumi_mask;
3059
                video_enc->dark_masking = dark_mask;
3060
                video_enc->spatial_cplx_masking = scplx_mask;
3061
                video_enc->temporal_cplx_masking = tcplx_mask;
3062
                video_enc->p_masking = p_mask;
3063
                video_enc->quantizer_noise_shaping= qns;
3064
                
3065
                if (use_umv) {
3066
                    video_enc->flags |= CODEC_FLAG_H263P_UMV;
3067
                }
3068
                if (use_ss) {
3069
                    video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3070
                }
3071
                   if (use_aic) {
3072
                    video_enc->flags |= CODEC_FLAG_H263P_AIC;
3073
                }
3074
                   if (use_aiv) {
3075
                    video_enc->flags |= CODEC_FLAG_H263P_AIV;
3076
                }
3077
                if (use_4mv) {
3078
                    video_enc->flags |= CODEC_FLAG_4MV;
3079
                }
3080
                if (use_obmc) {
3081
                    video_enc->flags |= CODEC_FLAG_OBMC;
3082
                }
3083
                if (use_loop) {
3084
                    video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3085
                }
3086
            
3087
                if(use_part) {
3088
                    video_enc->flags |= CODEC_FLAG_PART;
3089
                }
3090
                   if (use_alt_scan) {
3091
                    video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3092
                }
3093
                   if (use_trell) {
3094
                    video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3095
                }
3096
                   if (use_scan_offset) {
3097
                    video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3098
                }
3099
                   if (closed_gop) {
3100
                    video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3101
                }
3102
                if (strict_gop) {
3103
                    video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3104
                }
3105
                   if (use_qpel) {
3106
                    video_enc->flags |= CODEC_FLAG_QPEL;
3107
                }
3108
                   if (use_qprd) {
3109
                    video_enc->flags |= CODEC_FLAG_QP_RD;
3110
                }
3111
                   if (use_cbprd) {
3112
                    video_enc->flags |= CODEC_FLAG_CBP_RD;
3113
                }
3114
                if (b_frames) {
3115
                    video_enc->max_b_frames = b_frames;
3116
                    video_enc->b_frame_strategy = 0;
3117
                    video_enc->b_quant_factor = 2.0;
3118
                }
3119
                if (do_interlace_dct) {
3120
                    video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3121
                }
3122
                if (do_interlace_me) {
3123
                    video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3124
                }
3125
                video_enc->qmin = video_qmin;
3126
                video_enc->qmax = video_qmax;
3127
                video_enc->lmin = video_lmin;
3128
                video_enc->lmax = video_lmax;
3129
                video_enc->mb_qmin = video_mb_qmin;
3130
                video_enc->mb_qmax = video_mb_qmax;
3131
                video_enc->max_qdiff = video_qdiff;
3132
                video_enc->qblur = video_qblur;
3133
                video_enc->qcompress = video_qcomp;
3134
                video_enc->rc_eq = video_rc_eq;
3135
                video_enc->debug = debug;
3136
                video_enc->debug_mv = debug_mv;
3137
                video_enc->thread_count = thread_count;
3138
                p= video_rc_override_string;
3139
                for(i=0; p; i++){
3140
                    int start, end, q;
3141
                    int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3142
                    if(e!=3){
3143
                        fprintf(stderr, "error parsing rc_override\n");
3144
                        exit(1);
3145
                    }
3146
                    video_enc->rc_override= 
3147
                        av_realloc(video_enc->rc_override, 
3148
                                   sizeof(RcOverride)*(i+1));
3149
                    video_enc->rc_override[i].start_frame= start;
3150
                    video_enc->rc_override[i].end_frame  = end;
3151
                    if(q>0){
3152
                        video_enc->rc_override[i].qscale= q;
3153
                        video_enc->rc_override[i].quality_factor= 1.0;
3154
                    }
3155
                    else{
3156
                        video_enc->rc_override[i].qscale= 0;
3157
                        video_enc->rc_override[i].quality_factor= -q/100.0;
3158
                    }
3159
                    p= strchr(p, '/');
3160
                    if(p) p++;
3161
                }
3162
                video_enc->rc_override_count=i;
3163

    
3164
                video_enc->rc_max_rate = video_rc_max_rate;
3165
                video_enc->rc_min_rate = video_rc_min_rate;
3166
                video_enc->rc_buffer_size = video_rc_buffer_size;
3167
                video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3168
                video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3169
                video_enc->rc_initial_cplx= video_rc_initial_cplx;
3170
                video_enc->i_quant_factor = video_i_qfactor;
3171
                video_enc->b_quant_factor = video_b_qfactor;
3172
                video_enc->i_quant_offset = video_i_qoffset;
3173
                video_enc->b_quant_offset = video_b_qoffset;
3174
                video_enc->intra_quant_bias = video_intra_quant_bias;
3175
                video_enc->inter_quant_bias = video_inter_quant_bias;
3176
                video_enc->dct_algo = dct_algo;
3177
                video_enc->idct_algo = idct_algo;
3178
                video_enc->me_threshold= me_threshold;
3179
                video_enc->mb_threshold= mb_threshold;
3180
                video_enc->intra_dc_precision= intra_dc_precision - 8;
3181
                video_enc->strict_std_compliance = strict;
3182
                video_enc->error_rate = error_rate;
3183
                video_enc->noise_reduction= noise_reduction;
3184
                video_enc->scenechange_threshold= sc_threshold;
3185
                video_enc->me_range = me_range;
3186
                video_enc->coder_type= coder;
3187
                video_enc->context_model= context;
3188
                video_enc->prediction_method= predictor;
3189
                video_enc->profile= video_profile;
3190
                video_enc->level= video_level;
3191
                video_enc->nsse_weight= nsse_weight;
3192
                video_enc->me_subpel_quality= subpel_quality;
3193

    
3194
                if(packet_size){
3195
                    video_enc->rtp_mode= 1;
3196
                    video_enc->rtp_payload_size= packet_size;
3197
                }
3198
            
3199
                if (do_psnr)
3200
                    video_enc->flags|= CODEC_FLAG_PSNR;
3201
            
3202
                video_enc->me_method = me_method;
3203

    
3204
                /* two pass mode */
3205
                if (do_pass) {
3206
                    if (do_pass == 1) {
3207
                        video_enc->flags |= CODEC_FLAG_PASS1;
3208
                    } else {
3209
                        video_enc->flags |= CODEC_FLAG_PASS2;
3210
                    }
3211
                }
3212
            }
3213
        }
3214
    
3215
        if (use_audio) {
3216
            AVCodecContext *audio_enc;
3217

    
3218
            st = av_new_stream(oc, nb_streams++);
3219
            if (!st) {
3220
                fprintf(stderr, "Could not alloc stream\n");
3221
                exit(1);
3222
            }
3223
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
3224
            if(thread_count>1)
3225
                avcodec_thread_init(&st->codec, thread_count);
3226
#endif
3227

    
3228
            audio_enc = &st->codec;
3229
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3230

    
3231
            if(audio_codec_tag)
3232
                audio_enc->codec_tag= audio_codec_tag;
3233

    
3234
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3235
                audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3236
            if (audio_stream_copy) {
3237
                st->stream_copy = 1;
3238
                audio_enc->channels = audio_channels;
3239
            } else {
3240
                codec_id = file_oformat->audio_codec;
3241
                if (audio_codec_id != CODEC_ID_NONE)
3242
                    codec_id = audio_codec_id;
3243
                audio_enc->codec_id = codec_id;
3244
                
3245
                audio_enc->bit_rate = audio_bit_rate;
3246
                audio_enc->strict_std_compliance = strict;
3247
                audio_enc->thread_count = thread_count;
3248
                /* For audio codecs other than AC3 or DTS we limit */
3249
                /* the number of coded channels to stereo   */
3250
                if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3251
                    && codec_id != CODEC_ID_DTS) {
3252
                    audio_enc->channels = 2;
3253
                } else
3254
                    audio_enc->channels = audio_channels;
3255
            }
3256
            audio_enc->sample_rate = audio_sample_rate;
3257
        }
3258

    
3259
        oc->nb_streams = nb_streams;
3260

    
3261
        if (!nb_streams) {
3262
            fprintf(stderr, "No audio or video streams available\n");
3263
            exit(1);
3264
        }
3265

    
3266
        oc->timestamp = rec_timestamp;
3267
            
3268
        if (str_title)
3269
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3270
        if (str_author)
3271
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3272
        if (str_copyright)
3273
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3274
        if (str_comment)
3275
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3276
    }
3277

    
3278
    output_files[nb_output_files++] = oc;
3279

    
3280
    strcpy(oc->filename, filename);
3281

    
3282
    /* check filename in case of an image number is expected */
3283
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3284
        if (filename_number_test(oc->filename) < 0) {
3285
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3286
            exit(1);
3287
        }
3288
    }
3289

    
3290
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3291
        /* test if it already exists to avoid loosing precious files */
3292
        if (!file_overwrite && 
3293
            (strchr(filename, ':') == NULL ||
3294
             strstart(filename, "file:", NULL))) {
3295
            if (url_exist(filename)) {
3296
                int c;
3297
                
3298
                if ( !using_stdin ) {
3299
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3300
                    fflush(stderr);
3301
                    c = getchar();
3302
                    if (toupper(c) != 'Y') {
3303
                        fprintf(stderr, "Not overwriting - exiting\n");
3304
                        exit(1);
3305
                    }
3306
                                }
3307
                                else {
3308
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3309
                    exit(1);
3310
                                }
3311
            }
3312
        }
3313
        
3314
        /* open the file */
3315
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3316
            fprintf(stderr, "Could not open '%s'\n", filename);
3317
            exit(1);
3318
        }
3319
    }
3320

    
3321
    memset(ap, 0, sizeof(*ap));
3322
    ap->image_format = image_format;
3323
    if (av_set_parameters(oc, ap) < 0) {
3324
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3325
                oc->filename);
3326
        exit(1);
3327
    }
3328

    
3329
    oc->packet_size= mux_packet_size;
3330
    oc->mux_rate= mux_rate;
3331

    
3332
    /* reset some options */
3333
    file_oformat = NULL;
3334
    file_iformat = NULL;
3335
    image_format = NULL;
3336
    audio_disable = 0;
3337
    video_disable = 0;
3338
    audio_codec_id = CODEC_ID_NONE;
3339
    video_codec_id = CODEC_ID_NONE;
3340
    audio_stream_copy = 0;
3341
    video_stream_copy = 0;
3342
}
3343

    
3344
/* prepare dummy protocols for grab */
3345
static void prepare_grab(void)
3346
{
3347
    int has_video, has_audio, i, j;
3348
    AVFormatContext *oc;
3349
    AVFormatContext *ic;
3350
    AVFormatParameters vp1, *vp = &vp1;
3351
    AVFormatParameters ap1, *ap = &ap1;
3352
    
3353
    /* see if audio/video inputs are needed */
3354
    has_video = 0;
3355
    has_audio = 0;
3356
    memset(ap, 0, sizeof(*ap));
3357
    memset(vp, 0, sizeof(*vp));
3358
    vp->frame_rate_base= 1;
3359
    for(j=0;j<nb_output_files;j++) {
3360
        oc = output_files[j];
3361
        for(i=0;i<oc->nb_streams;i++) {
3362
            AVCodecContext *enc = &oc->streams[i]->codec;
3363
            switch(enc->codec_type) {
3364
            case CODEC_TYPE_AUDIO:
3365
                if (enc->sample_rate > ap->sample_rate)
3366
                    ap->sample_rate = enc->sample_rate;
3367
                if (enc->channels > ap->channels)
3368
                    ap->channels = enc->channels;
3369
                has_audio = 1;
3370
                break;
3371
            case CODEC_TYPE_VIDEO:
3372
                if (enc->width > vp->width)
3373
                    vp->width = enc->width;
3374
                if (enc->height > vp->height)
3375
                    vp->height = enc->height;
3376
                
3377
                if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3378
                    vp->frame_rate      = enc->frame_rate;
3379
                    vp->frame_rate_base = enc->frame_rate_base;
3380
                }
3381
                has_video = 1;
3382
                break;
3383
            default:
3384
                av_abort();
3385
            }
3386
        }
3387
    }
3388
    
3389
    if (has_video == 0 && has_audio == 0) {
3390
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3391
        exit(1);
3392
    }
3393
    
3394
    if (has_video) {
3395
        AVInputFormat *fmt1;
3396
        fmt1 = av_find_input_format(video_grab_format);
3397
        vp->device  = video_device;
3398
        vp->channel = video_channel;
3399
        vp->standard = video_standard;
3400
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3401
            fprintf(stderr, "Could not find video grab device\n");
3402
            exit(1);
3403
        }
3404
        /* If not enough info to get the stream parameters, we decode the
3405
           first frames to get it. */
3406
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3407
            fprintf(stderr, "Could not find video grab parameters\n");
3408
            exit(1);
3409
        }
3410
        /* by now video grab has one stream */
3411
        ic->streams[0]->r_frame_rate      = vp->frame_rate;
3412
        ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3413
        input_files[nb_input_files] = ic;
3414

    
3415
        if (verbose >= 0)
3416
            dump_format(ic, nb_input_files, "", 0);
3417

    
3418
        nb_input_files++;
3419
    }
3420
    if (has_audio && audio_grab_format) {
3421
        AVInputFormat *fmt1;
3422
        fmt1 = av_find_input_format(audio_grab_format);
3423
        ap->device = audio_device;
3424
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3425
            fprintf(stderr, "Could not find audio grab device\n");
3426
            exit(1);
3427
        }
3428
        input_files[nb_input_files] = ic;
3429

    
3430
        if (verbose >= 0)
3431
            dump_format(ic, nb_input_files, "", 0);
3432

    
3433
        nb_input_files++;
3434
    }
3435
}
3436

    
3437
/* same option as mencoder */
3438
static void opt_pass(const char *pass_str)
3439
{
3440
    int pass;
3441
    pass = atoi(pass_str);
3442
    if (pass != 1 && pass != 2) {
3443
        fprintf(stderr, "pass number can be only 1 or 2\n");
3444
        exit(1);
3445
    }
3446
    do_pass = pass;
3447
}
3448

    
3449
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3450
static int64_t getutime(void)
3451
{
3452
  return av_gettime();
3453
}
3454
#else
3455
static int64_t getutime(void)
3456
{
3457
    struct rusage rusage;
3458

    
3459
    getrusage(RUSAGE_SELF, &rusage);
3460
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3461
}
3462
#endif
3463

    
3464
extern int ffm_nopts;
3465

    
3466
static void opt_bitexact(void)
3467
{
3468
    bitexact=1;
3469
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3470
    ffm_nopts = 1;
3471
}
3472

    
3473
static void show_formats(void)
3474
{
3475
    AVInputFormat *ifmt;
3476
    AVOutputFormat *ofmt;
3477
    AVImageFormat *image_fmt;
3478
    URLProtocol *up;
3479
    AVCodec *p, *p2;
3480
    const char **pp, *last_name;
3481

    
3482
    printf("File formats:\n");
3483
    last_name= "000";
3484
    for(;;){
3485
        int decode=0;
3486
        int encode=0;
3487
        const char *name=NULL;
3488

    
3489
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3490
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3491
                strcmp(ofmt->name, last_name)>0){
3492
                name= ofmt->name;
3493
                encode=1;
3494
            }
3495
        }
3496
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3497
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3498
                strcmp(ifmt->name, last_name)>0){
3499
                name= ifmt->name;
3500
                encode=0;
3501
            }
3502
            if(name && strcmp(ifmt->name, name)==0)
3503
                decode=1;
3504
        }
3505
        if(name==NULL)
3506
            break;
3507
        last_name= name;
3508
        
3509
        printf(
3510
            " %s%s %s\n", 
3511
            decode ? "D":" ", 
3512
            encode ? "E":" ", 
3513
            name);
3514
    }
3515
    printf("\n");
3516

    
3517
    printf("Image formats:\n");
3518
    for(image_fmt = first_image_format; image_fmt != NULL; 
3519
        image_fmt = image_fmt->next) {
3520
        printf(
3521
            " %s%s %s\n",
3522
            image_fmt->img_read  ? "D":" ",
3523
            image_fmt->img_write ? "E":" ",
3524
            image_fmt->name);
3525
    }
3526
    printf("\n");
3527

    
3528
    printf("Codecs:\n");
3529
    last_name= "000";
3530
    for(;;){
3531
        int decode=0;
3532
        int encode=0;
3533
        int cap=0;
3534

    
3535
        p2=NULL;
3536
        for(p = first_avcodec; p != NULL; p = p->next) {
3537
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3538
                strcmp(p->name, last_name)>0){
3539
                p2= p;
3540
                decode= encode= cap=0;
3541
            }
3542
            if(p2 && strcmp(p->name, p2->name)==0){
3543
                if(p->decode) decode=1;
3544
                if(p->encode) encode=1;
3545
                cap |= p->capabilities;
3546
            }
3547
        }
3548
        if(p2==NULL)
3549
            break;
3550
        last_name= p2->name;
3551
        
3552
        printf(
3553
            " %s%s%s%s%s%s %s", 
3554
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
3555
            encode ? "E":" ", 
3556
            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3557
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3558
            cap & CODEC_CAP_DR1 ? "D":" ",
3559
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3560
            p2->name);
3561
       /* if(p2->decoder && decode==0)
3562
            printf(" use %s for decoding", p2->decoder->name);*/
3563
        printf("\n");
3564
    }
3565
    printf("\n");
3566

    
3567
    printf("Supported file protocols:\n");
3568
    for(up = first_protocol; up != NULL; up = up->next)
3569
        printf(" %s:", up->name);
3570
    printf("\n");
3571
    
3572
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3573
    printf("Motion estimation methods:\n");
3574
    pp = motion_str;
3575
    while (*pp) {
3576
        printf(" %s", *pp);
3577
        if ((pp - motion_str + 1) == ME_ZERO) 
3578
            printf("(fastest)");
3579
        else if ((pp - motion_str + 1) == ME_FULL) 
3580
            printf("(slowest)");
3581
        else if ((pp - motion_str + 1) == ME_EPZS) 
3582
            printf("(default)");
3583
        pp++;
3584
    }
3585
    printf("\n\n");
3586
    printf(
3587
"Note, the names of encoders and decoders dont always match, so there are\n"
3588
"several cases where the above table shows encoder only or decoder only entries\n"
3589
"even though both encoding and decoding are supported for example, the h263\n"
3590
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3591
"worse\n");
3592
    exit(1);
3593
}
3594

    
3595
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3596
{
3597
    int i;
3598
    const char *p = str;
3599
    for(i = 0;; i++) {
3600
        dest[i] = atoi(p);
3601
        if(i == 63)
3602
            break;
3603
        p = strchr(p, ',');
3604
        if(!p) {
3605
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3606
            exit(1);
3607
        }
3608
        p++;
3609
    }
3610
}
3611

    
3612
void opt_inter_matrix(const char *arg)
3613
{
3614
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3615
    parse_matrix_coeffs(inter_matrix, arg);
3616
}
3617

    
3618
void opt_intra_matrix(const char *arg)
3619
{
3620
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3621
    parse_matrix_coeffs(intra_matrix, arg);
3622
}
3623

    
3624
static void opt_target(const char *arg)
3625
{
3626
    int norm = -1;
3627

    
3628
    if(!strncmp(arg, "pal-", 4)) {
3629
        norm = 0;
3630
        arg += 4;
3631
    } else if(!strncmp(arg, "ntsc-", 5)) {
3632
        norm = 1;
3633
        arg += 5;
3634
    } else {
3635
        int fr;
3636
        /* Calculate FR via float to avoid int overflow */
3637
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3638
        if(fr == 25000) {
3639
            norm = 0;
3640
        } else if((fr == 29970) || (fr == 23976)) {
3641
            norm = 1;
3642
        } else {
3643
            /* Try to determine PAL/NTSC by peeking in the input files */
3644
            if(nb_input_files) {
3645
                int i, j;
3646
                for(j = 0; j < nb_input_files; j++) {
3647
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3648
                        AVCodecContext *c = &input_files[j]->streams[i]->codec;
3649
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3650
                            continue;
3651
                        fr = c->frame_rate * 1000 / c->frame_rate_base;
3652
                        if(fr == 25000) {
3653
                            norm = 0;
3654
                            break;
3655
                        } else if((fr == 29970) || (fr == 23976)) {
3656
                            norm = 1;
3657
                            break;
3658
                        }
3659
                    }
3660
                    if(norm >= 0)
3661
                        break;
3662
                }
3663
            }
3664
        }
3665
        if(verbose && norm >= 0)
3666
            printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3667
    }
3668

    
3669
    if(norm < 0) {
3670
        fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3671
        fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3672
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3673
        exit(1);
3674
    }
3675

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

    
3678
        opt_video_codec("mpeg1video");
3679
        opt_audio_codec("mp2");
3680
        opt_format("vcd");
3681

    
3682
        opt_frame_size(norm ? "352x240" : "352x288");
3683

    
3684
        video_bit_rate = 1150000;
3685
        video_rc_max_rate = 1150000;
3686
        video_rc_min_rate = 1150000;
3687
        video_rc_buffer_size = 40*1024*8;
3688

    
3689
        audio_bit_rate = 224000;
3690
        audio_sample_rate = 44100;
3691
        
3692
        mux_packet_size= 2324;
3693
        mux_rate= 2352 * 75 * 8;
3694

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

    
3697
        opt_video_codec("mpeg2video");
3698
        opt_audio_codec("mp2");
3699
        opt_format("svcd");
3700

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

    
3704
        video_bit_rate = 2040000;
3705
        video_rc_max_rate = 2516000;
3706
        video_rc_min_rate = 0; //1145000;
3707
        video_rc_buffer_size = 224*1024*8;
3708
        use_scan_offset = 1;
3709

    
3710
        audio_bit_rate = 224000;
3711
        audio_sample_rate = 44100;
3712

    
3713
        mux_packet_size= 2324;
3714

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

    
3717
        opt_video_codec("mpeg2video");
3718
        opt_audio_codec("ac3");
3719
        opt_format("dvd");
3720

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

    
3724
        video_bit_rate = 6000000;
3725
        video_rc_max_rate = 9000000;
3726
        video_rc_min_rate = 0; //1500000;
3727
        video_rc_buffer_size = 224*1024*8;
3728

    
3729
        audio_bit_rate = 448000;
3730
        audio_sample_rate = 48000;
3731

    
3732
    } else {
3733
        fprintf(stderr, "Unknown target: %s\n", arg);
3734
        exit(1);
3735
    }
3736
}
3737

    
3738
static void show_version(void)
3739
{
3740
    printf("ffmpeg      " FFMPEG_VERSION "\n"
3741
           "libavcodec  %d\n"
3742
           "libavformat %d\n", 
3743
           avcodec_build(), LIBAVFORMAT_BUILD);
3744
    exit(1);
3745
}
3746

    
3747
const OptionDef options[] = {
3748
    /* main options */
3749
    { "L", 0, {(void*)show_license}, "show license" },
3750
    { "h", 0, {(void*)show_help}, "show help" },
3751
    { "version", 0, {(void*)show_version}, "show version" },
3752
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3753
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3754
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3755
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3756
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3757
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3758
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3759
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3760
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3761
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3762
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3763
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3764
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3765
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3766
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3767
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3768
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3769
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
3770
      "add timings for benchmarking" },
3771
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
3772
      "dump each input packet" },
3773
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
3774
      "when dumping packets, also dump the payload" },
3775
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
3776
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3777
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3778
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3779
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3780
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3781
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3782
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3783
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3784

    
3785
    /* video options */
3786
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3787
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3788
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3789
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3790
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3791
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3792
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3793
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3794
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3795
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3796
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3797
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3798
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3799
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3800
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3801
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3802
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3803
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3804
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3805
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3806
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3807
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3808
    { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3809
    { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3810
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3811
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3812
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3813
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3814
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3815
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3816
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3817
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3818
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3819
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3820
//    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3821
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3822
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3823
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3824
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3825
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3826
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3827
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3828
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
3829
      "method" },
3830
    { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3831
    { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3832
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3833
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3834
    { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3835
    { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3836
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3837
    { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3838
    { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3839
    { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3840
    { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3841
    { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3842
    { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3843
    { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3844
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3845
    { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3846
    { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3847
    { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3848
    { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3849
    { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3850
    { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3851
    { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3852
    { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3853
    { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3854
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3855
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3856
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3857
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3858
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
3859
      "use same video quality as source (implies VBR)" },
3860
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3861
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3862
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
3863
      "deinterlace pictures" },
3864
    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 
3865
      "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3866
    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 
3867
      "force interlaced me support in encoder (MPEG2/MPEG4)" },
3868
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3869
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
3870
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3871
    { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3872
    { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3873
    { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3874
    { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3875
    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3876
    { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3877
    { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3878
    { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3879
    { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3880
    { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
3881
    { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3882
    { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3883
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3884
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3885
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3886
    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3887
    { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3888
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3889
    { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3890
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3891
    { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3892
    { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3893
    { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3894
    { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
3895
    { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
3896
    { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
3897
    { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
3898
    { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
3899
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3900

    
3901
    /* audio options */
3902
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3903
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3904
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3905
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3906
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3907
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3908

    
3909
    /* grab options */
3910
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3911
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3912
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3913
    { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3914
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3915
 
3916
    /* muxer options */   
3917
    { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
3918
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
3919
    { NULL, },
3920
};
3921

    
3922
static void show_banner(void)
3923
{
3924
    printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
3925
        LIBAVCODEC_BUILD);
3926
    printf("  configuration: %s\n", FFMPEG_CONFIGURATION);
3927
    printf("  built on " __DATE__ " " __TIME__);
3928
#ifdef __GNUC__
3929
    printf(", gcc: %s\n", __VERSION__);
3930
#else
3931
    printf(", using a non-gcc compiler\n");
3932
#endif
3933
}
3934

    
3935
static void show_license(void)
3936
{
3937
    show_banner();
3938
#ifdef CONFIG_GPL
3939
    printf(
3940
    "This program is free software; you can redistribute it and/or modify\n"   
3941
    "it under the terms of the GNU General Public License as published by\n"
3942
    "the Free Software Foundation; either version 2 of the License, or\n"
3943
    "(at your option) any later version.\n"
3944
    "\n"
3945
    "This program is distributed in the hope that it will be useful,\n"
3946
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3947
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3948
    "GNU General Public License for more details.\n"
3949
    "\n"
3950
    "You should have received a copy of the GNU General Public License\n"
3951
    "along with this program; if not, write to the Free Software\n"
3952
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3953
    );
3954
#else
3955
    printf(
3956
    "This library is free software; you can redistribute it and/or\n"
3957
    "modify it under the terms of the GNU Lesser General Public\n"
3958
    "License as published by the Free Software Foundation; either\n"
3959
    "version 2 of the License, or (at your option) any later version.\n"
3960
    "\n"
3961
    "This library is distributed in the hope that it will be useful,\n"
3962
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3963
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3964
    "Lesser General Public License for more details.\n"
3965
    "\n"
3966
    "You should have received a copy of the GNU Lesser General Public\n"
3967
    "License along with this library; if not, write to the Free Software\n"
3968
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3969
    );
3970
#endif
3971
    exit(1);
3972
}
3973

    
3974
static void show_help(void)
3975
{
3976
    show_banner();
3977
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3978
           "Hyper fast Audio and Video encoder\n");
3979
    printf("\n");
3980
    show_help_options(options, "Main options:\n",
3981
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3982
    show_help_options(options, "\nVideo options:\n",
3983
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3984
                      OPT_VIDEO);
3985
    show_help_options(options, "\nAdvanced Video options:\n",
3986
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3987
                      OPT_VIDEO | OPT_EXPERT);
3988
    show_help_options(options, "\nAudio options:\n",
3989
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3990
                      OPT_AUDIO);
3991
    show_help_options(options, "\nAdvanced Audio options:\n",
3992
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3993
                      OPT_AUDIO | OPT_EXPERT);
3994
    show_help_options(options, "\nAudio/Video grab options:\n",
3995
                      OPT_GRAB, 
3996
                      OPT_GRAB);
3997
    show_help_options(options, "\nAdvanced options:\n",
3998
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3999
                      OPT_EXPERT);
4000
    exit(1);
4001
}
4002

    
4003
void parse_arg_file(const char *filename)
4004
{
4005
    opt_output_file(filename);
4006
}
4007

    
4008
int main(int argc, char **argv)
4009
{
4010
    int i;
4011
    int64_t ti;
4012

    
4013
    av_register_all();
4014

    
4015
    if (argc <= 1)
4016
        show_help();
4017
    else
4018
        show_banner();
4019
    
4020
    /* parse options */
4021
    parse_options(argc, argv, options);
4022

    
4023
    /* file converter / grab */
4024
    if (nb_output_files <= 0) {
4025
        fprintf(stderr, "Must supply at least one output file\n");
4026
        exit(1);
4027
    }
4028
    
4029
    if (nb_input_files == 0) {
4030
        input_sync = 1;
4031
        prepare_grab();
4032
    }
4033

    
4034
    ti = getutime();
4035
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
4036
              stream_maps, nb_stream_maps);
4037
    ti = getutime() - ti;
4038
    if (do_benchmark) {
4039
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4040
    }
4041

    
4042
    /* close files */
4043
    for(i=0;i<nb_output_files;i++) {
4044
        /* maybe av_close_output_file ??? */
4045
        AVFormatContext *s = output_files[i];
4046
        int j;
4047
        if (!(s->oformat->flags & AVFMT_NOFILE))
4048
            url_fclose(&s->pb);
4049
        for(j=0;j<s->nb_streams;j++)
4050
            av_free(s->streams[j]);
4051
        av_free(s);
4052
    }
4053
    for(i=0;i<nb_input_files;i++)
4054
        av_close_input_file(input_files[i]);
4055

    
4056
    av_free_static();
4057

    
4058
    if(intra_matrix)
4059
        av_free(intra_matrix);
4060
    if(inter_matrix)
4061
        av_free(inter_matrix);
4062
    
4063
#ifdef POWERPC_PERFORMANCE_REPORT
4064
    extern void powerpc_display_perf_report(void);
4065
    powerpc_display_perf_report();
4066
#endif /* POWERPC_PERFORMANCE_REPORT */
4067

    
4068
#ifndef CONFIG_WIN32
4069
    if (received_sigterm) {
4070
        fprintf(stderr,
4071
            "Received signal %d: terminating.\n",
4072
            (int) received_sigterm);
4073
        exit (255);
4074
    }
4075
#endif
4076
    exit(0); /* not all OS-es handle main() return value */
4077
    return 0;
4078
}