Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ c1344911

History | View | Annotate | Download (144 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 max_frames[3] = {INT_MAX, INT_MAX, INT_MAX};
100
static int frame_rate = 25;
101
static int frame_rate_base = 1;
102
static int video_bit_rate = 200*1000;
103
static int video_bit_rate_tolerance = 4000*1000;
104
static float video_qscale = 0;
105
static int video_qmin = 2;
106
static int video_qmax = 31;
107
static int video_lmin = 2*FF_QP2LAMBDA;
108
static int video_lmax = 31*FF_QP2LAMBDA;
109
static int video_mb_qmin = 2;
110
static int video_mb_qmax = 31;
111
static int video_qdiff = 3;
112
static float video_qblur = 0.5;
113
static float video_qcomp = 0.5;
114
static uint16_t *intra_matrix = NULL;
115
static uint16_t *inter_matrix = NULL;
116
#if 0 //experimental, (can be removed)
117
static float video_rc_qsquish=1.0;
118
static float video_rc_qmod_amp=0;
119
static int video_rc_qmod_freq=0;
120
#endif
121
static char *video_rc_override_string=NULL;
122
static char *video_rc_eq="tex^qComp";
123
static int video_rc_buffer_size=0;
124
static float video_rc_buffer_aggressivity=1.0;
125
static int video_rc_max_rate=0;
126
static int video_rc_min_rate=0;
127
static float video_rc_initial_cplx=0;
128
static float video_b_qfactor = 1.25;
129
static float video_b_qoffset = 1.25;
130
static float video_i_qfactor = -0.8;
131
static float video_i_qoffset = 0.0;
132
static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
133
static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
134
static int me_method = ME_EPZS;
135
static int video_disable = 0;
136
static int video_codec_id = CODEC_ID_NONE;
137
static int video_codec_tag = 0;
138
static int same_quality = 0;
139
static int b_frames = 0;
140
static int mb_decision = FF_MB_DECISION_SIMPLE;
141
static int ildct_cmp = FF_CMP_VSAD;
142
static int mb_cmp = FF_CMP_SAD;
143
static int sub_cmp = FF_CMP_SAD;
144
static int cmp = FF_CMP_SAD;
145
static int pre_cmp = FF_CMP_SAD;
146
static int pre_me = 0;
147
static float lumi_mask = 0;
148
static float dark_mask = 0;
149
static float scplx_mask = 0;
150
static float tcplx_mask = 0;
151
static float p_mask = 0;
152
static int use_4mv = 0;
153
static int use_obmc = 0;
154
static int use_loop = 0;
155
static int use_aic = 0;
156
static int use_aiv = 0;
157
static int use_umv = 0;
158
static int use_ss = 0;
159
static int use_alt_scan = 0;
160
static int use_trell = 0;
161
static int use_scan_offset = 0;
162
static int use_qpel = 0;
163
static int use_qprd = 0;
164
static int use_cbprd = 0;
165
static int qns = 0;
166
static int closed_gop = 0;
167
static int strict_gop = 0;
168
static int do_deinterlace = 0;
169
static int do_interlace_dct = 0;
170
static int do_interlace_me = 0;
171
static int workaround_bugs = FF_BUG_AUTODETECT;
172
static int error_resilience = 2;
173
static int error_concealment = 3;
174
static int dct_algo = 0;
175
static int idct_algo = 0;
176
static int use_part = 0;
177
static int packet_size = 0;
178
static int error_rate = 0;
179
static int strict = 0;
180
static int top_field_first = -1;
181
static int noise_reduction = 0;
182
static int sc_threshold = 0;
183
static int debug = 0;
184
static int debug_mv = 0;
185
static int me_threshold = 0;
186
static int mb_threshold = 0;
187
static int intra_dc_precision = 8;
188
static int coder = 0;
189
static int context = 0;
190
static int predictor = 0;
191
static int video_profile = FF_PROFILE_UNKNOWN;
192
static int video_level = FF_LEVEL_UNKNOWN;
193
static int nsse_weight = 8;
194
static int subpel_quality= 8;
195
static int lowres= 0;
196
static int frame_skip_threshold= 0;
197
static int frame_skip_factor= 0;
198
static int frame_skip_exp= 0;
199
static int frame_skip_cmp= FF_CMP_DCTMAX;
200
extern int loop_input; /* currently a hack */
201

    
202
static int gop_size = 12;
203
static int intra_only = 0;
204
static int audio_sample_rate = 44100;
205
static int audio_bit_rate = 64000;
206
static int audio_disable = 0;
207
static int audio_channels = 1;
208
static int audio_codec_id = CODEC_ID_NONE;
209
static int audio_codec_tag = 0;
210

    
211
static int mux_rate= 0;
212
static int mux_packet_size= 0;
213
static float mux_preload= 0.5;
214
static float mux_max_delay= 0.7;
215

    
216
static int64_t recording_time = 0;
217
static int64_t start_time = 0;
218
static int64_t rec_timestamp = 0;
219
static int64_t input_ts_offset = 0;
220
static int file_overwrite = 0;
221
static char *str_title = NULL;
222
static char *str_author = NULL;
223
static char *str_copyright = NULL;
224
static char *str_comment = NULL;
225
static int do_benchmark = 0;
226
static int do_hex_dump = 0;
227
static int do_pkt_dump = 0;
228
static int do_psnr = 0;
229
static int do_vstats = 0;
230
static int do_pass = 0;
231
static int bitexact = 0;
232
static char *pass_logfilename = NULL;
233
static int audio_stream_copy = 0;
234
static int video_stream_copy = 0;
235
static int video_sync_method= 1;
236
static int audio_sync_method= 0;
237
static int copy_ts= 0;
238

    
239
static int rate_emu = 0;
240

    
241
static char *video_grab_format = "video4linux";
242
static char *video_device = NULL;
243
static char *grab_device = NULL;
244
static int  video_channel = 0;
245
static char *video_standard = "ntsc";
246

    
247
static char *audio_grab_format = "audio_device";
248
static char *audio_device = NULL;
249

    
250
static int using_stdin = 0;
251
static int using_vhook = 0;
252
static int verbose = 1;
253
static int thread_count= 1;
254
static int q_pressed = 0;
255
static int me_range = 0;
256
static int64_t video_size = 0;
257
static int64_t audio_size = 0;
258
static int64_t extra_size = 0;
259
static int nb_frames_dup = 0;
260
static int nb_frames_drop = 0;
261
static int input_sync;
262

    
263
static int pgmyuv_compatibility_hack=0;
264

    
265

    
266
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
267

    
268
typedef struct AVOutputStream {
269
    int file_index;          /* file index */
270
    int index;               /* stream index in the output file */
271
    int source_index;        /* AVInputStream index */
272
    AVStream *st;            /* stream in the output file */
273
    int encoding_needed;     /* true if encoding needed for this stream */
274
    int frame_number;
275
    /* input pts and corresponding output pts
276
       for A/V sync */
277
    double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
278
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
279
    /* video only */
280
    int video_resample;      /* video_resample and video_crop are mutually exclusive */
281
    AVFrame pict_tmp;      /* temporary image for resampling */
282
    ImgReSampleContext *img_resample_ctx; /* for image resampling */
283

    
284
    int video_crop;          /* video_resample and video_crop are mutually exclusive */
285
    int topBand;             /* cropping area sizes */
286
    int leftBand;
287
    
288
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
289
    int padtop;              /* padding area sizes */
290
    int padbottom;
291
    int padleft;
292
    int padright;
293
    
294
    /* audio only */
295
    int audio_resample;
296
    ReSampleContext *resample; /* for audio resampling */
297
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
298
    FILE *logfile;
299
} AVOutputStream;
300

    
301
typedef struct AVInputStream {
302
    int file_index;
303
    int index;
304
    AVStream *st;
305
    int discard;             /* true if stream data should be discarded */
306
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
307
    int64_t sample_index;      /* current sample */
308

    
309
    int64_t       start;     /* time when read started */
310
    unsigned long frame;     /* current frame */
311
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
312
                                is not defined */
313
    int64_t       pts;       /* current pts */
314
    int is_start;            /* is 1 at the start and after a discontinuity */
315
} AVInputStream;
316

    
317
typedef struct AVInputFile {
318
    int eof_reached;      /* true if eof reached */
319
    int ist_index;        /* index of first stream in ist_table */
320
    int buffer_size;      /* current total buffer size */
321
    int buffer_size_max;  /* buffer size at which we consider we can stop
322
                             buffering */
323
    int nb_streams;       /* nb streams we are aware of */
324
} AVInputFile;
325

    
326
#ifndef CONFIG_WIN32
327

    
328
/* init terminal so that we can grab keys */
329
static struct termios oldtty;
330

    
331
static void term_exit(void)
332
{
333
    tcsetattr (0, TCSANOW, &oldtty);
334
}
335

    
336
static volatile sig_atomic_t received_sigterm = 0;
337

    
338
static void
339
sigterm_handler(int sig)
340
{
341
    received_sigterm = sig;
342
    term_exit();
343
}
344

    
345
static void term_init(void)
346
{
347
    struct termios tty;
348

    
349
    tcgetattr (0, &tty);
350
    oldtty = tty;
351

    
352
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
353
                          |INLCR|IGNCR|ICRNL|IXON);
354
    tty.c_oflag |= OPOST;
355
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
356
    tty.c_cflag &= ~(CSIZE|PARENB);
357
    tty.c_cflag |= CS8;
358
    tty.c_cc[VMIN] = 1;
359
    tty.c_cc[VTIME] = 0;
360
    
361
    tcsetattr (0, TCSANOW, &tty);
362

    
363
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
364
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
365
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
366
    /*
367
    register a function to be called at normal program termination
368
    */
369
    atexit(term_exit);
370
#ifdef CONFIG_BEOS_NETSERVER
371
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
372
#endif
373
}
374

    
375
/* read a key without blocking */
376
static int read_key(void)
377
{
378
    int n = 1;
379
    unsigned char ch;
380
#ifndef CONFIG_BEOS_NETSERVER
381
    struct timeval tv;
382
    fd_set rfds;
383

    
384
    FD_ZERO(&rfds);
385
    FD_SET(0, &rfds);
386
    tv.tv_sec = 0;
387
    tv.tv_usec = 0;
388
    n = select(1, &rfds, NULL, NULL, &tv);
389
#endif
390
    if (n > 0) {
391
        n = read(0, &ch, 1);
392
        if (n == 1)
393
            return ch;
394

    
395
        return n;
396
    }
397
    return -1;
398
}
399

    
400
static int decode_interrupt_cb(void)
401
{
402
    return q_pressed || (q_pressed = read_key() == 'q');
403
}
404

    
405
#else
406

    
407
static volatile int received_sigterm = 0;
408

    
409
/* no interactive support */
410
static void term_exit(void)
411
{
412
}
413

    
414
static void term_init(void)
415
{
416
}
417

    
418
static int read_key(void)
419
{
420
    return 0;
421
}
422

    
423
#endif
424

    
425
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
426
{
427
    int i, err;
428
    AVFormatContext *ic;
429

    
430
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
431
    if (err < 0)
432
        return err;
433
    /* copy stream format */
434
    s->nb_streams = ic->nb_streams;
435
    for(i=0;i<ic->nb_streams;i++) {
436
        AVStream *st;
437

    
438
        st = av_mallocz(sizeof(AVStream));
439
        memcpy(st, ic->streams[i], sizeof(AVStream));
440
        s->streams[i] = st;
441
    }
442

    
443
    av_close_input_file(ic);
444
    return 0;
445
}
446

    
447
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
448

    
449
static void do_audio_out(AVFormatContext *s, 
450
                         AVOutputStream *ost, 
451
                         AVInputStream *ist,
452
                         unsigned char *buf, int size)
453
{
454
    uint8_t *buftmp;
455
    static uint8_t *audio_buf = NULL;
456
    static uint8_t *audio_out = NULL;
457
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
458

    
459
    int size_out, frame_bytes, ret;
460
    AVCodecContext *enc= &ost->st->codec;
461

    
462
    /* SC: dynamic allocation of buffers */
463
    if (!audio_buf)
464
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
465
    if (!audio_out)
466
        audio_out = av_malloc(audio_out_size);
467
    if (!audio_buf || !audio_out)
468
        return;               /* Should signal an error ! */
469

    
470
    if(audio_sync_method){
471
        double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts 
472
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
473
        double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
474
        int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
475

    
476
        //FIXME resample delay
477
        if(fabs(delta) > 50){
478
            if(ist->is_start){
479
                if(byte_delta < 0){
480
                    byte_delta= FFMAX(byte_delta, -size);
481
                    size += byte_delta;
482
                    buf  -= byte_delta;
483
                    if(verbose > 2)
484
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
485
                    if(!size)
486
                        return;
487
                    ist->is_start=0;
488
                }else{
489
                    static uint8_t *input_tmp= NULL;
490
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
491

    
492
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
493
                        ist->is_start=0;
494
                    else
495
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
496

    
497
                    memset(input_tmp, 0, byte_delta);
498
                    memcpy(input_tmp + byte_delta, buf, size);
499
                    buf= input_tmp;
500
                    size += byte_delta;
501
                    if(verbose > 2)
502
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
503
                }
504
            }else if(audio_sync_method>1){
505
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
506
                assert(ost->audio_resample);
507
                if(verbose > 2)
508
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
509
//                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));
510
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
511
            }
512
        } 
513
    }else
514
        ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
515
                        - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
516

    
517
    if (ost->audio_resample) {
518
        buftmp = audio_buf;
519
        size_out = audio_resample(ost->resample, 
520
                                  (short *)buftmp, (short *)buf,
521
                                  size / (ist->st->codec.channels * 2));
522
        size_out = size_out * enc->channels * 2;
523
    } else {
524
        buftmp = buf;
525
        size_out = size;
526
    }
527

    
528
    /* now encode as many frames as possible */
529
    if (enc->frame_size > 1) {
530
        /* output resampled raw samples */
531
        fifo_write(&ost->fifo, buftmp, size_out, 
532
                   &ost->fifo.wptr);
533

    
534
        frame_bytes = enc->frame_size * 2 * enc->channels;
535
        
536
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
537
                     &ost->fifo.rptr) == 0) {
538
            AVPacket pkt;
539
            av_init_packet(&pkt);
540

    
541
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
542
                                       (short *)audio_buf);
543
            audio_size += ret;
544
            pkt.stream_index= ost->index;
545
            pkt.data= audio_out;
546
            pkt.size= ret;
547
            if(enc->coded_frame)
548
                pkt.pts= enc->coded_frame->pts;
549
            pkt.flags |= PKT_FLAG_KEY;
550
            av_interleaved_write_frame(s, &pkt);
551
            
552
            ost->sync_opts += enc->frame_size;
553
        }
554
    } else {
555
        AVPacket pkt;
556
        av_init_packet(&pkt);
557

    
558
        ost->sync_opts += size_out / (2 * enc->channels);
559

    
560
        /* output a pcm frame */
561
        /* XXX: change encoding codec API to avoid this ? */
562
        switch(enc->codec->id) {
563
        case CODEC_ID_PCM_S16LE:
564
        case CODEC_ID_PCM_S16BE:
565
        case CODEC_ID_PCM_U16LE:
566
        case CODEC_ID_PCM_U16BE:
567
            break;
568
        default:
569
            size_out = size_out >> 1;
570
            break;
571
        }
572
        ret = avcodec_encode_audio(enc, audio_out, size_out, 
573
                                   (short *)buftmp);
574
        audio_size += ret;
575
        pkt.stream_index= ost->index;
576
        pkt.data= audio_out;
577
        pkt.size= ret;
578
        if(enc->coded_frame)
579
            pkt.pts= enc->coded_frame->pts;
580
        pkt.flags |= PKT_FLAG_KEY;
581
        av_interleaved_write_frame(s, &pkt);
582
    }
583
}
584

    
585
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
586
{
587
    AVCodecContext *dec;
588
    AVPicture *picture2;
589
    AVPicture picture_tmp;
590
    uint8_t *buf = 0;
591

    
592
    dec = &ist->st->codec;
593

    
594
    /* deinterlace : must be done before any resize */
595
    if (do_deinterlace || using_vhook) {
596
        int size;
597

    
598
        /* create temporary picture */
599
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
600
        buf = av_malloc(size);
601
        if (!buf)
602
            return;
603
        
604
        picture2 = &picture_tmp;
605
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
606

    
607
        if (do_deinterlace){
608
            if(avpicture_deinterlace(picture2, picture, 
609
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
610
                /* if error, do not deinterlace */
611
                av_free(buf);
612
                buf = NULL;
613
                picture2 = picture;
614
            }
615
        } else {
616
            if (img_convert(picture2, dec->pix_fmt, picture, 
617
                            dec->pix_fmt, dec->width, dec->height) < 0) {
618
                /* if error, do not copy */
619
                av_free(buf);
620
                buf = NULL;
621
                picture2 = picture;
622
            }
623
        }
624
    } else {
625
        picture2 = picture;
626
    }
627

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

    
630
    if (picture != picture2)
631
        *picture = *picture2;
632
    *bufp = buf;
633
}
634

    
635
/* we begin to correct av delay at this threshold */
636
#define AV_DELAY_MAX 0.100
637

    
638

    
639
/* Expects img to be yuv420 */
640
static void fill_pad_region(AVPicture* img, int height, int width,
641
        int padtop, int padbottom, int padleft, int padright, int *color) {
642
  
643
    int i, y, shift;
644
    uint8_t *optr;
645
    
646
    for (i = 0; i < 3; i++) {
647
        shift = (i == 0) ? 0 : 1;
648
        
649
        if (padtop || padleft) {
650
            memset(img->data[i], color[i], (((img->linesize[i] * padtop) + 
651
                            padleft) >> shift));
652
        }
653

    
654
        if (padleft || padright) {
655
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
656
                (img->linesize[i] - (padright >> shift));
657

    
658
            for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
659
                memset(optr, color[i], (padleft + padright) >> shift);
660
                optr += img->linesize[i];
661
            }
662
        }
663
      
664
        if (padbottom) {
665
            optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
666
            memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
667
        }
668
    }
669
}
670

    
671
static int bit_buffer_size= 1024*256;
672
static uint8_t *bit_buffer= NULL;
673

    
674
static void do_video_out(AVFormatContext *s, 
675
                         AVOutputStream *ost, 
676
                         AVInputStream *ist,
677
                         AVFrame *in_picture,
678
                         int *frame_size)
679
{
680
    int nb_frames, i, ret;
681
    AVFrame *final_picture, *formatted_picture;
682
    AVFrame picture_format_temp, picture_crop_temp;
683
    uint8_t *buf = NULL, *buf1 = NULL;
684
    AVCodecContext *enc, *dec;
685
    enum PixelFormat target_pixfmt;
686
    
687
    avcodec_get_frame_defaults(&picture_format_temp);
688
    avcodec_get_frame_defaults(&picture_crop_temp);
689

    
690
    enc = &ost->st->codec;
691
    dec = &ist->st->codec;
692

    
693
    /* by default, we output a single frame */
694
    nb_frames = 1;
695

    
696
    *frame_size = 0;
697

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

    
719
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
720
    if (nb_frames <= 0) 
721
        return;
722

    
723
    /* convert pixel format if needed */
724
    target_pixfmt = ost->video_resample || ost->video_pad
725
        ? PIX_FMT_YUV420P : enc->pix_fmt;
726
    if (dec->pix_fmt != target_pixfmt) {
727
        int size;
728

    
729
        /* create temporary picture */
730
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
731
        buf = av_malloc(size);
732
        if (!buf)
733
            return;
734
        formatted_picture = &picture_format_temp;
735
        avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
736
        
737
        if (img_convert((AVPicture*)formatted_picture, target_pixfmt, 
738
                        (AVPicture *)in_picture, dec->pix_fmt, 
739
                        dec->width, dec->height) < 0) {
740

    
741
            if (verbose >= 0)
742
                fprintf(stderr, "pixel format conversion not handled\n");
743

    
744
            goto the_end;
745
        }
746
    } else {
747
        formatted_picture = in_picture;
748
    }
749

    
750
    /* XXX: resampling could be done before raw format conversion in
751
       some cases to go faster */
752
    /* XXX: only works for YUV420P */
753
    if (ost->video_resample) {
754
        final_picture = &ost->pict_tmp;
755
        img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
756
       
757
        if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
758
            fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
759
                    ost->padtop, ost->padbottom, ost->padleft, ost->padright,
760
                    padcolor);
761
        }
762
        
763
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
764
            int size;
765
            
766
            av_free(buf);
767
            /* create temporary picture */
768
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
769
            buf = av_malloc(size);
770
            if (!buf)
771
                return;
772
            final_picture = &picture_format_temp;
773
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
774
        
775
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
776
                            (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
777
                            enc->width, enc->height) < 0) {
778

    
779
                if (verbose >= 0)
780
                    fprintf(stderr, "pixel format conversion not handled\n");
781

    
782
                goto the_end;
783
            }
784
        }
785
    } else if (ost->video_crop) {
786
        picture_crop_temp.data[0] = formatted_picture->data[0] +
787
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
788

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

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

    
797
        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
798
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
799
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
800
        final_picture = &picture_crop_temp;
801
    } else if (ost->video_pad) {
802
        final_picture = &ost->pict_tmp;
803

    
804
        for (i = 0; i < 3; i++) {
805
            uint8_t *optr, *iptr;
806
            int shift = (i == 0) ? 0 : 1;
807
            int y, yheight;
808
            
809
            /* set offset to start writing image into */
810
            optr = final_picture->data[i] + (((final_picture->linesize[i] * 
811
                            ost->padtop) + ost->padleft) >> shift);
812
            iptr = formatted_picture->data[i];
813

    
814
            yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
815
            for (y = 0; y < yheight; y++) {
816
                /* copy unpadded image row into padded image row */
817
                memcpy(optr, iptr, formatted_picture->linesize[i]);
818
                optr += final_picture->linesize[i];
819
                iptr += formatted_picture->linesize[i];
820
            }
821
        }
822

    
823
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
824
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
825
                padcolor);
826
        
827
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
828
            int size;
829

    
830
            av_free(buf);
831
            /* create temporary picture */
832
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
833
            buf = av_malloc(size);
834
            if (!buf)
835
                return;
836
            final_picture = &picture_format_temp;
837
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
838

    
839
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
840
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
841
                        enc->width, enc->height) < 0) {
842

    
843
                if (verbose >= 0)
844
                    fprintf(stderr, "pixel format conversion not handled\n");
845

    
846
                goto the_end;
847
            }
848
        }
849
    } else {
850
        final_picture = formatted_picture;
851
    }
852
    /* duplicates frame if needed */
853
    for(i=0;i<nb_frames;i++) {
854
        AVPacket pkt;
855
        av_init_packet(&pkt);
856
        pkt.stream_index= ost->index;
857

    
858
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
859
            /* raw pictures are written as AVPicture structure to
860
               avoid any copies. We support temorarily the older
861
               method. */
862
            AVFrame* old_frame = enc->coded_frame;
863
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
864
            pkt.data= (uint8_t *)final_picture;
865
            pkt.size=  sizeof(AVPicture);
866
            if(dec->coded_frame)
867
                pkt.pts= dec->coded_frame->pts;
868
            if(dec->coded_frame && dec->coded_frame->key_frame)
869
                pkt.flags |= PKT_FLAG_KEY;
870

    
871
            av_interleaved_write_frame(s, &pkt);
872
            enc->coded_frame = old_frame;
873
        } else {
874
            AVFrame big_picture;
875

    
876
            big_picture= *final_picture;
877
            /* better than nothing: use input picture interlaced
878
               settings */
879
            big_picture.interlaced_frame = in_picture->interlaced_frame;
880
            if(do_interlace_me || do_interlace_dct){
881
                if(top_field_first == -1)
882
                    big_picture.top_field_first = in_picture->top_field_first;
883
                else
884
                    big_picture.top_field_first = top_field_first;
885
            }
886

    
887
            /* handles sameq here. This is not correct because it may
888
               not be a global option */
889
            if (same_quality) {
890
                big_picture.quality = ist->st->quality;
891
            }else
892
                big_picture.quality = ost->st->quality;
893
            if(!me_threshold)
894
                big_picture.pict_type = 0;
895
//            big_picture.pts = AV_NOPTS_VALUE;
896
            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
897
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
898
            ret = avcodec_encode_video(enc, 
899
                                       bit_buffer, bit_buffer_size,
900
                                       &big_picture);
901
            //enc->frame_number = enc->real_pict_num;
902
            if(ret){
903
                pkt.data= bit_buffer;
904
                pkt.size= ret;
905
                if(enc->coded_frame)
906
                    pkt.pts= enc->coded_frame->pts;
907
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n", 
908
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
909
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
910

    
911
                if(enc->coded_frame && enc->coded_frame->key_frame)
912
                    pkt.flags |= PKT_FLAG_KEY;
913
                av_interleaved_write_frame(s, &pkt);
914
                *frame_size = ret;
915
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
916
                //        enc->frame_number-1, enc->real_pict_num, ret,
917
                //        enc->pict_type);
918
                /* if two pass, output log */
919
                if (ost->logfile && enc->stats_out) {
920
                    fprintf(ost->logfile, "%s", enc->stats_out);
921
                }
922
            }
923
        }
924
        ost->sync_opts++;
925
        ost->frame_number++;
926
    }
927
 the_end:
928
    av_free(buf);
929
    av_free(buf1);
930
}
931

    
932
static double psnr(double d){
933
    if(d==0) return INFINITY;
934
    return -10.0*log(d)/log(10.0);
935
}
936

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

    
984
static void print_report(AVFormatContext **output_files,
985
                         AVOutputStream **ost_table, int nb_ostreams,
986
                         int is_last_report)
987
{
988
    char buf[1024];
989
    AVOutputStream *ost;
990
    AVFormatContext *oc, *os;
991
    int64_t total_size;
992
    AVCodecContext *enc;
993
    int frame_number, vid, i;
994
    double bitrate, ti1, pts;
995
    static int64_t last_time = -1;
996
    
997
    if (!is_last_report) {
998
        int64_t cur_time;
999
        /* display the report every 0.5 seconds */
1000
        cur_time = av_gettime();
1001
        if (last_time == -1) {
1002
            last_time = cur_time;
1003
            return;
1004
        } 
1005
        if ((cur_time - last_time) < 500000)
1006
            return;
1007
        last_time = cur_time;
1008
    }
1009

    
1010

    
1011
    oc = output_files[0];
1012

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

    
1070
        if (verbose > 1)
1071
          sprintf(buf + strlen(buf), " dup=%d drop=%d",
1072
                  nb_frames_dup, nb_frames_drop);
1073
        
1074
        if (verbose >= 0)
1075
            fprintf(stderr, "%s    \r", buf);
1076

    
1077
        fflush(stderr);
1078
    }
1079
        
1080
    if (is_last_report && verbose >= 0){
1081
        int64_t raw= audio_size + video_size + extra_size;
1082
        fprintf(stderr, "\n");
1083
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1084
                video_size/1024.0,
1085
                audio_size/1024.0,
1086
                extra_size/1024.0,
1087
                100.0*(total_size - raw)/raw
1088
        );
1089
    }
1090
}
1091

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

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

    
1158
                    ret = avcodec_decode_video(&ist->st->codec, 
1159
                                               &picture, &got_picture, ptr, len);
1160
                    ist->st->quality= picture.quality;
1161
                    if (ret < 0) 
1162
                        goto fail_decode;
1163
                    if (!got_picture) {
1164
                        /* no picture yet */
1165
                        goto discard_packet;
1166
                    }
1167
                    if (ist->st->codec.frame_rate_base != 0) {
1168
                        ist->next_pts += ((int64_t)AV_TIME_BASE * 
1169
                                          ist->st->codec.frame_rate_base) /
1170
                            ist->st->codec.frame_rate;
1171
                    }
1172
                    len = 0;
1173
                    break;
1174
                default:
1175
                    goto fail_decode;
1176
                }
1177
            } else {
1178
                switch(ist->st->codec.codec_type) {
1179
                case CODEC_TYPE_AUDIO:
1180
                    ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec.frame_size) / 
1181
                        (ist->st->codec.sample_rate * ist->st->codec.channels);
1182
                    break;
1183
                case CODEC_TYPE_VIDEO:
1184
                    if (ist->st->codec.frame_rate_base != 0) {
1185
                        ist->next_pts += ((int64_t)AV_TIME_BASE * 
1186
                                          ist->st->codec.frame_rate_base) /
1187
                            ist->st->codec.frame_rate;
1188
                    }
1189
                    break;
1190
                }
1191
                data_buf = ptr;
1192
                data_size = len;
1193
                ret = len;
1194
                len = 0;
1195
            }
1196

    
1197
            buffer_to_free = NULL;
1198
            if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1199
                pre_process_video_frame(ist, (AVPicture *)&picture, 
1200
                                        &buffer_to_free);
1201
            }
1202

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

    
1210
                ist->frame++;
1211
            }
1212

    
1213
#if 0
1214
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1215
               is the one of the next displayed one */
1216
            /* XXX: add mpeg4 too ? */
1217
            if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1218
                if (ist->st->codec.pict_type != B_TYPE) {
1219
                    int64_t tmp;
1220
                    tmp = ist->last_ip_pts;
1221
                    ist->last_ip_pts  = ist->frac_pts.val;
1222
                    ist->frac_pts.val = tmp;
1223
                }
1224
            }
1225
#endif
1226
            /* if output time reached then transcode raw format, 
1227
               encode packets and output them */
1228
            if (start_time == 0 || ist->pts >= start_time)
1229
                for(i=0;i<nb_ostreams;i++) {
1230
                    int frame_size;
1231

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

    
1236
#if 0
1237
                        printf("%d: got pts=%0.3f %0.3f\n", i, 
1238
                               (double)pkt->pts / AV_TIME_BASE, 
1239
                               ((double)ist->pts / AV_TIME_BASE) - 
1240
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1241
#endif
1242
                        /* set the input output pts pairs */
1243
                        ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1244

    
1245
                        if (ost->encoding_needed) {
1246
                            switch(ost->st->codec.codec_type) {
1247
                            case CODEC_TYPE_AUDIO:
1248
                                do_audio_out(os, ost, ist, data_buf, data_size);
1249
                                break;
1250
                            case CODEC_TYPE_VIDEO:
1251
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1252
                                    video_size += frame_size;
1253
                                    if (do_vstats && frame_size)
1254
                                        do_video_stats(os, ost, frame_size);
1255
                                break;
1256
                            default:
1257
                                av_abort();
1258
                            }
1259
                        } else {
1260
                            AVFrame avframe; //FIXME/XXX remove this
1261
                            AVPacket opkt;
1262
                            av_init_packet(&opkt);
1263

    
1264
                            /* no reencoding needed : output the packet directly */
1265
                            /* force the input stream PTS */
1266
                        
1267
                            avcodec_get_frame_defaults(&avframe);
1268
                            ost->st->codec.coded_frame= &avframe;
1269
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1270

    
1271
                            if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1272
                                audio_size += data_size;
1273
                            else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1274
                                video_size += data_size;
1275
                                ost->sync_opts++;
1276
                            }
1277

    
1278
                            opkt.stream_index= ost->index;
1279
                            opkt.data= data_buf;
1280
                            opkt.size= data_size;
1281
                            if(pkt->pts != AV_NOPTS_VALUE)
1282
                                opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1283
                            else
1284
                                opkt.pts= AV_NOPTS_VALUE;
1285
                            opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1286
                            opkt.flags= pkt->flags;
1287
                            
1288
                            av_interleaved_write_frame(os, &opkt);
1289
                            ost->st->codec.frame_number++;
1290
                            ost->frame_number++;
1291
                        }
1292
                    }
1293
                }
1294
            av_free(buffer_to_free);
1295
        }
1296
 discard_packet:
1297
    if (pkt == NULL) {
1298
        /* EOF handling */
1299
  
1300
        for(i=0;i<nb_ostreams;i++) {
1301
            ost = ost_table[i];
1302
            if (ost->source_index == ist_index) {
1303
                AVCodecContext *enc= &ost->st->codec;
1304
                os = output_files[ost->file_index];
1305
                
1306
                if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1307
                    continue;
1308
                if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1309
                    continue;
1310

    
1311
                if (ost->encoding_needed) {
1312
                    for(;;) {
1313
                        AVPacket pkt;
1314
                        av_init_packet(&pkt);
1315
                        pkt.stream_index= ost->index;
1316
 
1317
                        switch(ost->st->codec.codec_type) {
1318
                        case CODEC_TYPE_AUDIO:        
1319
                            ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1320
                            audio_size += ret;
1321
                            pkt.flags |= PKT_FLAG_KEY;
1322
                            break;
1323
                        case CODEC_TYPE_VIDEO:
1324
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1325
                            video_size += ret;
1326
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1327
                                pkt.flags |= PKT_FLAG_KEY;
1328
                            if (ost->logfile && enc->stats_out) {
1329
                                fprintf(ost->logfile, "%s", enc->stats_out);
1330
                            }
1331
                            break;
1332
                        default:
1333
                            ret=-1;
1334
                        }
1335
                            
1336
                        if(ret<=0)
1337
                            break;
1338
                        pkt.data= bit_buffer;
1339
                        pkt.size= ret;
1340
                        if(enc->coded_frame)
1341
                            pkt.pts= enc->coded_frame->pts;
1342
                        av_interleaved_write_frame(os, &pkt);
1343
                    }
1344
                }
1345
            }
1346
        }
1347
    }
1348
 
1349
    return 0;
1350
 fail_decode:
1351
    return -1;
1352
}
1353

    
1354

    
1355
/*
1356
 * The following code is the main loop of the file converter
1357
 */
1358
static int av_encode(AVFormatContext **output_files,
1359
                     int nb_output_files,
1360
                     AVFormatContext **input_files,
1361
                     int nb_input_files,
1362
                     AVStreamMap *stream_maps, int nb_stream_maps)
1363
{
1364
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1365
    AVFormatContext *is, *os;
1366
    AVCodecContext *codec, *icodec;
1367
    AVOutputStream *ost, **ost_table = NULL;
1368
    AVInputStream *ist, **ist_table = NULL;
1369
    AVInputFile *file_table;
1370
    AVFormatContext *stream_no_data;
1371
    int key;
1372

    
1373
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1374
    if (!file_table)
1375
        goto fail;
1376
        
1377
    /* input stream init */
1378
    j = 0;
1379
    for(i=0;i<nb_input_files;i++) {
1380
        is = input_files[i];
1381
        file_table[i].ist_index = j;
1382
        file_table[i].nb_streams = is->nb_streams;
1383
        j += is->nb_streams;
1384
    }
1385
    nb_istreams = j;
1386

    
1387
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1388
    if (!ist_table)
1389
        goto fail;
1390
    
1391
    for(i=0;i<nb_istreams;i++) {
1392
        ist = av_mallocz(sizeof(AVInputStream));
1393
        if (!ist)
1394
            goto fail;
1395
        ist_table[i] = ist;
1396
    }
1397
    j = 0;
1398
    for(i=0;i<nb_input_files;i++) {
1399
        is = input_files[i];
1400
        for(k=0;k<is->nb_streams;k++) {
1401
            ist = ist_table[j++];
1402
            ist->st = is->streams[k];
1403
            ist->file_index = i;
1404
            ist->index = k;
1405
            ist->discard = 1; /* the stream is discarded by default
1406
                                 (changed later) */
1407

    
1408
            if (ist->st->codec.rate_emu) {
1409
                ist->start = av_gettime();
1410
                ist->frame = 0;
1411
            }
1412
        }
1413
    }
1414

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

    
1426
    /* Sanity check the mapping args -- do the input files & streams exist? */
1427
    for(i=0;i<nb_stream_maps;i++) {
1428
        int fi = stream_maps[i].file_index;
1429
        int si = stream_maps[i].stream_index;
1430
        
1431
        if (fi < 0 || fi > nb_input_files - 1 ||
1432
            si < 0 || si > file_table[fi].nb_streams - 1) {
1433
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1434
            exit(1);
1435
        }
1436
    }
1437
    
1438
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1439
    if (!ost_table)
1440
        goto fail;
1441
    for(i=0;i<nb_ostreams;i++) {
1442
        ost = av_mallocz(sizeof(AVOutputStream));
1443
        if (!ost)
1444
            goto fail;
1445
        ost_table[i] = ost;
1446
    }
1447
    
1448
    n = 0;
1449
    for(k=0;k<nb_output_files;k++) {
1450
        os = output_files[k];
1451
        for(i=0;i<os->nb_streams;i++) {
1452
            int found;
1453
            ost = ost_table[n++];
1454
            ost->file_index = k;
1455
            ost->index = i;
1456
            ost->st = os->streams[i];
1457
            if (nb_stream_maps > 0) {
1458
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index + 
1459
                    stream_maps[n-1].stream_index;
1460
                    
1461
                /* Sanity check that the stream types match */
1462
                if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1463
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1464
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1465
                        ost->file_index, ost->index);
1466
                    exit(1);
1467
                }
1468
                
1469
            } else {
1470
                /* get corresponding input stream index : we select the first one with the right type */
1471
                found = 0;
1472
                for(j=0;j<nb_istreams;j++) {
1473
                    ist = ist_table[j];
1474
                    if (ist->discard && 
1475
                        ist->st->codec.codec_type == ost->st->codec.codec_type) {
1476
                        ost->source_index = j;
1477
                        found = 1;
1478
                        break;
1479
                    }
1480
                }
1481
                
1482
                if (!found) {
1483
                    /* try again and reuse existing stream */
1484
                    for(j=0;j<nb_istreams;j++) {
1485
                        ist = ist_table[j];
1486
                        if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1487
                            ost->source_index = j;
1488
                            found = 1;
1489
                        }
1490
                    }
1491
                    if (!found) {
1492
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1493
                                ost->file_index, ost->index);
1494
                        exit(1);
1495
                    }
1496
                }
1497
            }
1498
            ist = ist_table[ost->source_index];
1499
            ist->discard = 0;
1500
        }
1501
    }
1502

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

    
1508
        codec = &ost->st->codec;
1509
        icodec = &ist->st->codec;
1510

    
1511
        if (ost->st->stream_copy) {
1512
            /* if stream_copy is selected, no need to decode or encode */
1513
            codec->codec_id = icodec->codec_id;
1514
            codec->codec_type = icodec->codec_type;
1515
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1516
            codec->bit_rate = icodec->bit_rate;
1517
            switch(codec->codec_type) {
1518
            case CODEC_TYPE_AUDIO:
1519
                codec->sample_rate = icodec->sample_rate;
1520
                codec->channels = icodec->channels;
1521
                codec->frame_size = icodec->frame_size;
1522
                codec->block_align= icodec->block_align;
1523
                break;
1524
            case CODEC_TYPE_VIDEO:
1525
                codec->frame_rate = icodec->frame_rate;
1526
                codec->frame_rate_base = icodec->frame_rate_base;
1527
                codec->width = icodec->width;
1528
                codec->height = icodec->height;
1529
                break;
1530
            default:
1531
                av_abort();
1532
            }
1533
        } else {
1534
            switch(codec->codec_type) {
1535
            case CODEC_TYPE_AUDIO:
1536
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1537
                    goto fail;
1538
                
1539
                if (codec->channels == icodec->channels &&
1540
                    codec->sample_rate == icodec->sample_rate) {
1541
                    ost->audio_resample = 0;
1542
                } else {
1543
                    if (codec->channels != icodec->channels &&
1544
                        (icodec->codec_id == CODEC_ID_AC3 ||
1545
                         icodec->codec_id == CODEC_ID_DTS)) {
1546
                        /* Special case for 5:1 AC3 and DTS input */
1547
                        /* and mono or stereo output      */
1548
                        /* Request specific number of channels */
1549
                        icodec->channels = codec->channels;
1550
                        if (codec->sample_rate == icodec->sample_rate)
1551
                            ost->audio_resample = 0;
1552
                        else {
1553
                            ost->audio_resample = 1;
1554
                        }
1555
                    } else {
1556
                        ost->audio_resample = 1; 
1557
                    }
1558
                }
1559
                if(audio_sync_method>1)
1560
                    ost->audio_resample = 1;
1561

    
1562
                if(ost->audio_resample){
1563
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1564
                                                    codec->sample_rate, icodec->sample_rate);
1565
                    if(!ost->resample){
1566
                        printf("Can't resample.  Aborting.\n");
1567
                        av_abort();
1568
                    }
1569
                }
1570
                ist->decoding_needed = 1;
1571
                ost->encoding_needed = 1;
1572
                break;
1573
            case CODEC_TYPE_VIDEO:
1574
                if (codec->width == icodec->width &&
1575
                    codec->height == icodec->height &&
1576
                    frame_topBand == 0 &&
1577
                    frame_bottomBand == 0 &&
1578
                    frame_leftBand == 0 &&
1579
                    frame_rightBand == 0 && 
1580
                    frame_padtop == 0 &&
1581
                    frame_padbottom == 0 &&
1582
                    frame_padleft == 0 &&
1583
                    frame_padright == 0)
1584
                {
1585
                    ost->video_resample = 0;
1586
                    ost->video_crop = 0;
1587
                    ost->video_pad = 0;
1588
                } else if ((codec->width == icodec->width -
1589
                                (frame_leftBand + frame_rightBand)) &&
1590
                        (codec->height == icodec->height -
1591
                                (frame_topBand  + frame_bottomBand)))
1592
                {
1593
                    ost->video_resample = 0;
1594
                    ost->video_crop = 1;
1595
                    ost->topBand = frame_topBand;
1596
                    ost->leftBand = frame_leftBand;
1597
                } else if ((codec->width == icodec->width + 
1598
                                (frame_padleft + frame_padright)) &&
1599
                        (codec->height == icodec->height +
1600
                                (frame_padtop + frame_padbottom))) {
1601
                    ost->video_resample = 0;
1602
                    ost->video_crop = 0;
1603
                    ost->video_pad = 1;
1604
                    ost->padtop = frame_padtop;
1605
                    ost->padleft = frame_padleft;
1606
                    ost->padbottom = frame_padbottom;
1607
                    ost->padright = frame_padright;
1608
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1609
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1610
                                codec->width, codec->height ) )
1611
                        goto fail;
1612
                } else {
1613
                    ost->video_resample = 1;
1614
                    ost->video_crop = 0; // cropping is handled as part of resample
1615
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1616
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1617
                                         codec->width, codec->height ) )
1618
                        goto fail;
1619

    
1620
                    ost->img_resample_ctx = img_resample_full_init( 
1621
                                      ost->st->codec.width, ost->st->codec.height,
1622
                                      ist->st->codec.width, ist->st->codec.height,
1623
                                      frame_topBand, frame_bottomBand,
1624
                            frame_leftBand, frame_rightBand, 
1625
                            frame_padtop, frame_padbottom, 
1626
                            frame_padleft, frame_padright);
1627
                    
1628
                    ost->padtop = frame_padtop;
1629
                    ost->padleft = frame_padleft;
1630
                    ost->padbottom = frame_padbottom;
1631
                    ost->padright = frame_padright;
1632
                   
1633
                }
1634
                ost->encoding_needed = 1;
1635
                ist->decoding_needed = 1;
1636
                break;
1637
            default:
1638
                av_abort();
1639
            }
1640
            /* two pass mode */
1641
            if (ost->encoding_needed && 
1642
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1643
                char logfilename[1024];
1644
                FILE *f;
1645
                int size;
1646
                char *logbuffer;
1647
                
1648
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 
1649
                         pass_logfilename ? 
1650
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1651
                if (codec->flags & CODEC_FLAG_PASS1) {
1652
                    f = fopen(logfilename, "w");
1653
                    if (!f) {
1654
                        perror(logfilename);
1655
                        exit(1);
1656
                    }
1657
                    ost->logfile = f;
1658
                } else {
1659
                    /* read the log file */
1660
                    f = fopen(logfilename, "r");
1661
                    if (!f) {
1662
                        perror(logfilename);
1663
                        exit(1);
1664
                    }
1665
                    fseek(f, 0, SEEK_END);
1666
                    size = ftell(f);
1667
                    fseek(f, 0, SEEK_SET);
1668
                    logbuffer = av_malloc(size + 1);
1669
                    if (!logbuffer) {
1670
                        fprintf(stderr, "Could not allocate log buffer\n");
1671
                        exit(1);
1672
                    }
1673
                    size = fread(logbuffer, 1, size, f);
1674
                    fclose(f);
1675
                    logbuffer[size] = '\0';
1676
                    codec->stats_in = logbuffer;
1677
                }
1678
            }
1679
        }
1680
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1681
            int size= codec->width * codec->height;
1682
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1683
        }
1684
    }
1685

    
1686
    if (!bit_buffer)
1687
        bit_buffer = av_malloc(bit_buffer_size);
1688
    if (!bit_buffer)
1689
        goto fail;
1690

    
1691
    /* dump the file output parameters - cannot be done before in case
1692
       of stream copy */
1693
    for(i=0;i<nb_output_files;i++) {
1694
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1695
    }
1696

    
1697
    /* dump the stream mapping */
1698
    if (verbose >= 0) {
1699
        fprintf(stderr, "Stream mapping:\n");
1700
        for(i=0;i<nb_ostreams;i++) {
1701
            ost = ost_table[i];
1702
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1703
                    ist_table[ost->source_index]->file_index,
1704
                    ist_table[ost->source_index]->index,
1705
                    ost->file_index, 
1706
                    ost->index);
1707
        }
1708
    }
1709

    
1710
    /* open each encoder */
1711
    for(i=0;i<nb_ostreams;i++) {
1712
        ost = ost_table[i];
1713
        if (ost->encoding_needed) {
1714
            AVCodec *codec;
1715
            codec = avcodec_find_encoder(ost->st->codec.codec_id);
1716
            if (!codec) {
1717
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n", 
1718
                        ost->file_index, ost->index);
1719
                exit(1);
1720
            }
1721
            if (avcodec_open(&ost->st->codec, codec) < 0) {
1722
                fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n", 
1723
                        ost->file_index, ost->index);
1724
                exit(1);
1725
            }
1726
            extra_size += ost->st->codec.extradata_size;
1727
        }
1728
    }
1729

    
1730
    /* open each decoder */
1731
    for(i=0;i<nb_istreams;i++) {
1732
        ist = ist_table[i];
1733
        if (ist->decoding_needed) {
1734
            AVCodec *codec;
1735
            codec = avcodec_find_decoder(ist->st->codec.codec_id);
1736
            if (!codec) {
1737
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n", 
1738
                        ist->st->codec.codec_id, ist->file_index, ist->index);
1739
                exit(1);
1740
            }
1741
            if (avcodec_open(&ist->st->codec, codec) < 0) {
1742
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
1743
                        ist->file_index, ist->index);
1744
                exit(1);
1745
            }
1746
            //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1747
            //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1748
        }
1749
    }
1750

    
1751
    /* init pts */
1752
    for(i=0;i<nb_istreams;i++) {
1753
        ist = ist_table[i];
1754
        is = input_files[ist->file_index];
1755
        ist->pts = 0;
1756
        ist->next_pts = ist->st->start_time;
1757
        if(ist->next_pts == AV_NOPTS_VALUE) 
1758
            ist->next_pts=0;
1759
        ist->is_start = 1;
1760
    }
1761

    
1762
    /* compute buffer size max (should use a complete heuristic) */
1763
    for(i=0;i<nb_input_files;i++) {
1764
        file_table[i].buffer_size_max = 2048;
1765
    }
1766

    
1767
    /* set meta data information from input file if required */
1768
    for (i=0;i<nb_meta_data_maps;i++) {
1769
        AVFormatContext *out_file;
1770
        AVFormatContext *in_file;
1771

    
1772
        int out_file_index = meta_data_maps[i].out_file;
1773
        int in_file_index = meta_data_maps[i].in_file;
1774
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1775
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1776
            ret = -EINVAL;
1777
            goto fail;
1778
        }
1779
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1780
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1781
            ret = -EINVAL;
1782
            goto fail;
1783
        }                
1784
                 
1785
        out_file = output_files[out_file_index];
1786
        in_file = input_files[in_file_index];
1787

    
1788
        strcpy(out_file->title, in_file->title);
1789
        strcpy(out_file->author, in_file->author);
1790
        strcpy(out_file->copyright, in_file->copyright);
1791
        strcpy(out_file->comment, in_file->comment);
1792
        strcpy(out_file->album, in_file->album);
1793
        out_file->year = in_file->year;
1794
        out_file->track = in_file->track;
1795
        strcpy(out_file->genre, in_file->genre);
1796
    }
1797
        
1798
    /* open files and write file headers */
1799
    for(i=0;i<nb_output_files;i++) {
1800
        os = output_files[i];
1801
        if (av_write_header(os) < 0) {
1802
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1803
            ret = -EINVAL;
1804
            goto fail;
1805
        }
1806
    }
1807

    
1808
#ifndef CONFIG_WIN32
1809
    if ( !using_stdin && verbose >= 0) {
1810
        fprintf(stderr, "Press [q] to stop encoding\n");
1811
        url_set_interrupt_cb(decode_interrupt_cb);
1812
    }
1813
#endif
1814
    term_init();
1815

    
1816
    stream_no_data = 0;
1817
    key = -1;
1818

    
1819
    for(; received_sigterm == 0;) {
1820
        int file_index, ist_index;
1821
        AVPacket pkt;
1822
        double ipts_min;
1823
        double opts_min;
1824

    
1825
    redo:
1826
        ipts_min= 1e100;
1827
        opts_min= 1e100;
1828
        /* if 'q' pressed, exits */
1829
        if (!using_stdin) {
1830
            if (q_pressed)
1831
                break;
1832
            /* read_key() returns 0 on EOF */
1833
            key = read_key();
1834
            if (key == 'q')
1835
                break;
1836
        }
1837

    
1838
        /* select the stream that we must read now by looking at the
1839
           smallest output pts */
1840
        file_index = -1;
1841
        for(i=0;i<nb_ostreams;i++) {
1842
            double ipts, opts;
1843
            ost = ost_table[i];
1844
            os = output_files[ost->file_index];
1845
            ist = ist_table[ost->source_index];
1846
            if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1847
                opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1848
            else
1849
                opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1850
            ipts = (double)ist->pts;
1851
            if (!file_table[ist->file_index].eof_reached){
1852
                if(ipts < ipts_min) {
1853
                    ipts_min = ipts;
1854
                    if(input_sync ) file_index = ist->file_index;
1855
                }
1856
                if(opts < opts_min) {
1857
                    opts_min = opts;
1858
                    if(!input_sync) file_index = ist->file_index;
1859
                }
1860
            }
1861
            if(ost->frame_number >= max_frames[ost->st->codec.codec_type]){
1862
                file_index= -1;
1863
                break;
1864
            }
1865
        }
1866
        /* if none, if is finished */
1867
        if (file_index < 0) {
1868
            break;
1869
        }
1870

    
1871
        /* finish if recording time exhausted */
1872
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1873
            break;
1874

    
1875
        /* read a frame from it and output it in the fifo */
1876
        is = input_files[file_index];
1877
        if (av_read_frame(is, &pkt) < 0) {
1878
            file_table[file_index].eof_reached = 1;
1879
            continue;
1880
        }
1881

    
1882
        if (!pkt.size) {
1883
            stream_no_data = is;
1884
        } else {
1885
            stream_no_data = 0;
1886
        }
1887
        if (do_pkt_dump) {
1888
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1889
        }
1890
        /* the following test is needed in case new streams appear
1891
           dynamically in stream : we ignore them */
1892
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1893
            goto discard_packet;
1894
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1895
        ist = ist_table[ist_index];
1896
        if (ist->discard)
1897
            goto discard_packet;
1898

    
1899
//        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);
1900
        if (pkt.dts != AV_NOPTS_VALUE) {
1901
            int64_t delta= pkt.dts - ist->next_pts;
1902
            if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1903
                input_files_ts_offset[ist->file_index]-= delta;
1904
                if (verbose > 2)
1905
                    fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1906
                for(i=0; i<file_table[file_index].nb_streams; i++){
1907
                    int index= file_table[file_index].ist_index + i;
1908
                    ist_table[index]->next_pts += delta;
1909
                    ist_table[index]->is_start=1;
1910
                }
1911
            }
1912
        }
1913

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

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

    
1921
            av_free_packet(&pkt);
1922
            goto redo;
1923
        }
1924
        
1925
    discard_packet:
1926
        av_free_packet(&pkt);
1927
        
1928
        /* dump report by using the output first video and audio streams */
1929
        print_report(output_files, ost_table, nb_ostreams, 0);
1930
    }
1931

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

    
1940
    term_exit();
1941

    
1942
    /* write the trailer if needed and close file */
1943
    for(i=0;i<nb_output_files;i++) {
1944
        os = output_files[i];
1945
        av_write_trailer(os);
1946
    }
1947

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

    
1951
    /* close each encoder */
1952
    for(i=0;i<nb_ostreams;i++) {
1953
        ost = ost_table[i];
1954
        if (ost->encoding_needed) {
1955
            av_freep(&ost->st->codec.stats_in);
1956
            avcodec_close(&ost->st->codec);
1957
        }
1958
    }
1959
    
1960
    /* close each decoder */
1961
    for(i=0;i<nb_istreams;i++) {
1962
        ist = ist_table[i];
1963
        if (ist->decoding_needed) {
1964
            avcodec_close(&ist->st->codec);
1965
        }
1966
    }
1967

    
1968
    /* finished ! */
1969
    
1970
    ret = 0;
1971
 fail1:
1972
    av_free(file_table);
1973

    
1974
    if (ist_table) {
1975
        for(i=0;i<nb_istreams;i++) {
1976
            ist = ist_table[i];
1977
            av_free(ist);
1978
        }
1979
        av_free(ist_table);
1980
    }
1981
    if (ost_table) {
1982
        for(i=0;i<nb_ostreams;i++) {
1983
            ost = ost_table[i];
1984
            if (ost) {
1985
                if (ost->logfile) {
1986
                    fclose(ost->logfile);
1987
                    ost->logfile = NULL;
1988
                }
1989
                fifo_free(&ost->fifo); /* works even if fifo is not
1990
                                          initialized but set to zero */
1991
                av_free(ost->pict_tmp.data[0]);
1992
                if (ost->video_resample)
1993
                    img_resample_close(ost->img_resample_ctx);
1994
                if (ost->audio_resample)
1995
                    audio_resample_close(ost->resample);
1996
                av_free(ost);
1997
            }
1998
        }
1999
        av_free(ost_table);
2000
    }
2001
    return ret;
2002
 fail:
2003
    ret = -ENOMEM;
2004
    goto fail1;
2005
}
2006

    
2007
#if 0
2008
int file_read(const char *filename)
2009
{
2010
    URLContext *h;
2011
    unsigned char buffer[1024];
2012
    int len, i;
2013

2014
    if (url_open(&h, filename, O_RDONLY) < 0) {
2015
        printf("could not open '%s'\n", filename);
2016
        return -1;
2017
    }
2018
    for(;;) {
2019
        len = url_read(h, buffer, sizeof(buffer));
2020
        if (len <= 0)
2021
            break;
2022
        for(i=0;i<len;i++) putchar(buffer[i]);
2023
    }
2024
    url_close(h);
2025
    return 0;
2026
}
2027
#endif
2028

    
2029
static void opt_image_format(const char *arg)
2030
{
2031
    AVImageFormat *f;
2032
    
2033
    for(f = first_image_format; f != NULL; f = f->next) {
2034
        if (!strcmp(arg, f->name))
2035
            break;
2036
    }
2037
    if (!f) {
2038
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2039
        exit(1);
2040
    }
2041
    image_format = f;
2042
}
2043

    
2044
static void opt_format(const char *arg)
2045
{
2046
    /* compatibility stuff for pgmyuv */
2047
    if (!strcmp(arg, "pgmyuv")) {
2048
        pgmyuv_compatibility_hack=1;
2049
//        opt_image_format(arg);
2050
        arg = "image2";
2051
    }
2052

    
2053
    file_iformat = av_find_input_format(arg);
2054
    file_oformat = guess_format(arg, NULL, NULL);
2055
    if (!file_iformat && !file_oformat) {
2056
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2057
        exit(1);
2058
    }
2059
}
2060

    
2061
static void opt_video_bitrate(const char *arg)
2062
{
2063
    video_bit_rate = atoi(arg) * 1000;
2064
}
2065

    
2066
static void opt_video_bitrate_tolerance(const char *arg)
2067
{
2068
    video_bit_rate_tolerance = atoi(arg) * 1000;
2069
}
2070

    
2071
static void opt_video_bitrate_max(const char *arg)
2072
{
2073
    video_rc_max_rate = atoi(arg) * 1000;
2074
}
2075

    
2076
static void opt_video_bitrate_min(const char *arg)
2077
{
2078
    video_rc_min_rate = atoi(arg) * 1000;
2079
}
2080

    
2081
static void opt_video_buffer_size(const char *arg)
2082
{
2083
    video_rc_buffer_size = atoi(arg) * 8*1024;
2084
}
2085

    
2086
static void opt_video_rc_eq(char *arg)
2087
{
2088
    video_rc_eq = arg;
2089
}
2090

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

    
2096

    
2097
static void opt_workaround_bugs(const char *arg)
2098
{
2099
    workaround_bugs = atoi(arg);
2100
}
2101

    
2102
static void opt_dct_algo(const char *arg)
2103
{
2104
    dct_algo = atoi(arg);
2105
}
2106

    
2107
static void opt_idct_algo(const char *arg)
2108
{
2109
    idct_algo = atoi(arg);
2110
}
2111

    
2112
static void opt_me_threshold(const char *arg)
2113
{
2114
    me_threshold = atoi(arg);
2115
}
2116

    
2117
static void opt_mb_threshold(const char *arg)
2118
{
2119
    mb_threshold = atoi(arg);
2120
}
2121

    
2122
static void opt_error_resilience(const char *arg)
2123
{
2124
    error_resilience = atoi(arg);
2125
}
2126

    
2127
static void opt_error_concealment(const char *arg)
2128
{
2129
    error_concealment = atoi(arg);
2130
}
2131

    
2132
static void opt_debug(const char *arg)
2133
{
2134
    debug = atoi(arg);
2135
}
2136

    
2137
static void opt_vismv(const char *arg)
2138
{
2139
    debug_mv = atoi(arg);
2140
}
2141
    
2142
static void opt_verbose(const char *arg)
2143
{
2144
    verbose = atoi(arg);
2145
    av_log_set_level(atoi(arg));
2146
}
2147

    
2148
static void opt_frame_rate(const char *arg)
2149
{
2150
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2151
        fprintf(stderr, "Incorrect frame rate\n");
2152
        exit(1);
2153
    }
2154
}
2155

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

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

    
2192
static void opt_frame_crop_left(const char *arg)
2193
{
2194
    frame_leftBand = atoi(arg);
2195
    if (frame_leftBand < 0) {
2196
        fprintf(stderr, "Incorrect left crop size\n");
2197
        exit(1);
2198
    }
2199
    if ((frame_leftBand % 2) != 0) {
2200
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2201
        exit(1);
2202
    }
2203
    if ((frame_leftBand) >= frame_width){
2204
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2205
        exit(1);
2206
    }
2207
    frame_width -= frame_leftBand;
2208
}
2209

    
2210
static void opt_frame_crop_right(const char *arg)
2211
{
2212
    frame_rightBand = atoi(arg);
2213
    if (frame_rightBand < 0) {
2214
        fprintf(stderr, "Incorrect right crop size\n");
2215
        exit(1);
2216
    }
2217
    if ((frame_rightBand % 2) != 0) {
2218
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2219
        exit(1);        
2220
    }
2221
    if ((frame_rightBand) >= frame_width){
2222
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2223
        exit(1);
2224
    }
2225
    frame_width -= frame_rightBand;
2226
}
2227

    
2228
static void opt_frame_size(const char *arg)
2229
{
2230
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2231
        fprintf(stderr, "Incorrect frame size\n");
2232
        exit(1);
2233
    }
2234
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2235
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2236
        exit(1);
2237
    }
2238
}
2239

    
2240

    
2241
#define SCALEBITS 10
2242
#define ONE_HALF  (1 << (SCALEBITS - 1))
2243
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
2244

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

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

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

    
2257
static void opt_pad_color(const char *arg) {
2258
    /* Input is expected to be six hex digits similar to
2259
       how colors are expressed in html tags (but without the #) */
2260
    int rgb = strtol(arg, NULL, 16);
2261
    int r,g,b;
2262
    
2263
    r = (rgb >> 16); 
2264
    g = ((rgb >> 8) & 255);
2265
    b = (rgb & 255);
2266

    
2267
    padcolor[0] = RGB_TO_Y(r,g,b);
2268
    padcolor[1] = RGB_TO_U(r,g,b,0);
2269
    padcolor[2] = RGB_TO_V(r,g,b,0);
2270
}
2271

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

    
2285
static void opt_frame_pad_bottom(const char *arg)
2286
{
2287
    frame_padbottom = atoi(arg); 
2288
    if (frame_padbottom < 0) {
2289
        fprintf(stderr, "Incorrect bottom pad size\n");
2290
        exit(1);
2291
    }
2292
    if ((frame_padbottom % 2) != 0) {
2293
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2294
        exit(1);
2295
    }
2296
}
2297

    
2298

    
2299
static void opt_frame_pad_left(const char *arg)
2300
{
2301
    frame_padleft = atoi(arg); 
2302
    if (frame_padleft < 0) {
2303
        fprintf(stderr, "Incorrect left pad size\n");
2304
        exit(1);
2305
    }
2306
    if ((frame_padleft % 2) != 0) {
2307
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2308
        exit(1);
2309
    }
2310
}
2311

    
2312

    
2313
static void opt_frame_pad_right(const char *arg)
2314
{
2315
    frame_padright = atoi(arg); 
2316
    if (frame_padright < 0) {
2317
        fprintf(stderr, "Incorrect right pad size\n");
2318
        exit(1);
2319
    }
2320
    if ((frame_padright % 2) != 0) {
2321
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2322
        exit(1);
2323
    }
2324
}
2325

    
2326

    
2327
static void opt_frame_pix_fmt(const char *arg)
2328
{
2329
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2330
}
2331

    
2332
static void opt_frame_aspect_ratio(const char *arg)
2333
{
2334
    int x = 0, y = 0;
2335
    double ar = 0;
2336
    const char *p;
2337
    
2338
    p = strchr(arg, ':');
2339
    if (p) {
2340
        x = strtol(arg, (char **)&arg, 10);
2341
        if (arg == p)
2342
            y = strtol(arg+1, (char **)&arg, 10);
2343
        if (x > 0 && y > 0)
2344
            ar = (double)x / (double)y;
2345
    } else
2346
        ar = strtod(arg, (char **)&arg);
2347

    
2348
    if (!ar) {
2349
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2350
        exit(1);
2351
    }
2352
    frame_aspect_ratio = ar;
2353
}
2354

    
2355
static void opt_gop_size(const char *arg)
2356
{
2357
    gop_size = atoi(arg);
2358
}
2359

    
2360
static void opt_b_frames(const char *arg)
2361
{
2362
    b_frames = atoi(arg);
2363
    if (b_frames > FF_MAX_B_FRAMES) {
2364
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2365
        exit(1);
2366
    } else if (b_frames < 1) {
2367
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2368
        exit(1);
2369
    }
2370
}
2371

    
2372
static void opt_mb_decision(const char *arg)
2373
{
2374
    mb_decision = atoi(arg);
2375
}
2376

    
2377
static void opt_mb_cmp(const char *arg)
2378
{
2379
    mb_cmp = atoi(arg);
2380
}
2381

    
2382
static void opt_ildct_cmp(const char *arg)
2383
{
2384
    ildct_cmp = atoi(arg);
2385
}
2386

    
2387
static void opt_sub_cmp(const char *arg)
2388
{
2389
    sub_cmp = atoi(arg);
2390
}
2391

    
2392
static void opt_cmp(const char *arg)
2393
{
2394
    cmp = atoi(arg);
2395
}
2396

    
2397
static void opt_pre_cmp(const char *arg)
2398
{
2399
    pre_cmp = atoi(arg);
2400
}
2401

    
2402
static void opt_pre_me(const char *arg)
2403
{
2404
    pre_me = atoi(arg);
2405
}
2406

    
2407
static void opt_lumi_mask(const char *arg)
2408
{
2409
    lumi_mask = atof(arg);
2410
}
2411

    
2412
static void opt_dark_mask(const char *arg)
2413
{
2414
    dark_mask = atof(arg);
2415
}
2416

    
2417
static void opt_scplx_mask(const char *arg)
2418
{
2419
    scplx_mask = atof(arg);
2420
}
2421

    
2422
static void opt_tcplx_mask(const char *arg)
2423
{
2424
    tcplx_mask = atof(arg);
2425
}
2426

    
2427
static void opt_p_mask(const char *arg)
2428
{
2429
    p_mask = atof(arg);
2430
}
2431

    
2432
static void opt_qscale(const char *arg)
2433
{
2434
    video_qscale = atof(arg);
2435
    if (video_qscale < 0.01 ||
2436
        video_qscale > 255) {
2437
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2438
        exit(1);
2439
    }
2440
}
2441

    
2442
static void opt_lmax(const char *arg)
2443
{
2444
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2445
}
2446

    
2447
static void opt_lmin(const char *arg)
2448
{
2449
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2450
}
2451

    
2452
static void opt_qmin(const char *arg)
2453
{
2454
    video_qmin = atoi(arg);
2455
    if (video_qmin < 0 ||
2456
        video_qmin > 31) {
2457
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2458
        exit(1);
2459
    }
2460
}
2461

    
2462
static void opt_qmax(const char *arg)
2463
{
2464
    video_qmax = atoi(arg);
2465
    if (video_qmax < 0 ||
2466
        video_qmax > 31) {
2467
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2468
        exit(1);
2469
    }
2470
}
2471

    
2472
static void opt_mb_qmin(const char *arg)
2473
{
2474
    video_mb_qmin = atoi(arg);
2475
    if (video_mb_qmin < 0 ||
2476
        video_mb_qmin > 31) {
2477
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2478
        exit(1);
2479
    }
2480
}
2481

    
2482
static void opt_mb_qmax(const char *arg)
2483
{
2484
    video_mb_qmax = atoi(arg);
2485
    if (video_mb_qmax < 0 ||
2486
        video_mb_qmax > 31) {
2487
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2488
        exit(1);
2489
    }
2490
}
2491

    
2492
static void opt_qdiff(const char *arg)
2493
{
2494
    video_qdiff = atoi(arg);
2495
    if (video_qdiff < 0 ||
2496
        video_qdiff > 31) {
2497
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2498
        exit(1);
2499
    }
2500
}
2501

    
2502
static void opt_qblur(const char *arg)
2503
{
2504
    video_qblur = atof(arg);
2505
}
2506

    
2507
static void opt_qcomp(const char *arg)
2508
{
2509
    video_qcomp = atof(arg);
2510
}
2511

    
2512
static void opt_rc_initial_cplx(const char *arg)
2513
{
2514
    video_rc_initial_cplx = atof(arg);
2515
}
2516
static void opt_b_qfactor(const char *arg)
2517
{
2518
    video_b_qfactor = atof(arg);
2519
}
2520
static void opt_i_qfactor(const char *arg)
2521
{
2522
    video_i_qfactor = atof(arg);
2523
}
2524
static void opt_b_qoffset(const char *arg)
2525
{
2526
    video_b_qoffset = atof(arg);
2527
}
2528
static void opt_i_qoffset(const char *arg)
2529
{
2530
    video_i_qoffset = atof(arg);
2531
}
2532

    
2533
static void opt_ibias(const char *arg)
2534
{
2535
    video_intra_quant_bias = atoi(arg);
2536
}
2537
static void opt_pbias(const char *arg)
2538
{
2539
    video_inter_quant_bias = atoi(arg);
2540
}
2541

    
2542
static void opt_packet_size(const char *arg)
2543
{
2544
    packet_size= atoi(arg);
2545
}
2546

    
2547
static void opt_error_rate(const char *arg)
2548
{
2549
    error_rate= atoi(arg);
2550
}
2551

    
2552
static void opt_strict(const char *arg)
2553
{
2554
    strict= atoi(arg);
2555
}
2556

    
2557
static void opt_top_field_first(const char *arg)
2558
{
2559
    top_field_first= atoi(arg);
2560
}
2561

    
2562
static void opt_noise_reduction(const char *arg)
2563
{
2564
    noise_reduction= atoi(arg);
2565
}
2566

    
2567
static void opt_qns(const char *arg)
2568
{
2569
    qns= atoi(arg);
2570
}
2571

    
2572
static void opt_sc_threshold(const char *arg)
2573
{
2574
    sc_threshold= atoi(arg);
2575
}
2576

    
2577
static void opt_me_range(const char *arg)
2578
{
2579
    me_range = atoi(arg);
2580
}
2581

    
2582
static void opt_thread_count(const char *arg)
2583
{
2584
    thread_count= atoi(arg);
2585
#if !defined(HAVE_THREADS)
2586
    if (verbose >= 0)
2587
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2588
#endif
2589
}
2590

    
2591
static void opt_audio_bitrate(const char *arg)
2592
{
2593
    audio_bit_rate = atoi(arg) * 1000;
2594
}
2595

    
2596
static void opt_audio_rate(const char *arg)
2597
{
2598
    audio_sample_rate = atoi(arg);
2599
}
2600

    
2601
static void opt_audio_channels(const char *arg)
2602
{
2603
    audio_channels = atoi(arg);
2604
}
2605

    
2606
static void opt_video_device(const char *arg)
2607
{
2608
    video_device = av_strdup(arg);
2609
}
2610

    
2611
static void opt_grab_device(const char *arg)
2612
{
2613
    grab_device = av_strdup(arg);
2614
}
2615

    
2616
static void opt_video_channel(const char *arg)
2617
{
2618
    video_channel = strtol(arg, NULL, 0);
2619
}
2620

    
2621
static void opt_video_standard(const char *arg)
2622
{
2623
    video_standard = av_strdup(arg);
2624
}
2625

    
2626
static void opt_audio_device(const char *arg)
2627
{
2628
    audio_device = av_strdup(arg);
2629
}
2630

    
2631
static void opt_audio_codec(const char *arg)
2632
{
2633
    AVCodec *p;
2634

    
2635
    if (!strcmp(arg, "copy")) {
2636
        audio_stream_copy = 1;
2637
    } else {
2638
        p = first_avcodec;
2639
        while (p) {
2640
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2641
                break;
2642
            p = p->next;
2643
        }
2644
        if (p == NULL) {
2645
            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2646
            exit(1);
2647
        } else {
2648
            audio_codec_id = p->id;
2649
        }
2650
    }
2651
}
2652

    
2653
static void opt_audio_tag(const char *arg)
2654
{
2655
    char *tail;
2656
    audio_codec_tag= strtol(arg, &tail, 0);
2657

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

    
2662
static void opt_video_tag(const char *arg)
2663
{
2664
    char *tail;
2665
    video_codec_tag= strtol(arg, &tail, 0);
2666

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

    
2671
static void add_frame_hooker(const char *arg)
2672
{
2673
    int argc = 0;
2674
    char *argv[64];
2675
    int i;
2676
    char *args = av_strdup(arg);
2677

    
2678
    using_vhook = 1;
2679

    
2680
    argv[0] = strtok(args, " ");
2681
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2682
    }
2683

    
2684
    i = frame_hook_add(argc, argv);
2685

    
2686
    if (i != 0) {
2687
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2688
        exit(1);
2689
    }
2690
}
2691

    
2692
const char *motion_str[] = {
2693
    "zero",
2694
    "full",
2695
    "log",
2696
    "phods",
2697
    "epzs",
2698
    "x1",
2699
    NULL,
2700
};
2701

    
2702
static void opt_motion_estimation(const char *arg)
2703
{
2704
    const char **p;
2705
    p = motion_str;
2706
    for(;;) {
2707
        if (!*p) {
2708
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2709
            exit(1);
2710
        }
2711
        if (!strcmp(*p, arg))
2712
            break;
2713
        p++;
2714
    }
2715
    me_method = (p - motion_str) + 1;
2716
}
2717

    
2718
static void opt_video_codec(const char *arg)
2719
{
2720
    AVCodec *p;
2721

    
2722
    if (!strcmp(arg, "copy")) {
2723
        video_stream_copy = 1;
2724
    } else {
2725
        p = first_avcodec;
2726
        while (p) {
2727
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2728
                break;
2729
            p = p->next;
2730
        }
2731
        if (p == NULL) {
2732
            fprintf(stderr, "Unknown video codec '%s'\n", arg);
2733
            exit(1);
2734
        } else {
2735
            video_codec_id = p->id;
2736
        }
2737
    }
2738
}
2739

    
2740
static void opt_map(const char *arg)
2741
{
2742
    AVStreamMap *m;
2743
    const char *p;
2744

    
2745
    p = arg;
2746
    m = &stream_maps[nb_stream_maps++];
2747

    
2748
    m->file_index = strtol(arg, (char **)&p, 0);
2749
    if (*p)
2750
        p++;
2751

    
2752
    m->stream_index = strtol(p, (char **)&p, 0);
2753
}
2754

    
2755
static void opt_map_meta_data(const char *arg)
2756
{
2757
    AVMetaDataMap *m;
2758
    const char *p;
2759
        
2760
    p = arg;
2761
    m = &meta_data_maps[nb_meta_data_maps++];
2762

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

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

    
2770
static void opt_recording_time(const char *arg)
2771
{
2772
    recording_time = parse_date(arg, 1);
2773
}
2774

    
2775
static void opt_start_time(const char *arg)
2776
{
2777
    start_time = parse_date(arg, 1);
2778
}
2779

    
2780
static void opt_rec_timestamp(const char *arg)
2781
{
2782
    rec_timestamp = parse_date(arg, 0) / 1000000;
2783
}
2784

    
2785
static void opt_input_ts_offset(const char *arg)
2786
{
2787
    input_ts_offset = parse_date(arg, 1);
2788
}
2789

    
2790
static void opt_input_file(const char *filename)
2791
{
2792
    AVFormatContext *ic;
2793
    AVFormatParameters params, *ap = &params;
2794
    int err, i, ret, rfps, rfps_base;
2795
    int64_t timestamp;
2796

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

    
2800
    using_stdin |= !strncmp(filename, "pipe:", 5) || 
2801
                   !strcmp( filename, "/dev/stdin" );
2802

    
2803
    /* get default parameters from command line */
2804
    memset(ap, 0, sizeof(*ap));
2805
    ap->sample_rate = audio_sample_rate;
2806
    ap->channels = audio_channels;
2807
    ap->frame_rate = frame_rate;
2808
    ap->frame_rate_base = frame_rate_base;
2809
    ap->width = frame_width + frame_padleft + frame_padright;
2810
    ap->height = frame_height + frame_padtop + frame_padbottom;
2811
    ap->image_format = image_format;
2812
    ap->pix_fmt = frame_pix_fmt;
2813
    ap->device  = grab_device;
2814
    ap->channel = video_channel;
2815
    ap->standard = video_standard;
2816
    ap->video_codec_id = video_codec_id;
2817
    ap->audio_codec_id = audio_codec_id;
2818
    if(pgmyuv_compatibility_hack)
2819
        ap->video_codec_id= CODEC_ID_PGMYUV;
2820

    
2821
    /* open the input file with generic libav function */
2822
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2823
    if (err < 0) {
2824
        print_error(filename, err);
2825
        exit(1);
2826
    }
2827
    
2828
    /* If not enough info to get the stream parameters, we decode the
2829
       first frames to get it. (used in mpeg case for example) */
2830
    ret = av_find_stream_info(ic);
2831
    if (ret < 0 && verbose >= 0) {
2832
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2833
        exit(1);
2834
    }
2835

    
2836
    timestamp = start_time;
2837
    /* add the stream start time */
2838
    if (ic->start_time != AV_NOPTS_VALUE)
2839
        timestamp += ic->start_time;
2840

    
2841
    /* if seeking requested, we execute it */
2842
    if (start_time != 0) {
2843
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2844
        if (ret < 0) {
2845
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
2846
                    filename, (double)timestamp / AV_TIME_BASE);
2847
        }
2848
        /* reset seek info */
2849
        start_time = 0;
2850
    }
2851

    
2852
    /* update the current parameters so that they match the one of the input stream */
2853
    for(i=0;i<ic->nb_streams;i++) {
2854
        AVCodecContext *enc = &ic->streams[i]->codec;
2855
#if defined(HAVE_THREADS)
2856
        if(thread_count>1)
2857
            avcodec_thread_init(enc, thread_count);
2858
#endif
2859
        enc->thread_count= thread_count;
2860
        switch(enc->codec_type) {
2861
        case CODEC_TYPE_AUDIO:
2862
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2863
            audio_channels = enc->channels;
2864
            audio_sample_rate = enc->sample_rate;
2865
            break;
2866
        case CODEC_TYPE_VIDEO:
2867
            frame_height = enc->height;
2868
            frame_width = enc->width;
2869
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2870
            frame_pix_fmt = enc->pix_fmt;
2871
            rfps      = ic->streams[i]->r_frame_rate;
2872
            rfps_base = ic->streams[i]->r_frame_rate_base;
2873
            enc->workaround_bugs = workaround_bugs;
2874
            enc->error_resilience = error_resilience; 
2875
            enc->error_concealment = error_concealment; 
2876
            enc->idct_algo = idct_algo;
2877
            enc->debug = debug;
2878
            enc->debug_mv = debug_mv;            
2879
            enc->lowres= lowres;
2880
            if(bitexact)
2881
                enc->flags|= CODEC_FLAG_BITEXACT;
2882
            if(me_threshold)
2883
                enc->debug |= FF_DEBUG_MV;
2884

    
2885
            if (enc->frame_rate != rfps || enc->frame_rate_base != rfps_base) { 
2886

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

    
2891
                    (float)rfps / rfps_base, rfps, rfps_base);
2892
            }
2893
            /* update the current frame rate to match the stream frame rate */
2894
            frame_rate      = rfps;
2895
            frame_rate_base = rfps_base;
2896

    
2897
            enc->rate_emu = rate_emu;
2898
            break;
2899
        case CODEC_TYPE_DATA:
2900
            break;
2901
        default:
2902
            av_abort();
2903
        }
2904
    }
2905
    
2906
    input_files[nb_input_files] = ic;
2907
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2908
    /* dump the file content */
2909
    if (verbose >= 0)
2910
        dump_format(ic, nb_input_files, filename, 0);
2911

    
2912
    nb_input_files++;
2913
    file_iformat = NULL;
2914
    file_oformat = NULL;
2915
    image_format = NULL;
2916

    
2917
    grab_device = NULL;
2918
    video_channel = 0;
2919
    
2920
    rate_emu = 0;
2921
}
2922

    
2923
static void opt_grab(const char *arg)
2924
{
2925
    file_iformat = av_find_input_format(arg);
2926
    opt_input_file("");
2927
}
2928

    
2929
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2930
{
2931
    int has_video, has_audio, i, j;
2932
    AVFormatContext *ic;
2933

    
2934
    has_video = 0;
2935
    has_audio = 0;
2936
    for(j=0;j<nb_input_files;j++) {
2937
        ic = input_files[j];
2938
        for(i=0;i<ic->nb_streams;i++) {
2939
            AVCodecContext *enc = &ic->streams[i]->codec;
2940
            switch(enc->codec_type) {
2941
            case CODEC_TYPE_AUDIO:
2942
                has_audio = 1;
2943
                break;
2944
            case CODEC_TYPE_VIDEO:
2945
                has_video = 1;
2946
                break;
2947
            case CODEC_TYPE_DATA:
2948
                break;
2949
            default:
2950
                av_abort();
2951
            }
2952
        }
2953
    }
2954
    *has_video_ptr = has_video;
2955
    *has_audio_ptr = has_audio;
2956
}
2957

    
2958
static void opt_output_file(const char *filename)
2959
{
2960
    AVStream *st;
2961
    AVFormatContext *oc;
2962
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2963
    int codec_id;
2964
    AVFormatParameters params, *ap = &params;
2965

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

    
2969
    oc = av_alloc_format_context();
2970

    
2971
    if (!file_oformat) {
2972
        file_oformat = guess_format(NULL, filename, NULL);
2973
        if (!file_oformat) {
2974
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2975
                    filename);
2976
            exit(1);
2977
        }
2978
    }
2979
    
2980
    oc->oformat = file_oformat;
2981

    
2982
    if (!strcmp(file_oformat->name, "ffm") && 
2983
        strstart(filename, "http:", NULL)) {
2984
        /* special case for files sent to ffserver: we get the stream
2985
           parameters from ffserver */
2986
        if (read_ffserver_streams(oc, filename) < 0) {
2987
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2988
            exit(1);
2989
        }
2990
    } else {
2991
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2992
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2993

    
2994
        /* disable if no corresponding type found and at least one
2995
           input file */
2996
        if (nb_input_files > 0) {
2997
            check_audio_video_inputs(&input_has_video, &input_has_audio);
2998
            if (!input_has_video)
2999
                use_video = 0;
3000
            if (!input_has_audio)
3001
                use_audio = 0;
3002
        }
3003

    
3004
        /* manual disable */
3005
        if (audio_disable) {
3006
            use_audio = 0;
3007
        }
3008
        if (video_disable) {
3009
            use_video = 0;
3010
        }
3011
        
3012
        nb_streams = 0;
3013
        if (use_video) {
3014
            AVCodecContext *video_enc;
3015
            
3016
            st = av_new_stream(oc, nb_streams++);
3017
            if (!st) {
3018
                fprintf(stderr, "Could not alloc stream\n");
3019
                exit(1);
3020
            }
3021
#if defined(HAVE_THREADS)
3022
            if(thread_count>1)
3023
                avcodec_thread_init(&st->codec, thread_count);
3024
#endif
3025

    
3026
            video_enc = &st->codec;
3027
            
3028
            if(video_codec_tag)
3029
                video_enc->codec_tag= video_codec_tag;
3030
                
3031
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3032
                video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3033
            if (video_stream_copy) {
3034
                st->stream_copy = 1;
3035
                video_enc->codec_type = CODEC_TYPE_VIDEO;
3036
            } else {
3037
                char *p;
3038
                int i;
3039
                AVCodec *codec;
3040
            
3041
                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
3042
                if (video_codec_id != CODEC_ID_NONE)
3043
                    codec_id = video_codec_id;
3044
                
3045
                video_enc->codec_id = codec_id;
3046
                codec = avcodec_find_encoder(codec_id);
3047
                
3048
                video_enc->bit_rate = video_bit_rate;
3049
                video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3050
                video_enc->frame_rate = frame_rate; 
3051
                video_enc->frame_rate_base = frame_rate_base; 
3052
                if(codec && codec->supported_framerates){
3053
                    const AVRational *p= codec->supported_framerates;
3054
                    AVRational req= (AVRational){frame_rate, frame_rate_base};
3055
                    const AVRational *best=NULL;
3056
                    AVRational best_error= (AVRational){INT_MAX, 1};
3057
                    for(; p->den!=0; p++){
3058
                        AVRational error= av_sub_q(req, *p);
3059
                        if(error.num <0) error.num *= -1;
3060
                        if(av_cmp_q(error, best_error) < 0){
3061
                            best_error= error;
3062
                            best= p;
3063
                        }
3064
                    }
3065
                    video_enc->frame_rate     = best->num;
3066
                    video_enc->frame_rate_base= best->den;
3067
                }
3068
                
3069
                video_enc->width = frame_width + frame_padright + frame_padleft;
3070
                video_enc->height = frame_height + frame_padtop + frame_padbottom;
3071
                video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3072
                video_enc->pix_fmt = frame_pix_fmt;
3073

    
3074
                if(codec && codec->pix_fmts){
3075
                    const enum PixelFormat *p= codec->pix_fmts;
3076
                    for(; *p!=-1; p++){
3077
                        if(*p == video_enc->pix_fmt)
3078
                            break;
3079
                    }
3080
                    if(*p == -1)
3081
                        video_enc->pix_fmt = codec->pix_fmts[0];
3082
                }
3083

    
3084
                if (!intra_only)
3085
                    video_enc->gop_size = gop_size;
3086
                else
3087
                    video_enc->gop_size = 0;
3088
                if (video_qscale || same_quality) {
3089
                    video_enc->flags |= CODEC_FLAG_QSCALE;
3090
                    st->quality = FF_QP2LAMBDA * video_qscale;
3091
                }
3092

    
3093
                if(intra_matrix)
3094
                    video_enc->intra_matrix = intra_matrix;
3095
                if(inter_matrix)
3096
                    video_enc->inter_matrix = inter_matrix;
3097

    
3098
                if(bitexact)
3099
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
3100

    
3101
                video_enc->mb_decision = mb_decision;
3102
                video_enc->mb_cmp = mb_cmp;
3103
                video_enc->ildct_cmp = ildct_cmp;
3104
                video_enc->me_sub_cmp = sub_cmp;
3105
                video_enc->me_cmp = cmp;
3106
                video_enc->me_pre_cmp = pre_cmp;
3107
                video_enc->pre_me = pre_me;
3108
                video_enc->lumi_masking = lumi_mask;
3109
                video_enc->dark_masking = dark_mask;
3110
                video_enc->spatial_cplx_masking = scplx_mask;
3111
                video_enc->temporal_cplx_masking = tcplx_mask;
3112
                video_enc->p_masking = p_mask;
3113
                video_enc->quantizer_noise_shaping= qns;
3114
                
3115
                if (use_umv) {
3116
                    video_enc->flags |= CODEC_FLAG_H263P_UMV;
3117
                }
3118
                if (use_ss) {
3119
                    video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3120
                }
3121
                   if (use_aic) {
3122
                    video_enc->flags |= CODEC_FLAG_H263P_AIC;
3123
                }
3124
                   if (use_aiv) {
3125
                    video_enc->flags |= CODEC_FLAG_H263P_AIV;
3126
                }
3127
                if (use_4mv) {
3128
                    video_enc->flags |= CODEC_FLAG_4MV;
3129
                }
3130
                if (use_obmc) {
3131
                    video_enc->flags |= CODEC_FLAG_OBMC;
3132
                }
3133
                if (use_loop) {
3134
                    video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3135
                }
3136
            
3137
                if(use_part) {
3138
                    video_enc->flags |= CODEC_FLAG_PART;
3139
                }
3140
                   if (use_alt_scan) {
3141
                    video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3142
                }
3143
                   if (use_trell) {
3144
                    video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3145
                }
3146
                   if (use_scan_offset) {
3147
                    video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3148
                }
3149
                   if (closed_gop) {
3150
                    video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3151
                }
3152
                if (strict_gop) {
3153
                    video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3154
                }
3155
                   if (use_qpel) {
3156
                    video_enc->flags |= CODEC_FLAG_QPEL;
3157
                }
3158
                   if (use_qprd) {
3159
                    video_enc->flags |= CODEC_FLAG_QP_RD;
3160
                }
3161
                   if (use_cbprd) {
3162
                    video_enc->flags |= CODEC_FLAG_CBP_RD;
3163
                }
3164
                if (b_frames) {
3165
                    video_enc->max_b_frames = b_frames;
3166
                    video_enc->b_frame_strategy = 0;
3167
                    video_enc->b_quant_factor = 2.0;
3168
                }
3169
                if (do_interlace_dct) {
3170
                    video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3171
                }
3172
                if (do_interlace_me) {
3173
                    video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3174
                }
3175
                video_enc->qmin = video_qmin;
3176
                video_enc->qmax = video_qmax;
3177
                video_enc->lmin = video_lmin;
3178
                video_enc->lmax = video_lmax;
3179
                video_enc->mb_qmin = video_mb_qmin;
3180
                video_enc->mb_qmax = video_mb_qmax;
3181
                video_enc->max_qdiff = video_qdiff;
3182
                video_enc->qblur = video_qblur;
3183
                video_enc->qcompress = video_qcomp;
3184
                video_enc->rc_eq = video_rc_eq;
3185
                video_enc->debug = debug;
3186
                video_enc->debug_mv = debug_mv;
3187
                video_enc->thread_count = thread_count;
3188
                p= video_rc_override_string;
3189
                for(i=0; p; i++){
3190
                    int start, end, q;
3191
                    int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3192
                    if(e!=3){
3193
                        fprintf(stderr, "error parsing rc_override\n");
3194
                        exit(1);
3195
                    }
3196
                    video_enc->rc_override= 
3197
                        av_realloc(video_enc->rc_override, 
3198
                                   sizeof(RcOverride)*(i+1));
3199
                    video_enc->rc_override[i].start_frame= start;
3200
                    video_enc->rc_override[i].end_frame  = end;
3201
                    if(q>0){
3202
                        video_enc->rc_override[i].qscale= q;
3203
                        video_enc->rc_override[i].quality_factor= 1.0;
3204
                    }
3205
                    else{
3206
                        video_enc->rc_override[i].qscale= 0;
3207
                        video_enc->rc_override[i].quality_factor= -q/100.0;
3208
                    }
3209
                    p= strchr(p, '/');
3210
                    if(p) p++;
3211
                }
3212
                video_enc->rc_override_count=i;
3213

    
3214
                video_enc->rc_max_rate = video_rc_max_rate;
3215
                video_enc->rc_min_rate = video_rc_min_rate;
3216
                video_enc->rc_buffer_size = video_rc_buffer_size;
3217
                video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3218
                video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3219
                video_enc->rc_initial_cplx= video_rc_initial_cplx;
3220
                video_enc->i_quant_factor = video_i_qfactor;
3221
                video_enc->b_quant_factor = video_b_qfactor;
3222
                video_enc->i_quant_offset = video_i_qoffset;
3223
                video_enc->b_quant_offset = video_b_qoffset;
3224
                video_enc->intra_quant_bias = video_intra_quant_bias;
3225
                video_enc->inter_quant_bias = video_inter_quant_bias;
3226
                video_enc->dct_algo = dct_algo;
3227
                video_enc->idct_algo = idct_algo;
3228
                video_enc->me_threshold= me_threshold;
3229
                video_enc->mb_threshold= mb_threshold;
3230
                video_enc->intra_dc_precision= intra_dc_precision - 8;
3231
                video_enc->strict_std_compliance = strict;
3232
                video_enc->error_rate = error_rate;
3233
                video_enc->noise_reduction= noise_reduction;
3234
                video_enc->scenechange_threshold= sc_threshold;
3235
                video_enc->me_range = me_range;
3236
                video_enc->coder_type= coder;
3237
                video_enc->context_model= context;
3238
                video_enc->prediction_method= predictor;
3239
                video_enc->profile= video_profile;
3240
                video_enc->level= video_level;
3241
                video_enc->nsse_weight= nsse_weight;
3242
                video_enc->me_subpel_quality= subpel_quality;
3243
                video_enc->frame_skip_threshold= frame_skip_threshold;
3244
                video_enc->frame_skip_factor= frame_skip_factor;
3245
                video_enc->frame_skip_exp= frame_skip_exp;
3246
                video_enc->frame_skip_cmp= frame_skip_cmp;
3247

    
3248
                if(packet_size){
3249
                    video_enc->rtp_mode= 1;
3250
                    video_enc->rtp_payload_size= packet_size;
3251
                }
3252
            
3253
                if (do_psnr)
3254
                    video_enc->flags|= CODEC_FLAG_PSNR;
3255
            
3256
                video_enc->me_method = me_method;
3257

    
3258
                /* two pass mode */
3259
                if (do_pass) {
3260
                    if (do_pass == 1) {
3261
                        video_enc->flags |= CODEC_FLAG_PASS1;
3262
                    } else {
3263
                        video_enc->flags |= CODEC_FLAG_PASS2;
3264
                    }
3265
                }
3266
            }
3267
        }
3268
    
3269
        if (use_audio) {
3270
            AVCodecContext *audio_enc;
3271

    
3272
            st = av_new_stream(oc, nb_streams++);
3273
            if (!st) {
3274
                fprintf(stderr, "Could not alloc stream\n");
3275
                exit(1);
3276
            }
3277
#if defined(HAVE_THREADS)
3278
            if(thread_count>1)
3279
                avcodec_thread_init(&st->codec, thread_count);
3280
#endif
3281

    
3282
            audio_enc = &st->codec;
3283
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3284

    
3285
            if(audio_codec_tag)
3286
                audio_enc->codec_tag= audio_codec_tag;
3287

    
3288
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3289
                audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3290
            if (audio_stream_copy) {
3291
                st->stream_copy = 1;
3292
                audio_enc->channels = audio_channels;
3293
            } else {
3294
                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
3295
                if (audio_codec_id != CODEC_ID_NONE)
3296
                    codec_id = audio_codec_id;
3297
                audio_enc->codec_id = codec_id;
3298
                
3299
                audio_enc->bit_rate = audio_bit_rate;
3300
                audio_enc->strict_std_compliance = strict;
3301
                audio_enc->thread_count = thread_count;
3302
                /* For audio codecs other than AC3 or DTS we limit */
3303
                /* the number of coded channels to stereo   */
3304
                if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3305
                    && codec_id != CODEC_ID_DTS) {
3306
                    audio_enc->channels = 2;
3307
                } else
3308
                    audio_enc->channels = audio_channels;
3309
            }
3310
            audio_enc->sample_rate = audio_sample_rate;
3311
        }
3312

    
3313
        oc->nb_streams = nb_streams;
3314

    
3315
        if (!nb_streams) {
3316
            fprintf(stderr, "No audio or video streams available\n");
3317
            exit(1);
3318
        }
3319

    
3320
        oc->timestamp = rec_timestamp;
3321
            
3322
        if (str_title)
3323
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3324
        if (str_author)
3325
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3326
        if (str_copyright)
3327
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3328
        if (str_comment)
3329
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3330
    }
3331

    
3332
    output_files[nb_output_files++] = oc;
3333

    
3334
    strcpy(oc->filename, filename);
3335

    
3336
    /* check filename in case of an image number is expected */
3337
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3338
        if (filename_number_test(oc->filename) < 0) {
3339
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3340
            exit(1);
3341
        }
3342
    }
3343

    
3344
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3345
        /* test if it already exists to avoid loosing precious files */
3346
        if (!file_overwrite && 
3347
            (strchr(filename, ':') == NULL ||
3348
             strstart(filename, "file:", NULL))) {
3349
            if (url_exist(filename)) {
3350
                int c;
3351
                
3352
                if ( !using_stdin ) {
3353
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3354
                    fflush(stderr);
3355
                    c = getchar();
3356
                    if (toupper(c) != 'Y') {
3357
                        fprintf(stderr, "Not overwriting - exiting\n");
3358
                        exit(1);
3359
                    }
3360
                                }
3361
                                else {
3362
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3363
                    exit(1);
3364
                                }
3365
            }
3366
        }
3367
        
3368
        /* open the file */
3369
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3370
            fprintf(stderr, "Could not open '%s'\n", filename);
3371
            exit(1);
3372
        }
3373
    }
3374

    
3375
    memset(ap, 0, sizeof(*ap));
3376
    ap->image_format = image_format;
3377
    if (av_set_parameters(oc, ap) < 0) {
3378
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3379
                oc->filename);
3380
        exit(1);
3381
    }
3382

    
3383
    oc->packet_size= mux_packet_size;
3384
    oc->mux_rate= mux_rate;
3385
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3386
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3387

    
3388
    /* reset some options */
3389
    file_oformat = NULL;
3390
    file_iformat = NULL;
3391
    image_format = NULL;
3392
    audio_disable = 0;
3393
    video_disable = 0;
3394
    audio_codec_id = CODEC_ID_NONE;
3395
    video_codec_id = CODEC_ID_NONE;
3396
    audio_stream_copy = 0;
3397
    video_stream_copy = 0;
3398
}
3399

    
3400
/* prepare dummy protocols for grab */
3401
static void prepare_grab(void)
3402
{
3403
    int has_video, has_audio, i, j;
3404
    AVFormatContext *oc;
3405
    AVFormatContext *ic;
3406
    AVFormatParameters vp1, *vp = &vp1;
3407
    AVFormatParameters ap1, *ap = &ap1;
3408
    
3409
    /* see if audio/video inputs are needed */
3410
    has_video = 0;
3411
    has_audio = 0;
3412
    memset(ap, 0, sizeof(*ap));
3413
    memset(vp, 0, sizeof(*vp));
3414
    vp->frame_rate_base= 1;
3415
    for(j=0;j<nb_output_files;j++) {
3416
        oc = output_files[j];
3417
        for(i=0;i<oc->nb_streams;i++) {
3418
            AVCodecContext *enc = &oc->streams[i]->codec;
3419
            switch(enc->codec_type) {
3420
            case CODEC_TYPE_AUDIO:
3421
                if (enc->sample_rate > ap->sample_rate)
3422
                    ap->sample_rate = enc->sample_rate;
3423
                if (enc->channels > ap->channels)
3424
                    ap->channels = enc->channels;
3425
                has_audio = 1;
3426
                break;
3427
            case CODEC_TYPE_VIDEO:
3428
                if (enc->width > vp->width)
3429
                    vp->width = enc->width;
3430
                if (enc->height > vp->height)
3431
                    vp->height = enc->height;
3432
                
3433
                if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3434
                    vp->frame_rate      = enc->frame_rate;
3435
                    vp->frame_rate_base = enc->frame_rate_base;
3436
                }
3437
                has_video = 1;
3438
                break;
3439
            default:
3440
                av_abort();
3441
            }
3442
        }
3443
    }
3444
    
3445
    if (has_video == 0 && has_audio == 0) {
3446
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3447
        exit(1);
3448
    }
3449
    
3450
    if (has_video) {
3451
        AVInputFormat *fmt1;
3452
        fmt1 = av_find_input_format(video_grab_format);
3453
        vp->device  = video_device;
3454
        vp->channel = video_channel;
3455
        vp->standard = video_standard;
3456
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3457
            fprintf(stderr, "Could not find video grab device\n");
3458
            exit(1);
3459
        }
3460
        /* If not enough info to get the stream parameters, we decode the
3461
           first frames to get it. */
3462
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3463
            fprintf(stderr, "Could not find video grab parameters\n");
3464
            exit(1);
3465
        }
3466
        /* by now video grab has one stream */
3467
        ic->streams[0]->r_frame_rate      = vp->frame_rate;
3468
        ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3469
        input_files[nb_input_files] = ic;
3470

    
3471
        if (verbose >= 0)
3472
            dump_format(ic, nb_input_files, "", 0);
3473

    
3474
        nb_input_files++;
3475
    }
3476
    if (has_audio && audio_grab_format) {
3477
        AVInputFormat *fmt1;
3478
        fmt1 = av_find_input_format(audio_grab_format);
3479
        ap->device = audio_device;
3480
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3481
            fprintf(stderr, "Could not find audio grab device\n");
3482
            exit(1);
3483
        }
3484
        input_files[nb_input_files] = ic;
3485

    
3486
        if (verbose >= 0)
3487
            dump_format(ic, nb_input_files, "", 0);
3488

    
3489
        nb_input_files++;
3490
    }
3491
}
3492

    
3493
/* same option as mencoder */
3494
static void opt_pass(const char *pass_str)
3495
{
3496
    int pass;
3497
    pass = atoi(pass_str);
3498
    if (pass != 1 && pass != 2) {
3499
        fprintf(stderr, "pass number can be only 1 or 2\n");
3500
        exit(1);
3501
    }
3502
    do_pass = pass;
3503
}
3504

    
3505
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3506
static int64_t getutime(void)
3507
{
3508
  return av_gettime();
3509
}
3510
#else
3511
static int64_t getutime(void)
3512
{
3513
    struct rusage rusage;
3514

    
3515
    getrusage(RUSAGE_SELF, &rusage);
3516
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3517
}
3518
#endif
3519

    
3520
extern int ffm_nopts;
3521

    
3522
static void opt_bitexact(void)
3523
{
3524
    bitexact=1;
3525
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3526
    ffm_nopts = 1;
3527
}
3528

    
3529
static void show_formats(void)
3530
{
3531
    AVInputFormat *ifmt;
3532
    AVOutputFormat *ofmt;
3533
    AVImageFormat *image_fmt;
3534
    URLProtocol *up;
3535
    AVCodec *p, *p2;
3536
    const char **pp, *last_name;
3537

    
3538
    printf("File formats:\n");
3539
    last_name= "000";
3540
    for(;;){
3541
        int decode=0;
3542
        int encode=0;
3543
        const char *name=NULL;
3544
        const char *long_name=NULL;
3545

    
3546
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3547
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3548
                strcmp(ofmt->name, last_name)>0){
3549
                name= ofmt->name;
3550
                long_name= ofmt->long_name;
3551
                encode=1;
3552
            }
3553
        }
3554
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3555
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3556
                strcmp(ifmt->name, last_name)>0){
3557
                name= ifmt->name;
3558
                long_name= ifmt->long_name;
3559
                encode=0;
3560
            }
3561
            if(name && strcmp(ifmt->name, name)==0)
3562
                decode=1;
3563
        }
3564
        if(name==NULL)
3565
            break;
3566
        last_name= name;
3567
        
3568
        printf(
3569
            " %s%s %-15s %s\n", 
3570
            decode ? "D":" ", 
3571
            encode ? "E":" ", 
3572
            name,
3573
            long_name ? long_name:" ");
3574
    }
3575
    printf("\n");
3576

    
3577
    printf("Image formats (filename extensions, if any, follow):\n");
3578
    for(image_fmt = first_image_format; image_fmt != NULL; 
3579
        image_fmt = image_fmt->next) {
3580
        printf(
3581
            " %s%s %-6s %s\n",
3582
            image_fmt->img_read  ? "D":" ",
3583
            image_fmt->img_write ? "E":" ",
3584
            image_fmt->name,
3585
            image_fmt->extensions ? image_fmt->extensions:" ");
3586
    }
3587
    printf("\n");
3588

    
3589
    printf("Codecs:\n");
3590
    last_name= "000";
3591
    for(;;){
3592
        int decode=0;
3593
        int encode=0;
3594
        int cap=0;
3595

    
3596
        p2=NULL;
3597
        for(p = first_avcodec; p != NULL; p = p->next) {
3598
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3599
                strcmp(p->name, last_name)>0){
3600
                p2= p;
3601
                decode= encode= cap=0;
3602
            }
3603
            if(p2 && strcmp(p->name, p2->name)==0){
3604
                if(p->decode) decode=1;
3605
                if(p->encode) encode=1;
3606
                cap |= p->capabilities;
3607
            }
3608
        }
3609
        if(p2==NULL)
3610
            break;
3611
        last_name= p2->name;
3612
        
3613
        printf(
3614
            " %s%s%s%s%s%s %s", 
3615
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
3616
            encode ? "E":" ", 
3617
            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3618
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3619
            cap & CODEC_CAP_DR1 ? "D":" ",
3620
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3621
            p2->name);
3622
       /* if(p2->decoder && decode==0)
3623
            printf(" use %s for decoding", p2->decoder->name);*/
3624
        printf("\n");
3625
    }
3626
    printf("\n");
3627

    
3628
    printf("Supported file protocols:\n");
3629
    for(up = first_protocol; up != NULL; up = up->next)
3630
        printf(" %s:", up->name);
3631
    printf("\n");
3632
    
3633
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3634
    printf("Motion estimation methods:\n");
3635
    pp = motion_str;
3636
    while (*pp) {
3637
        printf(" %s", *pp);
3638
        if ((pp - motion_str + 1) == ME_ZERO) 
3639
            printf("(fastest)");
3640
        else if ((pp - motion_str + 1) == ME_FULL) 
3641
            printf("(slowest)");
3642
        else if ((pp - motion_str + 1) == ME_EPZS) 
3643
            printf("(default)");
3644
        pp++;
3645
    }
3646
    printf("\n\n");
3647
    printf(
3648
"Note, the names of encoders and decoders dont always match, so there are\n"
3649
"several cases where the above table shows encoder only or decoder only entries\n"
3650
"even though both encoding and decoding are supported for example, the h263\n"
3651
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3652
"worse\n");
3653
    exit(1);
3654
}
3655

    
3656
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3657
{
3658
    int i;
3659
    const char *p = str;
3660
    for(i = 0;; i++) {
3661
        dest[i] = atoi(p);
3662
        if(i == 63)
3663
            break;
3664
        p = strchr(p, ',');
3665
        if(!p) {
3666
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3667
            exit(1);
3668
        }
3669
        p++;
3670
    }
3671
}
3672

    
3673
void opt_inter_matrix(const char *arg)
3674
{
3675
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3676
    parse_matrix_coeffs(inter_matrix, arg);
3677
}
3678

    
3679
void opt_intra_matrix(const char *arg)
3680
{
3681
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3682
    parse_matrix_coeffs(intra_matrix, arg);
3683
}
3684

    
3685
static void opt_target(const char *arg)
3686
{
3687
    int norm = -1;
3688
    static const char const *frame_rates[] = {"25", "30000/1001", "24000/1001"};
3689

    
3690
    if(!strncmp(arg, "pal-", 4)) {
3691
        norm = 0;
3692
        arg += 4;
3693
    } else if(!strncmp(arg, "ntsc-", 5)) {
3694
        norm = 1;
3695
        arg += 5;
3696
    } else if(!strncmp(arg, "film-", 5)) {
3697
        norm = 2;
3698
        arg += 5;
3699
    } else {
3700
        int fr;
3701
        /* Calculate FR via float to avoid int overflow */
3702
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3703
        if(fr == 25000) {
3704
            norm = 0;
3705
        } else if((fr == 29970) || (fr == 23976)) {
3706
            norm = 1;
3707
        } else {
3708
            /* Try to determine PAL/NTSC by peeking in the input files */
3709
            if(nb_input_files) {
3710
                int i, j;
3711
                for(j = 0; j < nb_input_files; j++) {
3712
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3713
                        AVCodecContext *c = &input_files[j]->streams[i]->codec;
3714
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3715
                            continue;
3716
                        fr = c->frame_rate * 1000 / c->frame_rate_base;
3717
                        if(fr == 25000) {
3718
                            norm = 0;
3719
                            break;
3720
                        } else if((fr == 29970) || (fr == 23976)) {
3721
                            norm = 1;
3722
                            break;
3723
                        }
3724
                    }
3725
                    if(norm >= 0)
3726
                        break;
3727
                }
3728
            }
3729
        }
3730
        if(verbose && norm >= 0)
3731
            printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3732
    }
3733

    
3734
    if(norm < 0) {
3735
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3736
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3737
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3738
        exit(1);
3739
    }
3740

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

    
3743
        opt_video_codec("mpeg1video");
3744
        opt_audio_codec("mp2");
3745
        opt_format("vcd");
3746

    
3747
        opt_frame_size(norm ? "352x240" : "352x288");
3748
        opt_frame_rate(frame_rates[norm]);
3749

    
3750
        video_bit_rate = 1150000;
3751
        video_rc_max_rate = 1150000;
3752
        video_rc_min_rate = 1150000;
3753
        video_rc_buffer_size = 40*1024*8;
3754

    
3755
        audio_bit_rate = 224000;
3756
        audio_sample_rate = 44100;
3757
        
3758
        mux_packet_size= 2324;
3759
        mux_rate= 2352 * 75 * 8;
3760

    
3761
        /* We have to offset the PTS, so that it is consistent with the SCR.
3762
           SCR starts at 36000, but the first two packs contain only padding
3763
           and the first pack from the other stream, respectively, may also have
3764
           been written before.
3765
           So the real data starts at SCR 36000+3*1200. */
3766
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3767
    } else if(!strcmp(arg, "svcd")) {
3768

    
3769
        opt_video_codec("mpeg2video");
3770
        opt_audio_codec("mp2");
3771
        opt_format("svcd");
3772

    
3773
        opt_frame_size(norm ? "480x480" : "480x576");
3774
        opt_frame_rate(frame_rates[norm]);
3775
        opt_gop_size(norm ? "18" : "15");
3776

    
3777
        video_bit_rate = 2040000;
3778
        video_rc_max_rate = 2516000;
3779
        video_rc_min_rate = 0; //1145000;
3780
        video_rc_buffer_size = 224*1024*8;
3781
        use_scan_offset = 1;
3782

    
3783
        audio_bit_rate = 224000;
3784
        audio_sample_rate = 44100;
3785

    
3786
        mux_packet_size= 2324;
3787

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

    
3790
        opt_video_codec("mpeg2video");
3791
        opt_audio_codec("ac3");
3792
        opt_format("dvd");
3793

    
3794
        opt_frame_size(norm ? "720x480" : "720x576");
3795
        opt_frame_rate(frame_rates[norm]);
3796
        opt_gop_size(norm ? "18" : "15");
3797

    
3798
        video_bit_rate = 6000000;
3799
        video_rc_max_rate = 9000000;
3800
        video_rc_min_rate = 0; //1500000;
3801
        video_rc_buffer_size = 224*1024*8;
3802

    
3803
        mux_packet_size= 2048;  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3804
        mux_rate = 10080000;    // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3805

    
3806
        audio_bit_rate = 448000;
3807
        audio_sample_rate = 48000;
3808

    
3809
    } else {
3810
        fprintf(stderr, "Unknown target: %s\n", arg);
3811
        exit(1);
3812
    }
3813
}
3814

    
3815
static void show_version(void)
3816
{
3817
    printf("ffmpeg      " FFMPEG_VERSION "\n"
3818
           "libavcodec  %d\n"
3819
           "libavformat %d\n", 
3820
           avcodec_build(), LIBAVFORMAT_BUILD);
3821
    exit(1);
3822
}
3823

    
3824
const OptionDef options[] = {
3825
    /* main options */
3826
    { "L", 0, {(void*)show_license}, "show license" },
3827
    { "h", 0, {(void*)show_help}, "show help" },
3828
    { "version", 0, {(void*)show_version}, "show version" },
3829
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3830
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3831
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3832
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3833
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3834
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3835
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3836
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3837
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3838
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3839
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3840
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3841
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3842
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3843
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3844
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3845
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3846
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
3847
      "add timings for benchmarking" },
3848
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
3849
      "dump each input packet" },
3850
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
3851
      "when dumping packets, also dump the payload" },
3852
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
3853
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3854
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3855
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3856
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3857
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3858
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3859
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3860
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3861

    
3862
    /* video options */
3863
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3864
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3865
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3866
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3867
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3868
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3869
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3870
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3871
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3872
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3873
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3874
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3875
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3876
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3877
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3878
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3879
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3880
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3881
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3882
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3883
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3884
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3885
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3886
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3887
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3888
    { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3889
    { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3890
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3891
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3892
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3893
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3894
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3895
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3896
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3897
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3898
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3899
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3900
//    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3901
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3902
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3903
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3904
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3905
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3906
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3907
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3908
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
3909
      "method" },
3910
    { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3911
    { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3912
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3913
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3914
    { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3915
    { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3916
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3917
    { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3918
    { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3919
    { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3920
    { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3921
    { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3922
    { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3923
    { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3924
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3925
    { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3926
    { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3927
    { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3928
    { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3929
    { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3930
    { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3931
    { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3932
    { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3933
    { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3934
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3935
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3936
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3937
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3938
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
3939
      "use same video quality as source (implies VBR)" },
3940
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3941
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3942
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
3943
      "deinterlace pictures" },
3944
    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 
3945
      "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3946
    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 
3947
      "force interlaced me support in encoder (MPEG2/MPEG4)" },
3948
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3949
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
3950
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3951
    { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3952
    { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3953
    { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3954
    { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3955
    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3956
    { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3957
    { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3958
    { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3959
    { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3960
    { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
3961
    { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3962
    { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3963
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3964
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3965
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3966
    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3967
    { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3968
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3969
    { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3970
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3971
    { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3972
    { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3973
    { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3974
    { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
3975
    { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
3976
    { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
3977
    { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
3978
    { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
3979
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3980
    { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3981
    { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3982
    { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3983
    { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
3984

    
3985
    /* audio options */
3986
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3987
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3988
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3989
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3990
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3991
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3992

    
3993
    /* grab options */
3994
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3995
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3996
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3997
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3998

    
3999
    /* G.2 grab options */ 
4000
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4001
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4002
 
4003
    /* muxer options */   
4004
    { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4005
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4006
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4007
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4008
    { NULL, },
4009
};
4010

    
4011
static void show_banner(void)
4012
{
4013
    printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4014
        LIBAVCODEC_BUILD);
4015
    printf("  configuration: %s\n", FFMPEG_CONFIGURATION);
4016
    printf("  built on " __DATE__ " " __TIME__);
4017
#ifdef __GNUC__
4018
    printf(", gcc: %s\n", __VERSION__);
4019
#else
4020
    printf(", using a non-gcc compiler\n");
4021
#endif
4022
}
4023

    
4024
static void show_license(void)
4025
{
4026
    show_banner();
4027
#ifdef CONFIG_GPL
4028
    printf(
4029
    "This program is free software; you can redistribute it and/or modify\n"   
4030
    "it under the terms of the GNU General Public License as published by\n"
4031
    "the Free Software Foundation; either version 2 of the License, or\n"
4032
    "(at your option) any later version.\n"
4033
    "\n"
4034
    "This program is distributed in the hope that it will be useful,\n"
4035
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4036
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4037
    "GNU General Public License for more details.\n"
4038
    "\n"
4039
    "You should have received a copy of the GNU General Public License\n"
4040
    "along with this program; if not, write to the Free Software\n"
4041
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4042
    );
4043
#else
4044
    printf(
4045
    "This library is free software; you can redistribute it and/or\n"
4046
    "modify it under the terms of the GNU Lesser General Public\n"
4047
    "License as published by the Free Software Foundation; either\n"
4048
    "version 2 of the License, or (at your option) any later version.\n"
4049
    "\n"
4050
    "This library is distributed in the hope that it will be useful,\n"
4051
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4052
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4053
    "Lesser General Public License for more details.\n"
4054
    "\n"
4055
    "You should have received a copy of the GNU Lesser General Public\n"
4056
    "License along with this library; if not, write to the Free Software\n"
4057
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4058
    );
4059
#endif
4060
    exit(1);
4061
}
4062

    
4063
static void show_help(void)
4064
{
4065
    show_banner();
4066
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4067
           "Hyper fast Audio and Video encoder\n");
4068
    printf("\n");
4069
    show_help_options(options, "Main options:\n",
4070
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4071
    show_help_options(options, "\nVideo options:\n",
4072
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4073
                      OPT_VIDEO);
4074
    show_help_options(options, "\nAdvanced Video options:\n",
4075
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4076
                      OPT_VIDEO | OPT_EXPERT);
4077
    show_help_options(options, "\nAudio options:\n",
4078
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4079
                      OPT_AUDIO);
4080
    show_help_options(options, "\nAdvanced Audio options:\n",
4081
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4082
                      OPT_AUDIO | OPT_EXPERT);
4083
    show_help_options(options, "\nAudio/Video grab options:\n",
4084
                      OPT_GRAB, 
4085
                      OPT_GRAB);
4086
    show_help_options(options, "\nAdvanced options:\n",
4087
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4088
                      OPT_EXPERT);
4089
    exit(1);
4090
}
4091

    
4092
void parse_arg_file(const char *filename)
4093
{
4094
    opt_output_file(filename);
4095
}
4096

    
4097
int main(int argc, char **argv)
4098
{
4099
    int i;
4100
    int64_t ti;
4101

    
4102
    av_register_all();
4103

    
4104
    if (argc <= 1)
4105
        show_help();
4106
    else
4107
        show_banner();
4108
    
4109
    /* parse options */
4110
    parse_options(argc, argv, options);
4111

    
4112
    /* file converter / grab */
4113
    if (nb_output_files <= 0) {
4114
        fprintf(stderr, "Must supply at least one output file\n");
4115
        exit(1);
4116
    }
4117
    
4118
    if (nb_input_files == 0) {
4119
        input_sync = 1;
4120
        prepare_grab();
4121
    }
4122

    
4123
    ti = getutime();
4124
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
4125
              stream_maps, nb_stream_maps);
4126
    ti = getutime() - ti;
4127
    if (do_benchmark) {
4128
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4129
    }
4130

    
4131
    /* close files */
4132
    for(i=0;i<nb_output_files;i++) {
4133
        /* maybe av_close_output_file ??? */
4134
        AVFormatContext *s = output_files[i];
4135
        int j;
4136
        if (!(s->oformat->flags & AVFMT_NOFILE))
4137
            url_fclose(&s->pb);
4138
        for(j=0;j<s->nb_streams;j++)
4139
            av_free(s->streams[j]);
4140
        av_free(s);
4141
    }
4142
    for(i=0;i<nb_input_files;i++)
4143
        av_close_input_file(input_files[i]);
4144

    
4145
    av_free_static();
4146

    
4147
    if(intra_matrix)
4148
        av_free(intra_matrix);
4149
    if(inter_matrix)
4150
        av_free(inter_matrix);
4151
    
4152
#ifdef POWERPC_PERFORMANCE_REPORT
4153
    extern void powerpc_display_perf_report(void);
4154
    powerpc_display_perf_report();
4155
#endif /* POWERPC_PERFORMANCE_REPORT */
4156

    
4157
#ifndef CONFIG_WIN32
4158
    if (received_sigterm) {
4159
        fprintf(stderr,
4160
            "Received signal %d: terminating.\n",
4161
            (int) received_sigterm);
4162
        exit (255);
4163
    }
4164
#endif
4165
    exit(0); /* not all OS-es handle main() return value */
4166
    return 0;
4167
}