Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ f3356e9c

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

    
209
static int gop_size = 12;
210
static int intra_only = 0;
211
static int audio_sample_rate = 44100;
212
static int audio_bit_rate = 64000;
213
static int audio_disable = 0;
214
static int audio_channels = 1;
215
static int audio_codec_id = CODEC_ID_NONE;
216
static int audio_codec_tag = 0;
217

    
218
static int mux_rate= 0;
219
static int mux_packet_size= 0;
220
static float mux_preload= 0.5;
221
static float mux_max_delay= 0.7;
222

    
223
static int64_t recording_time = 0;
224
static int64_t start_time = 0;
225
static int64_t rec_timestamp = 0;
226
static int64_t input_ts_offset = 0;
227
static int file_overwrite = 0;
228
static char *str_title = NULL;
229
static char *str_author = NULL;
230
static char *str_copyright = NULL;
231
static char *str_comment = NULL;
232
static int do_benchmark = 0;
233
static int do_hex_dump = 0;
234
static int do_pkt_dump = 0;
235
static int do_psnr = 0;
236
static int do_vstats = 0;
237
static int do_pass = 0;
238
static int bitexact = 0;
239
static char *pass_logfilename = NULL;
240
static int audio_stream_copy = 0;
241
static int video_stream_copy = 0;
242
static int video_sync_method= 1;
243
static int audio_sync_method= 0;
244
static int copy_ts= 0;
245

    
246
static int rate_emu = 0;
247

    
248
static char *video_grab_format = "video4linux";
249
static char *video_device = NULL;
250
static char *grab_device = NULL;
251
static int  video_channel = 0;
252
static char *video_standard = "ntsc";
253

    
254
static char *audio_grab_format = "audio_device";
255
static char *audio_device = NULL;
256

    
257
static int using_stdin = 0;
258
static int using_vhook = 0;
259
static int verbose = 1;
260
static int thread_count= 1;
261
static int q_pressed = 0;
262
static int me_range = 0;
263
static int64_t video_size = 0;
264
static int64_t audio_size = 0;
265
static int64_t extra_size = 0;
266
static int nb_frames_dup = 0;
267
static int nb_frames_drop = 0;
268
static int input_sync;
269

    
270
static int pgmyuv_compatibility_hack=0;
271

    
272

    
273
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
274

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

    
291
    int video_crop;          /* video_resample and video_crop are mutually exclusive */
292
    int topBand;             /* cropping area sizes */
293
    int leftBand;
294
    
295
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
296
    int padtop;              /* padding area sizes */
297
    int padbottom;
298
    int padleft;
299
    int padright;
300
    
301
    /* audio only */
302
    int audio_resample;
303
    ReSampleContext *resample; /* for audio resampling */
304
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
305
    FILE *logfile;
306
} AVOutputStream;
307

    
308
typedef struct AVInputStream {
309
    int file_index;
310
    int index;
311
    AVStream *st;
312
    int discard;             /* true if stream data should be discarded */
313
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
314
    int64_t sample_index;      /* current sample */
315

    
316
    int64_t       start;     /* time when read started */
317
    unsigned long frame;     /* current frame */
318
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
319
                                is not defined */
320
    int64_t       pts;       /* current pts */
321
    int is_start;            /* is 1 at the start and after a discontinuity */
322
} AVInputStream;
323

    
324
typedef struct AVInputFile {
325
    int eof_reached;      /* true if eof reached */
326
    int ist_index;        /* index of first stream in ist_table */
327
    int buffer_size;      /* current total buffer size */
328
    int buffer_size_max;  /* buffer size at which we consider we can stop
329
                             buffering */
330
    int nb_streams;       /* nb streams we are aware of */
331
} AVInputFile;
332

    
333
#ifndef CONFIG_WIN32
334

    
335
/* init terminal so that we can grab keys */
336
static struct termios oldtty;
337

    
338
static void term_exit(void)
339
{
340
    tcsetattr (0, TCSANOW, &oldtty);
341
}
342

    
343
static volatile sig_atomic_t received_sigterm = 0;
344

    
345
static void
346
sigterm_handler(int sig)
347
{
348
    received_sigterm = sig;
349
    term_exit();
350
}
351

    
352
static void term_init(void)
353
{
354
    struct termios tty;
355

    
356
    tcgetattr (0, &tty);
357
    oldtty = tty;
358

    
359
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
360
                          |INLCR|IGNCR|ICRNL|IXON);
361
    tty.c_oflag |= OPOST;
362
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
363
    tty.c_cflag &= ~(CSIZE|PARENB);
364
    tty.c_cflag |= CS8;
365
    tty.c_cc[VMIN] = 1;
366
    tty.c_cc[VTIME] = 0;
367
    
368
    tcsetattr (0, TCSANOW, &tty);
369

    
370
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
371
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
372
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
373
    /*
374
    register a function to be called at normal program termination
375
    */
376
    atexit(term_exit);
377
#ifdef CONFIG_BEOS_NETSERVER
378
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
379
#endif
380
}
381

    
382
/* read a key without blocking */
383
static int read_key(void)
384
{
385
    int n = 1;
386
    unsigned char ch;
387
#ifndef CONFIG_BEOS_NETSERVER
388
    struct timeval tv;
389
    fd_set rfds;
390

    
391
    FD_ZERO(&rfds);
392
    FD_SET(0, &rfds);
393
    tv.tv_sec = 0;
394
    tv.tv_usec = 0;
395
    n = select(1, &rfds, NULL, NULL, &tv);
396
#endif
397
    if (n > 0) {
398
        n = read(0, &ch, 1);
399
        if (n == 1)
400
            return ch;
401

    
402
        return n;
403
    }
404
    return -1;
405
}
406

    
407
static int decode_interrupt_cb(void)
408
{
409
    return q_pressed || (q_pressed = read_key() == 'q');
410
}
411

    
412
#else
413

    
414
static volatile int received_sigterm = 0;
415

    
416
/* no interactive support */
417
static void term_exit(void)
418
{
419
}
420

    
421
static void term_init(void)
422
{
423
}
424

    
425
static int read_key(void)
426
{
427
    return 0;
428
}
429

    
430
#endif
431

    
432
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
433
{
434
    int i, err;
435
    AVFormatContext *ic;
436

    
437
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
438
    if (err < 0)
439
        return err;
440
    /* copy stream format */
441
    s->nb_streams = ic->nb_streams;
442
    for(i=0;i<ic->nb_streams;i++) {
443
        AVStream *st;
444

    
445
        st = av_mallocz(sizeof(AVStream));
446
        memcpy(st, ic->streams[i], sizeof(AVStream));
447
        s->streams[i] = st;
448
    }
449

    
450
    av_close_input_file(ic);
451
    return 0;
452
}
453

    
454
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
455

    
456
static void do_audio_out(AVFormatContext *s, 
457
                         AVOutputStream *ost, 
458
                         AVInputStream *ist,
459
                         unsigned char *buf, int size)
460
{
461
    uint8_t *buftmp;
462
    static uint8_t *audio_buf = NULL;
463
    static uint8_t *audio_out = NULL;
464
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
465

    
466
    int size_out, frame_bytes, ret;
467
    AVCodecContext *enc= &ost->st->codec;
468

    
469
    /* SC: dynamic allocation of buffers */
470
    if (!audio_buf)
471
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
472
    if (!audio_out)
473
        audio_out = av_malloc(audio_out_size);
474
    if (!audio_buf || !audio_out)
475
        return;               /* Should signal an error ! */
476

    
477
    if(audio_sync_method){
478
        double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts 
479
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
480
        double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
481
        int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
482

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

    
499
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
500
                        ist->is_start=0;
501
                    else
502
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
503

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

    
524
    if (ost->audio_resample) {
525
        buftmp = audio_buf;
526
        size_out = audio_resample(ost->resample, 
527
                                  (short *)buftmp, (short *)buf,
528
                                  size / (ist->st->codec.channels * 2));
529
        size_out = size_out * enc->channels * 2;
530
    } else {
531
        buftmp = buf;
532
        size_out = size;
533
    }
534

    
535
    /* now encode as many frames as possible */
536
    if (enc->frame_size > 1) {
537
        /* output resampled raw samples */
538
        fifo_write(&ost->fifo, buftmp, size_out, 
539
                   &ost->fifo.wptr);
540

    
541
        frame_bytes = enc->frame_size * 2 * enc->channels;
542
        
543
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
544
                     &ost->fifo.rptr) == 0) {
545
            AVPacket pkt;
546
            av_init_packet(&pkt);
547

    
548
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
549
                                       (short *)audio_buf);
550
            audio_size += ret;
551
            pkt.stream_index= ost->index;
552
            pkt.data= audio_out;
553
            pkt.size= ret;
554
            if(enc->coded_frame)
555
                pkt.pts= enc->coded_frame->pts;
556
            pkt.flags |= PKT_FLAG_KEY;
557
            av_interleaved_write_frame(s, &pkt);
558
            
559
            ost->sync_opts += enc->frame_size;
560
        }
561
    } else {
562
        AVPacket pkt;
563
        av_init_packet(&pkt);
564

    
565
        ost->sync_opts += size_out / (2 * enc->channels);
566

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

    
592
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
593
{
594
    AVCodecContext *dec;
595
    AVPicture *picture2;
596
    AVPicture picture_tmp;
597
    uint8_t *buf = 0;
598

    
599
    dec = &ist->st->codec;
600

    
601
    /* deinterlace : must be done before any resize */
602
    if (do_deinterlace || using_vhook) {
603
        int size;
604

    
605
        /* create temporary picture */
606
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
607
        buf = av_malloc(size);
608
        if (!buf)
609
            return;
610
        
611
        picture2 = &picture_tmp;
612
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
613

    
614
        if (do_deinterlace){
615
            if(avpicture_deinterlace(picture2, picture, 
616
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
617
                /* if error, do not deinterlace */
618
                av_free(buf);
619
                buf = NULL;
620
                picture2 = picture;
621
            }
622
        } else {
623
            if (img_convert(picture2, dec->pix_fmt, picture, 
624
                            dec->pix_fmt, dec->width, dec->height) < 0) {
625
                /* if error, do not copy */
626
                av_free(buf);
627
                buf = NULL;
628
                picture2 = picture;
629
            }
630
        }
631
    } else {
632
        picture2 = picture;
633
    }
634

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

    
637
    if (picture != picture2)
638
        *picture = *picture2;
639
    *bufp = buf;
640
}
641

    
642
/* we begin to correct av delay at this threshold */
643
#define AV_DELAY_MAX 0.100
644

    
645

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

    
661
        if (padleft || padright) {
662
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
663
                (img->linesize[i] - (padright >> shift));
664

    
665
            for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
666
                memset(optr, color[i], (padleft + padright) >> shift);
667
                optr += img->linesize[i];
668
            }
669
        }
670
      
671
        if (padbottom || padright) {
672
            optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
673
            memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
674
        }
675
    }
676
}
677

    
678
static int bit_buffer_size= 1024*256;
679
static uint8_t *bit_buffer= NULL;
680

    
681
static void do_video_out(AVFormatContext *s, 
682
                         AVOutputStream *ost, 
683
                         AVInputStream *ist,
684
                         AVFrame *in_picture,
685
                         int *frame_size)
686
{
687
    int nb_frames, i, ret;
688
    AVFrame *final_picture, *formatted_picture;
689
    AVFrame picture_format_temp, picture_crop_temp;
690
    uint8_t *buf = NULL, *buf1 = NULL;
691
    AVCodecContext *enc, *dec;
692
    enum PixelFormat target_pixfmt;
693
    
694
    avcodec_get_frame_defaults(&picture_format_temp);
695
    avcodec_get_frame_defaults(&picture_crop_temp);
696

    
697
    enc = &ost->st->codec;
698
    dec = &ist->st->codec;
699

    
700
    /* by default, we output a single frame */
701
    nb_frames = 1;
702

    
703
    *frame_size = 0;
704

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

    
726
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
727
    if (nb_frames <= 0) 
728
        return;
729

    
730
    /* convert pixel format if needed */
731
    target_pixfmt = ost->video_resample || ost->video_pad
732
        ? PIX_FMT_YUV420P : enc->pix_fmt;
733
    if (dec->pix_fmt != target_pixfmt) {
734
        int size;
735

    
736
        /* create temporary picture */
737
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
738
        buf = av_malloc(size);
739
        if (!buf)
740
            return;
741
        formatted_picture = &picture_format_temp;
742
        avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
743
        
744
        if (img_convert((AVPicture*)formatted_picture, target_pixfmt, 
745
                        (AVPicture *)in_picture, dec->pix_fmt, 
746
                        dec->width, dec->height) < 0) {
747

    
748
            if (verbose >= 0)
749
                fprintf(stderr, "pixel format conversion not handled\n");
750

    
751
            goto the_end;
752
        }
753
    } else {
754
        formatted_picture = in_picture;
755
    }
756

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

    
786
                if (verbose >= 0)
787
                    fprintf(stderr, "pixel format conversion not handled\n");
788

    
789
                goto the_end;
790
            }
791
        }
792
    } else if (ost->video_crop) {
793
        picture_crop_temp.data[0] = formatted_picture->data[0] +
794
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
795

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

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

    
804
        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
805
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
806
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
807
        final_picture = &picture_crop_temp;
808
    } else if (ost->video_pad) {
809
        final_picture = &ost->pict_tmp;
810

    
811
        for (i = 0; i < 3; i++) {
812
            uint8_t *optr, *iptr;
813
            int shift = (i == 0) ? 0 : 1;
814
            int y, yheight;
815
            
816
            /* set offset to start writing image into */
817
            optr = final_picture->data[i] + (((final_picture->linesize[i] * 
818
                            ost->padtop) + ost->padleft) >> shift);
819
            iptr = formatted_picture->data[i];
820

    
821
            yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
822
            for (y = 0; y < yheight; y++) {
823
                /* copy unpadded image row into padded image row */
824
                memcpy(optr, iptr, formatted_picture->linesize[i]);
825
                optr += final_picture->linesize[i];
826
                iptr += formatted_picture->linesize[i];
827
            }
828
        }
829

    
830
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
831
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
832
                padcolor);
833
        
834
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
835
            int size;
836

    
837
            av_free(buf);
838
            /* create temporary picture */
839
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
840
            buf = av_malloc(size);
841
            if (!buf)
842
                return;
843
            final_picture = &picture_format_temp;
844
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
845

    
846
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
847
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
848
                        enc->width, enc->height) < 0) {
849

    
850
                if (verbose >= 0)
851
                    fprintf(stderr, "pixel format conversion not handled\n");
852

    
853
                goto the_end;
854
            }
855
        }
856
    } else {
857
        final_picture = formatted_picture;
858
    }
859
    /* duplicates frame if needed */
860
    for(i=0;i<nb_frames;i++) {
861
        AVPacket pkt;
862
        av_init_packet(&pkt);
863
        pkt.stream_index= ost->index;
864

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

    
878
            av_interleaved_write_frame(s, &pkt);
879
            enc->coded_frame = old_frame;
880
        } else {
881
            AVFrame big_picture;
882

    
883
            big_picture= *final_picture;
884
            /* better than nothing: use input picture interlaced
885
               settings */
886
            big_picture.interlaced_frame = in_picture->interlaced_frame;
887
            if(do_interlace_me || do_interlace_dct){
888
                if(top_field_first == -1)
889
                    big_picture.top_field_first = in_picture->top_field_first;
890
                else
891
                    big_picture.top_field_first = top_field_first;
892
            }
893

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

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

    
939
static double psnr(double d){
940
    if(d==0) return INFINITY;
941
    return -10.0*log(d)/log(10.0);
942
}
943

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

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

    
1017

    
1018
    oc = output_files[0];
1019

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

    
1077
        if (verbose > 1)
1078
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1079
                  nb_frames_dup, nb_frames_drop);
1080
        
1081
        if (verbose >= 0)
1082
            fprintf(stderr, "%s    \r", buf);
1083

    
1084
        fflush(stderr);
1085
    }
1086
        
1087
    if (is_last_report && verbose >= 0){
1088
        int64_t raw= audio_size + video_size + extra_size;
1089
        fprintf(stderr, "\n");
1090
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1091
                video_size/1024.0,
1092
                audio_size/1024.0,
1093
                extra_size/1024.0,
1094
                100.0*(total_size - raw)/raw
1095
        );
1096
    }
1097
}
1098

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

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

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

    
1204
            buffer_to_free = NULL;
1205
            if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1206
                pre_process_video_frame(ist, (AVPicture *)&picture, 
1207
                                        &buffer_to_free);
1208
            }
1209

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

    
1217
                ist->frame++;
1218
            }
1219

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

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

    
1243
#if 0
1244
                        printf("%d: got pts=%0.3f %0.3f\n", i, 
1245
                               (double)pkt->pts / AV_TIME_BASE, 
1246
                               ((double)ist->pts / AV_TIME_BASE) - 
1247
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1248
#endif
1249
                        /* set the input output pts pairs */
1250
                        ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1251

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

    
1271
                            /* no reencoding needed : output the packet directly */
1272
                            /* force the input stream PTS */
1273
                        
1274
                            avcodec_get_frame_defaults(&avframe);
1275
                            ost->st->codec.coded_frame= &avframe;
1276
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1277

    
1278
                            if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1279
                                audio_size += data_size;
1280
                            else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1281
                                video_size += data_size;
1282
                                ost->sync_opts++;
1283
                            }
1284

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

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

    
1361

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

    
1380
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1381
    if (!file_table)
1382
        goto fail;
1383
        
1384
    /* input stream init */
1385
    j = 0;
1386
    for(i=0;i<nb_input_files;i++) {
1387
        is = input_files[i];
1388
        file_table[i].ist_index = j;
1389
        file_table[i].nb_streams = is->nb_streams;
1390
        j += is->nb_streams;
1391
    }
1392
    nb_istreams = j;
1393

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

    
1415
            if (ist->st->codec.rate_emu) {
1416
                ist->start = av_gettime();
1417
                ist->frame = 0;
1418
            }
1419
        }
1420
    }
1421

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

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

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

    
1515
        codec = &ost->st->codec;
1516
        icodec = &ist->st->codec;
1517

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

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

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

    
1693
    if (!bit_buffer)
1694
        bit_buffer = av_malloc(bit_buffer_size);
1695
    if (!bit_buffer)
1696
        goto fail;
1697

    
1698
    /* dump the file output parameters - cannot be done before in case
1699
       of stream copy */
1700
    for(i=0;i<nb_output_files;i++) {
1701
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1702
    }
1703

    
1704
    /* dump the stream mapping */
1705
    if (verbose >= 0) {
1706
        fprintf(stderr, "Stream mapping:\n");
1707
        for(i=0;i<nb_ostreams;i++) {
1708
            ost = ost_table[i];
1709
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1710
                    ist_table[ost->source_index]->file_index,
1711
                    ist_table[ost->source_index]->index,
1712
                    ost->file_index, 
1713
                    ost->index);
1714
        }
1715
    }
1716

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

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

    
1758
    /* init pts */
1759
    for(i=0;i<nb_istreams;i++) {
1760
        ist = ist_table[i];
1761
        is = input_files[ist->file_index];
1762
        ist->pts = 0;
1763
        ist->next_pts = ist->st->start_time;
1764
        if(ist->next_pts == AV_NOPTS_VALUE) 
1765
            ist->next_pts=0;
1766
        if(input_files_ts_offset[ist->file_index])
1767
            ist->next_pts= AV_NOPTS_VALUE;
1768
        ist->is_start = 1;
1769
    }
1770

    
1771
    /* compute buffer size max (should use a complete heuristic) */
1772
    for(i=0;i<nb_input_files;i++) {
1773
        file_table[i].buffer_size_max = 2048;
1774
    }
1775

    
1776
    /* set meta data information from input file if required */
1777
    for (i=0;i<nb_meta_data_maps;i++) {
1778
        AVFormatContext *out_file;
1779
        AVFormatContext *in_file;
1780

    
1781
        int out_file_index = meta_data_maps[i].out_file;
1782
        int in_file_index = meta_data_maps[i].in_file;
1783
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1784
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1785
            ret = -EINVAL;
1786
            goto fail;
1787
        }
1788
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1789
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1790
            ret = -EINVAL;
1791
            goto fail;
1792
        }                
1793
                 
1794
        out_file = output_files[out_file_index];
1795
        in_file = input_files[in_file_index];
1796

    
1797
        strcpy(out_file->title, in_file->title);
1798
        strcpy(out_file->author, in_file->author);
1799
        strcpy(out_file->copyright, in_file->copyright);
1800
        strcpy(out_file->comment, in_file->comment);
1801
        strcpy(out_file->album, in_file->album);
1802
        out_file->year = in_file->year;
1803
        out_file->track = in_file->track;
1804
        strcpy(out_file->genre, in_file->genre);
1805
    }
1806
        
1807
    /* open files and write file headers */
1808
    for(i=0;i<nb_output_files;i++) {
1809
        os = output_files[i];
1810
        if (av_write_header(os) < 0) {
1811
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1812
            ret = -EINVAL;
1813
            goto fail;
1814
        }
1815
    }
1816

    
1817
#ifndef CONFIG_WIN32
1818
    if ( !using_stdin && verbose >= 0) {
1819
        fprintf(stderr, "Press [q] to stop encoding\n");
1820
        url_set_interrupt_cb(decode_interrupt_cb);
1821
    }
1822
#endif
1823
    term_init();
1824

    
1825
    stream_no_data = 0;
1826
    key = -1;
1827

    
1828
    for(; received_sigterm == 0;) {
1829
        int file_index, ist_index;
1830
        AVPacket pkt;
1831
        double ipts_min;
1832
        double opts_min;
1833

    
1834
    redo:
1835
        ipts_min= 1e100;
1836
        opts_min= 1e100;
1837
        /* if 'q' pressed, exits */
1838
        if (!using_stdin) {
1839
            if (q_pressed)
1840
                break;
1841
            /* read_key() returns 0 on EOF */
1842
            key = read_key();
1843
            if (key == 'q')
1844
                break;
1845
        }
1846

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

    
1880
        /* finish if recording time exhausted */
1881
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1882
            break;
1883

    
1884
        /* read a frame from it and output it in the fifo */
1885
        is = input_files[file_index];
1886
        if (av_read_frame(is, &pkt) < 0) {
1887
            file_table[file_index].eof_reached = 1;
1888
            continue;
1889
        }
1890

    
1891
        if (!pkt.size) {
1892
            stream_no_data = is;
1893
        } else {
1894
            stream_no_data = 0;
1895
        }
1896
        if (do_pkt_dump) {
1897
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1898
        }
1899
        /* the following test is needed in case new streams appear
1900
           dynamically in stream : we ignore them */
1901
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1902
            goto discard_packet;
1903
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1904
        ist = ist_table[ist_index];
1905
        if (ist->discard)
1906
            goto discard_packet;
1907

    
1908
//        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);
1909
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1910
            int64_t delta= pkt.dts - ist->next_pts;
1911
            if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1912
                input_files_ts_offset[ist->file_index]-= delta;
1913
                if (verbose > 2)
1914
                    fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1915
                for(i=0; i<file_table[file_index].nb_streams; i++){
1916
                    int index= file_table[file_index].ist_index + i;
1917
                    ist_table[index]->next_pts += delta;
1918
                    ist_table[index]->is_start=1;
1919
                }
1920
            }
1921
        }
1922

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

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

    
1930
            av_free_packet(&pkt);
1931
            goto redo;
1932
        }
1933
        
1934
    discard_packet:
1935
        av_free_packet(&pkt);
1936
        
1937
        /* dump report by using the output first video and audio streams */
1938
        print_report(output_files, ost_table, nb_ostreams, 0);
1939
    }
1940

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

    
1949
    term_exit();
1950

    
1951
    /* write the trailer if needed and close file */
1952
    for(i=0;i<nb_output_files;i++) {
1953
        os = output_files[i];
1954
        av_write_trailer(os);
1955
    }
1956

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

    
1960
    /* close each encoder */
1961
    for(i=0;i<nb_ostreams;i++) {
1962
        ost = ost_table[i];
1963
        if (ost->encoding_needed) {
1964
            av_freep(&ost->st->codec.stats_in);
1965
            avcodec_close(&ost->st->codec);
1966
        }
1967
    }
1968
    
1969
    /* close each decoder */
1970
    for(i=0;i<nb_istreams;i++) {
1971
        ist = ist_table[i];
1972
        if (ist->decoding_needed) {
1973
            avcodec_close(&ist->st->codec);
1974
        }
1975
    }
1976

    
1977
    /* finished ! */
1978
    
1979
    ret = 0;
1980
 fail1:
1981
    av_freep(&bit_buffer);
1982
    av_free(file_table);
1983

    
1984
    if (ist_table) {
1985
        for(i=0;i<nb_istreams;i++) {
1986
            ist = ist_table[i];
1987
            av_free(ist);
1988
        }
1989
        av_free(ist_table);
1990
    }
1991
    if (ost_table) {
1992
        for(i=0;i<nb_ostreams;i++) {
1993
            ost = ost_table[i];
1994
            if (ost) {
1995
                if (ost->logfile) {
1996
                    fclose(ost->logfile);
1997
                    ost->logfile = NULL;
1998
                }
1999
                fifo_free(&ost->fifo); /* works even if fifo is not
2000
                                          initialized but set to zero */
2001
                av_free(ost->pict_tmp.data[0]);
2002
                if (ost->video_resample)
2003
                    img_resample_close(ost->img_resample_ctx);
2004
                if (ost->audio_resample)
2005
                    audio_resample_close(ost->resample);
2006
                av_free(ost);
2007
            }
2008
        }
2009
        av_free(ost_table);
2010
    }
2011
    return ret;
2012
 fail:
2013
    ret = -ENOMEM;
2014
    goto fail1;
2015
}
2016

    
2017
#if 0
2018
int file_read(const char *filename)
2019
{
2020
    URLContext *h;
2021
    unsigned char buffer[1024];
2022
    int len, i;
2023

2024
    if (url_open(&h, filename, O_RDONLY) < 0) {
2025
        printf("could not open '%s'\n", filename);
2026
        return -1;
2027
    }
2028
    for(;;) {
2029
        len = url_read(h, buffer, sizeof(buffer));
2030
        if (len <= 0)
2031
            break;
2032
        for(i=0;i<len;i++) putchar(buffer[i]);
2033
    }
2034
    url_close(h);
2035
    return 0;
2036
}
2037
#endif
2038

    
2039
static void opt_image_format(const char *arg)
2040
{
2041
    AVImageFormat *f;
2042
    
2043
    for(f = first_image_format; f != NULL; f = f->next) {
2044
        if (!strcmp(arg, f->name))
2045
            break;
2046
    }
2047
    if (!f) {
2048
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2049
        exit(1);
2050
    }
2051
    image_format = f;
2052
}
2053

    
2054
static void opt_format(const char *arg)
2055
{
2056
    /* compatibility stuff for pgmyuv */
2057
    if (!strcmp(arg, "pgmyuv")) {
2058
        pgmyuv_compatibility_hack=1;
2059
//        opt_image_format(arg);
2060
        arg = "image2";
2061
    }
2062

    
2063
    file_iformat = av_find_input_format(arg);
2064
    file_oformat = guess_format(arg, NULL, NULL);
2065
    if (!file_iformat && !file_oformat) {
2066
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2067
        exit(1);
2068
    }
2069
}
2070

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

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

    
2081
static void opt_video_bitrate_max(const char *arg)
2082
{
2083
    video_rc_max_rate = atoi(arg) * 1000;
2084
}
2085

    
2086
static void opt_video_bitrate_min(const char *arg)
2087
{
2088
    video_rc_min_rate = atoi(arg) * 1000;
2089
}
2090

    
2091
static void opt_video_buffer_size(const char *arg)
2092
{
2093
    video_rc_buffer_size = atoi(arg) * 8*1024;
2094
}
2095

    
2096
static void opt_video_rc_eq(char *arg)
2097
{
2098
    video_rc_eq = arg;
2099
}
2100

    
2101
static void opt_video_rc_override_string(char *arg)
2102
{
2103
    video_rc_override_string = arg;
2104
}
2105

    
2106

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

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

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

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

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

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

    
2137
static void opt_error_concealment(const char *arg)
2138
{
2139
    error_concealment = atoi(arg);
2140
}
2141

    
2142
static void opt_debug(const char *arg)
2143
{
2144
    debug = atoi(arg);
2145
}
2146

    
2147
static void opt_vismv(const char *arg)
2148
{
2149
    debug_mv = atoi(arg);
2150
}
2151
    
2152
static void opt_verbose(const char *arg)
2153
{
2154
    verbose = atoi(arg);
2155
    av_log_set_level(atoi(arg));
2156
}
2157

    
2158
static void opt_frame_rate(const char *arg)
2159
{
2160
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2161
        fprintf(stderr, "Incorrect frame rate\n");
2162
        exit(1);
2163
    }
2164
}
2165

    
2166
static void opt_frame_crop_top(const char *arg)
2167
{
2168
    frame_topBand = atoi(arg); 
2169
    if (frame_topBand < 0) {
2170
        fprintf(stderr, "Incorrect top crop size\n");
2171
        exit(1);
2172
    }
2173
    if ((frame_topBand % 2) != 0) {
2174
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2175
        exit(1);
2176
    }
2177
    if ((frame_topBand) >= frame_height){
2178
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2179
        exit(1);
2180
    }
2181
    frame_height -= frame_topBand;
2182
}
2183

    
2184
static void opt_frame_crop_bottom(const char *arg)
2185
{
2186
    frame_bottomBand = atoi(arg);
2187
    if (frame_bottomBand < 0) {
2188
        fprintf(stderr, "Incorrect bottom crop size\n");
2189
        exit(1);
2190
    }
2191
    if ((frame_bottomBand % 2) != 0) {
2192
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2193
        exit(1);        
2194
    }
2195
    if ((frame_bottomBand) >= frame_height){
2196
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2197
        exit(1);
2198
    }
2199
    frame_height -= frame_bottomBand;
2200
}
2201

    
2202
static void opt_frame_crop_left(const char *arg)
2203
{
2204
    frame_leftBand = atoi(arg);
2205
    if (frame_leftBand < 0) {
2206
        fprintf(stderr, "Incorrect left crop size\n");
2207
        exit(1);
2208
    }
2209
    if ((frame_leftBand % 2) != 0) {
2210
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2211
        exit(1);
2212
    }
2213
    if ((frame_leftBand) >= frame_width){
2214
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2215
        exit(1);
2216
    }
2217
    frame_width -= frame_leftBand;
2218
}
2219

    
2220
static void opt_frame_crop_right(const char *arg)
2221
{
2222
    frame_rightBand = atoi(arg);
2223
    if (frame_rightBand < 0) {
2224
        fprintf(stderr, "Incorrect right crop size\n");
2225
        exit(1);
2226
    }
2227
    if ((frame_rightBand % 2) != 0) {
2228
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2229
        exit(1);        
2230
    }
2231
    if ((frame_rightBand) >= frame_width){
2232
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2233
        exit(1);
2234
    }
2235
    frame_width -= frame_rightBand;
2236
}
2237

    
2238
static void opt_frame_size(const char *arg)
2239
{
2240
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2241
        fprintf(stderr, "Incorrect frame size\n");
2242
        exit(1);
2243
    }
2244
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2245
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2246
        exit(1);
2247
    }
2248
}
2249

    
2250

    
2251
#define SCALEBITS 10
2252
#define ONE_HALF  (1 << (SCALEBITS - 1))
2253
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
2254

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

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

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

    
2267
static void opt_pad_color(const char *arg) {
2268
    /* Input is expected to be six hex digits similar to
2269
       how colors are expressed in html tags (but without the #) */
2270
    int rgb = strtol(arg, NULL, 16);
2271
    int r,g,b;
2272
    
2273
    r = (rgb >> 16); 
2274
    g = ((rgb >> 8) & 255);
2275
    b = (rgb & 255);
2276

    
2277
    padcolor[0] = RGB_TO_Y(r,g,b);
2278
    padcolor[1] = RGB_TO_U(r,g,b,0);
2279
    padcolor[2] = RGB_TO_V(r,g,b,0);
2280
}
2281

    
2282
static void opt_frame_pad_top(const char *arg)
2283
{
2284
    frame_padtop = atoi(arg); 
2285
    if (frame_padtop < 0) {
2286
        fprintf(stderr, "Incorrect top pad size\n");
2287
        exit(1);
2288
    }
2289
    if ((frame_padtop % 2) != 0) {
2290
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2291
        exit(1);
2292
    }
2293
}
2294

    
2295
static void opt_frame_pad_bottom(const char *arg)
2296
{
2297
    frame_padbottom = atoi(arg); 
2298
    if (frame_padbottom < 0) {
2299
        fprintf(stderr, "Incorrect bottom pad size\n");
2300
        exit(1);
2301
    }
2302
    if ((frame_padbottom % 2) != 0) {
2303
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2304
        exit(1);
2305
    }
2306
}
2307

    
2308

    
2309
static void opt_frame_pad_left(const char *arg)
2310
{
2311
    frame_padleft = atoi(arg); 
2312
    if (frame_padleft < 0) {
2313
        fprintf(stderr, "Incorrect left pad size\n");
2314
        exit(1);
2315
    }
2316
    if ((frame_padleft % 2) != 0) {
2317
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2318
        exit(1);
2319
    }
2320
}
2321

    
2322

    
2323
static void opt_frame_pad_right(const char *arg)
2324
{
2325
    frame_padright = atoi(arg); 
2326
    if (frame_padright < 0) {
2327
        fprintf(stderr, "Incorrect right pad size\n");
2328
        exit(1);
2329
    }
2330
    if ((frame_padright % 2) != 0) {
2331
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2332
        exit(1);
2333
    }
2334
}
2335

    
2336

    
2337
static void opt_frame_pix_fmt(const char *arg)
2338
{
2339
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2340
}
2341

    
2342
static void opt_frame_aspect_ratio(const char *arg)
2343
{
2344
    int x = 0, y = 0;
2345
    double ar = 0;
2346
    const char *p;
2347
    
2348
    p = strchr(arg, ':');
2349
    if (p) {
2350
        x = strtol(arg, (char **)&arg, 10);
2351
        if (arg == p)
2352
            y = strtol(arg+1, (char **)&arg, 10);
2353
        if (x > 0 && y > 0)
2354
            ar = (double)x / (double)y;
2355
    } else
2356
        ar = strtod(arg, (char **)&arg);
2357

    
2358
    if (!ar) {
2359
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2360
        exit(1);
2361
    }
2362
    frame_aspect_ratio = ar;
2363
}
2364

    
2365
static void opt_gop_size(const char *arg)
2366
{
2367
    gop_size = atoi(arg);
2368
}
2369

    
2370
static void opt_b_frames(const char *arg)
2371
{
2372
    b_frames = atoi(arg);
2373
    if (b_frames > FF_MAX_B_FRAMES) {
2374
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2375
        exit(1);
2376
    } else if (b_frames < 1) {
2377
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2378
        exit(1);
2379
    }
2380
}
2381

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

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

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

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

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

    
2407
static void opt_pre_cmp(const char *arg)
2408
{
2409
    pre_cmp = atoi(arg);
2410
}
2411

    
2412
static void opt_pre_me(const char *arg)
2413
{
2414
    pre_me = atoi(arg);
2415
}
2416

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

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

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

    
2432
static void opt_tcplx_mask(const char *arg)
2433
{
2434
    tcplx_mask = atof(arg);
2435
}
2436

    
2437
static void opt_p_mask(const char *arg)
2438
{
2439
    p_mask = atof(arg);
2440
}
2441

    
2442
static void opt_qscale(const char *arg)
2443
{
2444
    video_qscale = atof(arg);
2445
    if (video_qscale < 0.01 ||
2446
        video_qscale > 255) {
2447
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2448
        exit(1);
2449
    }
2450
}
2451

    
2452
static void opt_qsquish(const char *arg)
2453
{
2454
    video_qsquish = atof(arg);
2455
    if (video_qsquish < 0.0 ||
2456
        video_qsquish > 99.0) {
2457
        fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2458
        exit(1);
2459
    }
2460
}
2461

    
2462
static void opt_lelim(const char *arg)
2463
{
2464
    video_lelim = atoi(arg);
2465
    if (video_lelim < -99 ||
2466
        video_lelim > 99) {
2467
        fprintf(stderr, "lelim must be >= -99 and <= 99\n");
2468
        exit(1);
2469
    }
2470
}
2471

    
2472
static void opt_celim(const char *arg)
2473
{
2474
    video_celim = atoi(arg);
2475
    if (video_celim < -99 ||
2476
        video_celim > 99) {
2477
        fprintf(stderr, "celim must be >= -99 and <= 99\n");
2478
        exit(1);
2479
    }
2480
}
2481

    
2482
static void opt_lmax(const char *arg)
2483
{
2484
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2485
}
2486

    
2487
static void opt_lmin(const char *arg)
2488
{
2489
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2490
}
2491

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

    
2502
static void opt_qmax(const char *arg)
2503
{
2504
    video_qmax = atoi(arg);
2505
    if (video_qmax < 1 ||
2506
        video_qmax > 31) {
2507
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2508
        exit(1);
2509
    }
2510
}
2511

    
2512
static void opt_mb_lmin(const char *arg)
2513
{
2514
    video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2515
    if (video_mb_lmin < 1 ||
2516
        video_mb_lmin > FF_LAMBDA_MAX) {
2517
        fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2518
        exit(1);
2519
    }
2520
}
2521

    
2522
static void opt_mb_lmax(const char *arg)
2523
{
2524
    video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2525
    if (video_mb_lmax < 1 ||
2526
        video_mb_lmax > FF_LAMBDA_MAX) {
2527
        fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2528
        exit(1);
2529
    }
2530
}
2531

    
2532
static void opt_qdiff(const char *arg)
2533
{
2534
    video_qdiff = atoi(arg);
2535
    if (video_qdiff < 0 ||
2536
        video_qdiff > 31) {
2537
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2538
        exit(1);
2539
    }
2540
}
2541

    
2542
static void opt_qblur(const char *arg)
2543
{
2544
    video_qblur = atof(arg);
2545
}
2546

    
2547
static void opt_qcomp(const char *arg)
2548
{
2549
    video_qcomp = atof(arg);
2550
}
2551

    
2552
static void opt_rc_initial_cplx(const char *arg)
2553
{
2554
    video_rc_initial_cplx = atof(arg);
2555
}
2556
static void opt_b_qfactor(const char *arg)
2557
{
2558
    video_b_qfactor = atof(arg);
2559
}
2560
static void opt_i_qfactor(const char *arg)
2561
{
2562
    video_i_qfactor = atof(arg);
2563
}
2564
static void opt_b_qoffset(const char *arg)
2565
{
2566
    video_b_qoffset = atof(arg);
2567
}
2568
static void opt_i_qoffset(const char *arg)
2569
{
2570
    video_i_qoffset = atof(arg);
2571
}
2572

    
2573
static void opt_ibias(const char *arg)
2574
{
2575
    video_intra_quant_bias = atoi(arg);
2576
}
2577
static void opt_pbias(const char *arg)
2578
{
2579
    video_inter_quant_bias = atoi(arg);
2580
}
2581

    
2582
static void opt_packet_size(const char *arg)
2583
{
2584
    packet_size= atoi(arg);
2585
}
2586

    
2587
static void opt_error_rate(const char *arg)
2588
{
2589
    error_rate= atoi(arg);
2590
}
2591

    
2592
static void opt_strict(const char *arg)
2593
{
2594
    strict= atoi(arg);
2595
}
2596

    
2597
static void opt_top_field_first(const char *arg)
2598
{
2599
    top_field_first= atoi(arg);
2600
}
2601

    
2602
static void opt_noise_reduction(const char *arg)
2603
{
2604
    noise_reduction= atoi(arg);
2605
}
2606

    
2607
static void opt_qns(const char *arg)
2608
{
2609
    qns= atoi(arg);
2610
}
2611

    
2612
static void opt_sc_threshold(const char *arg)
2613
{
2614
    sc_threshold= atoi(arg);
2615
}
2616

    
2617
static void opt_me_range(const char *arg)
2618
{
2619
    me_range = atoi(arg);
2620
}
2621

    
2622
static void opt_thread_count(const char *arg)
2623
{
2624
    thread_count= atoi(arg);
2625
#if !defined(HAVE_THREADS)
2626
    if (verbose >= 0)
2627
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2628
#endif
2629
}
2630

    
2631
static void opt_audio_bitrate(const char *arg)
2632
{
2633
    audio_bit_rate = atoi(arg) * 1000;
2634
}
2635

    
2636
static void opt_audio_rate(const char *arg)
2637
{
2638
    audio_sample_rate = atoi(arg);
2639
}
2640

    
2641
static void opt_audio_channels(const char *arg)
2642
{
2643
    audio_channels = atoi(arg);
2644
}
2645

    
2646
static void opt_video_device(const char *arg)
2647
{
2648
    video_device = av_strdup(arg);
2649
}
2650

    
2651
static void opt_grab_device(const char *arg)
2652
{
2653
    grab_device = av_strdup(arg);
2654
}
2655

    
2656
static void opt_video_channel(const char *arg)
2657
{
2658
    video_channel = strtol(arg, NULL, 0);
2659
}
2660

    
2661
static void opt_video_standard(const char *arg)
2662
{
2663
    video_standard = av_strdup(arg);
2664
}
2665

    
2666
static void opt_audio_device(const char *arg)
2667
{
2668
    audio_device = av_strdup(arg);
2669
}
2670

    
2671
static void opt_audio_codec(const char *arg)
2672
{
2673
    AVCodec *p;
2674

    
2675
    if (!strcmp(arg, "copy")) {
2676
        audio_stream_copy = 1;
2677
    } else {
2678
        p = first_avcodec;
2679
        while (p) {
2680
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2681
                break;
2682
            p = p->next;
2683
        }
2684
        if (p == NULL) {
2685
            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2686
            exit(1);
2687
        } else {
2688
            audio_codec_id = p->id;
2689
        }
2690
    }
2691
}
2692

    
2693
static void opt_audio_tag(const char *arg)
2694
{
2695
    char *tail;
2696
    audio_codec_tag= strtol(arg, &tail, 0);
2697

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

    
2702
static void opt_video_tag(const char *arg)
2703
{
2704
    char *tail;
2705
    video_codec_tag= strtol(arg, &tail, 0);
2706

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

    
2711
static void add_frame_hooker(const char *arg)
2712
{
2713
    int argc = 0;
2714
    char *argv[64];
2715
    int i;
2716
    char *args = av_strdup(arg);
2717

    
2718
    using_vhook = 1;
2719

    
2720
    argv[0] = strtok(args, " ");
2721
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2722
    }
2723

    
2724
    i = frame_hook_add(argc, argv);
2725

    
2726
    if (i != 0) {
2727
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2728
        exit(1);
2729
    }
2730
}
2731

    
2732
const char *motion_str[] = {
2733
    "zero",
2734
    "full",
2735
    "log",
2736
    "phods",
2737
    "epzs",
2738
    "x1",
2739
    NULL,
2740
};
2741

    
2742
static void opt_motion_estimation(const char *arg)
2743
{
2744
    const char **p;
2745
    p = motion_str;
2746
    for(;;) {
2747
        if (!*p) {
2748
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2749
            exit(1);
2750
        }
2751
        if (!strcmp(*p, arg))
2752
            break;
2753
        p++;
2754
    }
2755
    me_method = (p - motion_str) + 1;
2756
}
2757

    
2758
static void opt_video_codec(const char *arg)
2759
{
2760
    AVCodec *p;
2761

    
2762
    if (!strcmp(arg, "copy")) {
2763
        video_stream_copy = 1;
2764
    } else {
2765
        p = first_avcodec;
2766
        while (p) {
2767
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2768
                break;
2769
            p = p->next;
2770
        }
2771
        if (p == NULL) {
2772
            fprintf(stderr, "Unknown video codec '%s'\n", arg);
2773
            exit(1);
2774
        } else {
2775
            video_codec_id = p->id;
2776
        }
2777
    }
2778
}
2779

    
2780
static void opt_map(const char *arg)
2781
{
2782
    AVStreamMap *m;
2783
    const char *p;
2784

    
2785
    p = arg;
2786
    m = &stream_maps[nb_stream_maps++];
2787

    
2788
    m->file_index = strtol(arg, (char **)&p, 0);
2789
    if (*p)
2790
        p++;
2791

    
2792
    m->stream_index = strtol(p, (char **)&p, 0);
2793
}
2794

    
2795
static void opt_map_meta_data(const char *arg)
2796
{
2797
    AVMetaDataMap *m;
2798
    const char *p;
2799
        
2800
    p = arg;
2801
    m = &meta_data_maps[nb_meta_data_maps++];
2802

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

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

    
2810
static void opt_recording_time(const char *arg)
2811
{
2812
    recording_time = parse_date(arg, 1);
2813
}
2814

    
2815
static void opt_start_time(const char *arg)
2816
{
2817
    start_time = parse_date(arg, 1);
2818
}
2819

    
2820
static void opt_rec_timestamp(const char *arg)
2821
{
2822
    rec_timestamp = parse_date(arg, 0) / 1000000;
2823
}
2824

    
2825
static void opt_input_ts_offset(const char *arg)
2826
{
2827
    input_ts_offset = parse_date(arg, 1);
2828
}
2829

    
2830
static void opt_input_file(const char *filename)
2831
{
2832
    AVFormatContext *ic;
2833
    AVFormatParameters params, *ap = &params;
2834
    int err, i, ret, rfps, rfps_base;
2835
    int64_t timestamp;
2836

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

    
2840
    using_stdin |= !strncmp(filename, "pipe:", 5) || 
2841
                   !strcmp( filename, "/dev/stdin" );
2842

    
2843
    /* get default parameters from command line */
2844
    memset(ap, 0, sizeof(*ap));
2845
    ap->sample_rate = audio_sample_rate;
2846
    ap->channels = audio_channels;
2847
    ap->frame_rate = frame_rate;
2848
    ap->frame_rate_base = frame_rate_base;
2849
    ap->width = frame_width + frame_padleft + frame_padright;
2850
    ap->height = frame_height + frame_padtop + frame_padbottom;
2851
    ap->image_format = image_format;
2852
    ap->pix_fmt = frame_pix_fmt;
2853
    ap->device  = grab_device;
2854
    ap->channel = video_channel;
2855
    ap->standard = video_standard;
2856
    ap->video_codec_id = video_codec_id;
2857
    ap->audio_codec_id = audio_codec_id;
2858
    if(pgmyuv_compatibility_hack)
2859
        ap->video_codec_id= CODEC_ID_PGMYUV;
2860

    
2861
    /* open the input file with generic libav function */
2862
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2863
    if (err < 0) {
2864
        print_error(filename, err);
2865
        exit(1);
2866
    }
2867
    
2868
    /* If not enough info to get the stream parameters, we decode the
2869
       first frames to get it. (used in mpeg case for example) */
2870
    ret = av_find_stream_info(ic);
2871
    if (ret < 0 && verbose >= 0) {
2872
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2873
        exit(1);
2874
    }
2875

    
2876
    timestamp = start_time;
2877
    /* add the stream start time */
2878
    if (ic->start_time != AV_NOPTS_VALUE)
2879
        timestamp += ic->start_time;
2880

    
2881
    /* if seeking requested, we execute it */
2882
    if (start_time != 0) {
2883
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2884
        if (ret < 0) {
2885
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
2886
                    filename, (double)timestamp / AV_TIME_BASE);
2887
        }
2888
        /* reset seek info */
2889
        start_time = 0;
2890
    }
2891

    
2892
    /* update the current parameters so that they match the one of the input stream */
2893
    for(i=0;i<ic->nb_streams;i++) {
2894
        AVCodecContext *enc = &ic->streams[i]->codec;
2895
#if defined(HAVE_THREADS)
2896
        if(thread_count>1)
2897
            avcodec_thread_init(enc, thread_count);
2898
#endif
2899
        enc->thread_count= thread_count;
2900
        switch(enc->codec_type) {
2901
        case CODEC_TYPE_AUDIO:
2902
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2903
            audio_channels = enc->channels;
2904
            audio_sample_rate = enc->sample_rate;
2905
            if(audio_disable)
2906
                ic->streams[i]->discard= AVDISCARD_ALL;
2907
            break;
2908
        case CODEC_TYPE_VIDEO:
2909
            frame_height = enc->height;
2910
            frame_width = enc->width;
2911
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2912
            frame_pix_fmt = enc->pix_fmt;
2913
            rfps      = ic->streams[i]->r_frame_rate;
2914
            rfps_base = ic->streams[i]->r_frame_rate_base;
2915
            enc->workaround_bugs = workaround_bugs;
2916
            enc->error_resilience = error_resilience; 
2917
            enc->error_concealment = error_concealment; 
2918
            enc->idct_algo = idct_algo;
2919
            enc->debug = debug;
2920
            enc->debug_mv = debug_mv;            
2921
            enc->lowres= lowres;
2922
            if(bitexact)
2923
                enc->flags|= CODEC_FLAG_BITEXACT;
2924
            if(me_threshold)
2925
                enc->debug |= FF_DEBUG_MV;
2926

    
2927
            if (enc->frame_rate != rfps || enc->frame_rate_base != rfps_base) { 
2928

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

    
2933
                    (float)rfps / rfps_base, rfps, rfps_base);
2934
            }
2935
            /* update the current frame rate to match the stream frame rate */
2936
            frame_rate      = rfps;
2937
            frame_rate_base = rfps_base;
2938

    
2939
            enc->rate_emu = rate_emu;
2940
            if(video_disable)
2941
                ic->streams[i]->discard= AVDISCARD_ALL;
2942
            else if(video_discard)
2943
                ic->streams[i]->discard= video_discard;
2944
            break;
2945
        case CODEC_TYPE_DATA:
2946
            break;
2947
        default:
2948
            av_abort();
2949
        }
2950
    }
2951
    
2952
    input_files[nb_input_files] = ic;
2953
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2954
    /* dump the file content */
2955
    if (verbose >= 0)
2956
        dump_format(ic, nb_input_files, filename, 0);
2957

    
2958
    nb_input_files++;
2959
    file_iformat = NULL;
2960
    file_oformat = NULL;
2961
    image_format = NULL;
2962

    
2963
    grab_device = NULL;
2964
    video_channel = 0;
2965
    
2966
    rate_emu = 0;
2967
}
2968

    
2969
static void opt_grab(const char *arg)
2970
{
2971
    file_iformat = av_find_input_format(arg);
2972
    opt_input_file("");
2973
}
2974

    
2975
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2976
{
2977
    int has_video, has_audio, i, j;
2978
    AVFormatContext *ic;
2979

    
2980
    has_video = 0;
2981
    has_audio = 0;
2982
    for(j=0;j<nb_input_files;j++) {
2983
        ic = input_files[j];
2984
        for(i=0;i<ic->nb_streams;i++) {
2985
            AVCodecContext *enc = &ic->streams[i]->codec;
2986
            switch(enc->codec_type) {
2987
            case CODEC_TYPE_AUDIO:
2988
                has_audio = 1;
2989
                break;
2990
            case CODEC_TYPE_VIDEO:
2991
                has_video = 1;
2992
                break;
2993
            case CODEC_TYPE_DATA:
2994
                break;
2995
            default:
2996
                av_abort();
2997
            }
2998
        }
2999
    }
3000
    *has_video_ptr = has_video;
3001
    *has_audio_ptr = has_audio;
3002
}
3003

    
3004
static void opt_output_file(const char *filename)
3005
{
3006
    AVStream *st;
3007
    AVFormatContext *oc;
3008
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
3009
    int codec_id;
3010
    AVFormatParameters params, *ap = &params;
3011

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

    
3015
    oc = av_alloc_format_context();
3016

    
3017
    if (!file_oformat) {
3018
        file_oformat = guess_format(NULL, filename, NULL);
3019
        if (!file_oformat) {
3020
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3021
                    filename);
3022
            exit(1);
3023
        }
3024
    }
3025
    
3026
    oc->oformat = file_oformat;
3027

    
3028
    if (!strcmp(file_oformat->name, "ffm") && 
3029
        strstart(filename, "http:", NULL)) {
3030
        /* special case for files sent to ffserver: we get the stream
3031
           parameters from ffserver */
3032
        if (read_ffserver_streams(oc, filename) < 0) {
3033
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3034
            exit(1);
3035
        }
3036
    } else {
3037
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
3038
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
3039

    
3040
        /* disable if no corresponding type found and at least one
3041
           input file */
3042
        if (nb_input_files > 0) {
3043
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3044
            if (!input_has_video)
3045
                use_video = 0;
3046
            if (!input_has_audio)
3047
                use_audio = 0;
3048
        }
3049

    
3050
        /* manual disable */
3051
        if (audio_disable) {
3052
            use_audio = 0;
3053
        }
3054
        if (video_disable) {
3055
            use_video = 0;
3056
        }
3057
        
3058
        nb_streams = 0;
3059
        if (use_video) {
3060
            AVCodecContext *video_enc;
3061
            
3062
            st = av_new_stream(oc, nb_streams++);
3063
            if (!st) {
3064
                fprintf(stderr, "Could not alloc stream\n");
3065
                exit(1);
3066
            }
3067
#if defined(HAVE_THREADS)
3068
            if(thread_count>1)
3069
                avcodec_thread_init(&st->codec, thread_count);
3070
#endif
3071

    
3072
            video_enc = &st->codec;
3073
            
3074
            if(video_codec_tag)
3075
                video_enc->codec_tag= video_codec_tag;
3076
                
3077
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3078
                video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3079
            if (video_stream_copy) {
3080
                st->stream_copy = 1;
3081
                video_enc->codec_type = CODEC_TYPE_VIDEO;
3082
            } else {
3083
                char *p;
3084
                int i;
3085
                AVCodec *codec;
3086
            
3087
                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
3088
                if (video_codec_id != CODEC_ID_NONE)
3089
                    codec_id = video_codec_id;
3090
                
3091
                video_enc->codec_id = codec_id;
3092
                codec = avcodec_find_encoder(codec_id);
3093
                
3094
                video_enc->bit_rate = video_bit_rate;
3095
                video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3096
                video_enc->frame_rate = frame_rate; 
3097
                video_enc->frame_rate_base = frame_rate_base; 
3098
                if(codec && codec->supported_framerates){
3099
                    const AVRational *p= codec->supported_framerates;
3100
                    AVRational req= (AVRational){frame_rate, frame_rate_base};
3101
                    const AVRational *best=NULL;
3102
                    AVRational best_error= (AVRational){INT_MAX, 1};
3103
                    for(; p->den!=0; p++){
3104
                        AVRational error= av_sub_q(req, *p);
3105
                        if(error.num <0) error.num *= -1;
3106
                        if(av_cmp_q(error, best_error) < 0){
3107
                            best_error= error;
3108
                            best= p;
3109
                        }
3110
                    }
3111
                    video_enc->frame_rate     = best->num;
3112
                    video_enc->frame_rate_base= best->den;
3113
                }
3114
                
3115
                video_enc->width = frame_width + frame_padright + frame_padleft;
3116
                video_enc->height = frame_height + frame_padtop + frame_padbottom;
3117
                video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3118
                video_enc->pix_fmt = frame_pix_fmt;
3119

    
3120
                if(codec && codec->pix_fmts){
3121
                    const enum PixelFormat *p= codec->pix_fmts;
3122
                    for(; *p!=-1; p++){
3123
                        if(*p == video_enc->pix_fmt)
3124
                            break;
3125
                    }
3126
                    if(*p == -1)
3127
                        video_enc->pix_fmt = codec->pix_fmts[0];
3128
                }
3129

    
3130
                if (!intra_only)
3131
                    video_enc->gop_size = gop_size;
3132
                else
3133
                    video_enc->gop_size = 0;
3134
                if (video_qscale || same_quality) {
3135
                    video_enc->flags |= CODEC_FLAG_QSCALE;
3136
                    video_enc->global_quality= 
3137
                    st->quality = FF_QP2LAMBDA * video_qscale;
3138
                }
3139

    
3140
                if(intra_matrix)
3141
                    video_enc->intra_matrix = intra_matrix;
3142
                if(inter_matrix)
3143
                    video_enc->inter_matrix = inter_matrix;
3144

    
3145
                if(bitexact)
3146
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
3147

    
3148
                video_enc->mb_decision = mb_decision;
3149
                video_enc->mb_cmp = mb_cmp;
3150
                video_enc->ildct_cmp = ildct_cmp;
3151
                video_enc->me_sub_cmp = sub_cmp;
3152
                video_enc->me_cmp = cmp;
3153
                video_enc->me_pre_cmp = pre_cmp;
3154
                video_enc->pre_me = pre_me;
3155
                video_enc->lumi_masking = lumi_mask;
3156
                video_enc->dark_masking = dark_mask;
3157
                video_enc->spatial_cplx_masking = scplx_mask;
3158
                video_enc->temporal_cplx_masking = tcplx_mask;
3159
                video_enc->p_masking = p_mask;
3160
                video_enc->quantizer_noise_shaping= qns;
3161
                
3162
                if (use_umv) {
3163
                    video_enc->flags |= CODEC_FLAG_H263P_UMV;
3164
                }
3165
                if (use_ss) {
3166
                    video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3167
                }
3168
                   if (use_aic) {
3169
                    video_enc->flags |= CODEC_FLAG_H263P_AIC;
3170
                }
3171
                   if (use_aiv) {
3172
                    video_enc->flags |= CODEC_FLAG_H263P_AIV;
3173
                }
3174
                if (use_4mv) {
3175
                    video_enc->flags |= CODEC_FLAG_4MV;
3176
                }
3177
                if (use_obmc) {
3178
                    video_enc->flags |= CODEC_FLAG_OBMC;
3179
                }
3180
                if (use_loop) {
3181
                    video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3182
                }
3183
            
3184
                if(use_part) {
3185
                    video_enc->flags |= CODEC_FLAG_PART;
3186
                }
3187
                   if (use_alt_scan) {
3188
                    video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3189
                }
3190
                   if (use_trell) {
3191
                    video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3192
                }
3193
                   if (use_mv0) {
3194
                    video_enc->flags |= CODEC_FLAG_MV0;
3195
                }
3196
                   if (do_normalize_aqp) {
3197
                    video_enc->flags |= CODEC_FLAG_NORMALIZE_AQP;
3198
                }
3199
                   if (use_scan_offset) {
3200
                    video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3201
                }
3202
                   if (closed_gop) {
3203
                    video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3204
                }
3205
                if (strict_gop) {
3206
                    video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3207
                }
3208
                   if (use_qpel) {
3209
                    video_enc->flags |= CODEC_FLAG_QPEL;
3210
                }
3211
                   if (use_qprd) {
3212
                    video_enc->flags |= CODEC_FLAG_QP_RD;
3213
                }
3214
                   if (use_cbprd) {
3215
                    video_enc->flags |= CODEC_FLAG_CBP_RD;
3216
                }
3217
                if (b_frames) {
3218
                    video_enc->max_b_frames = b_frames;
3219
                    video_enc->b_frame_strategy = 0;
3220
                    video_enc->b_quant_factor = 2.0;
3221
                }
3222
                if (do_interlace_dct) {
3223
                    video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3224
                }
3225
                if (do_interlace_me) {
3226
                    video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3227
                }
3228
                if (no_output) {
3229
                    video_enc->flags2 |= CODEC_FLAG2_NO_OUTPUT;
3230
                }
3231
                video_enc->qmin = video_qmin;
3232
                video_enc->qmax = video_qmax;
3233
                video_enc->lmin = video_lmin;
3234
                video_enc->lmax = video_lmax;
3235
                video_enc->rc_qsquish = video_qsquish;
3236
                video_enc->luma_elim_threshold = video_lelim;
3237
                video_enc->chroma_elim_threshold = video_celim;
3238
                video_enc->mb_lmin = video_mb_lmin;
3239
                video_enc->mb_lmax = video_mb_lmax;
3240
                video_enc->max_qdiff = video_qdiff;
3241
                video_enc->qblur = video_qblur;
3242
                video_enc->qcompress = video_qcomp;
3243
                video_enc->rc_eq = video_rc_eq;
3244
                video_enc->debug = debug;
3245
                video_enc->debug_mv = debug_mv;
3246
                video_enc->thread_count = thread_count;
3247
                p= video_rc_override_string;
3248
                for(i=0; p; i++){
3249
                    int start, end, q;
3250
                    int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3251
                    if(e!=3){
3252
                        fprintf(stderr, "error parsing rc_override\n");
3253
                        exit(1);
3254
                    }
3255
                    video_enc->rc_override= 
3256
                        av_realloc(video_enc->rc_override, 
3257
                                   sizeof(RcOverride)*(i+1));
3258
                    video_enc->rc_override[i].start_frame= start;
3259
                    video_enc->rc_override[i].end_frame  = end;
3260
                    if(q>0){
3261
                        video_enc->rc_override[i].qscale= q;
3262
                        video_enc->rc_override[i].quality_factor= 1.0;
3263
                    }
3264
                    else{
3265
                        video_enc->rc_override[i].qscale= 0;
3266
                        video_enc->rc_override[i].quality_factor= -q/100.0;
3267
                    }
3268
                    p= strchr(p, '/');
3269
                    if(p) p++;
3270
                }
3271
                video_enc->rc_override_count=i;
3272

    
3273
                video_enc->rc_max_rate = video_rc_max_rate;
3274
                video_enc->rc_min_rate = video_rc_min_rate;
3275
                video_enc->rc_buffer_size = video_rc_buffer_size;
3276
                video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3277
                video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3278
                video_enc->rc_initial_cplx= video_rc_initial_cplx;
3279
                video_enc->i_quant_factor = video_i_qfactor;
3280
                video_enc->b_quant_factor = video_b_qfactor;
3281
                video_enc->i_quant_offset = video_i_qoffset;
3282
                video_enc->b_quant_offset = video_b_qoffset;
3283
                video_enc->intra_quant_bias = video_intra_quant_bias;
3284
                video_enc->inter_quant_bias = video_inter_quant_bias;
3285
                video_enc->dct_algo = dct_algo;
3286
                video_enc->idct_algo = idct_algo;
3287
                video_enc->me_threshold= me_threshold;
3288
                video_enc->mb_threshold= mb_threshold;
3289
                video_enc->intra_dc_precision= intra_dc_precision - 8;
3290
                video_enc->strict_std_compliance = strict;
3291
                video_enc->error_rate = error_rate;
3292
                video_enc->noise_reduction= noise_reduction;
3293
                video_enc->scenechange_threshold= sc_threshold;
3294
                video_enc->me_range = me_range;
3295
                video_enc->coder_type= coder;
3296
                video_enc->context_model= context;
3297
                video_enc->prediction_method= predictor;
3298
                video_enc->profile= video_profile;
3299
                video_enc->level= video_level;
3300
                video_enc->nsse_weight= nsse_weight;
3301
                video_enc->me_subpel_quality= subpel_quality;
3302
                video_enc->frame_skip_threshold= frame_skip_threshold;
3303
                video_enc->frame_skip_factor= frame_skip_factor;
3304
                video_enc->frame_skip_exp= frame_skip_exp;
3305
                video_enc->frame_skip_cmp= frame_skip_cmp;
3306

    
3307
                if(packet_size){
3308
                    video_enc->rtp_mode= 1;
3309
                    video_enc->rtp_payload_size= packet_size;
3310
                }
3311
            
3312
                if (do_psnr)
3313
                    video_enc->flags|= CODEC_FLAG_PSNR;
3314
            
3315
                video_enc->me_method = me_method;
3316

    
3317
                /* two pass mode */
3318
                if (do_pass) {
3319
                    if (do_pass == 1) {
3320
                        video_enc->flags |= CODEC_FLAG_PASS1;
3321
                    } else {
3322
                        video_enc->flags |= CODEC_FLAG_PASS2;
3323
                    }
3324
                }
3325
            }
3326
        }
3327
    
3328
        if (use_audio) {
3329
            AVCodecContext *audio_enc;
3330

    
3331
            st = av_new_stream(oc, nb_streams++);
3332
            if (!st) {
3333
                fprintf(stderr, "Could not alloc stream\n");
3334
                exit(1);
3335
            }
3336
#if defined(HAVE_THREADS)
3337
            if(thread_count>1)
3338
                avcodec_thread_init(&st->codec, thread_count);
3339
#endif
3340

    
3341
            audio_enc = &st->codec;
3342
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3343

    
3344
            if(audio_codec_tag)
3345
                audio_enc->codec_tag= audio_codec_tag;
3346

    
3347
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3348
                audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3349
            if (audio_stream_copy) {
3350
                st->stream_copy = 1;
3351
                audio_enc->channels = audio_channels;
3352
            } else {
3353
                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
3354
                if (audio_codec_id != CODEC_ID_NONE)
3355
                    codec_id = audio_codec_id;
3356
                audio_enc->codec_id = codec_id;
3357
                
3358
                audio_enc->bit_rate = audio_bit_rate;
3359
                audio_enc->strict_std_compliance = strict;
3360
                audio_enc->thread_count = thread_count;
3361
                /* For audio codecs other than AC3 or DTS we limit */
3362
                /* the number of coded channels to stereo   */
3363
                if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3364
                    && codec_id != CODEC_ID_DTS) {
3365
                    audio_enc->channels = 2;
3366
                } else
3367
                    audio_enc->channels = audio_channels;
3368
            }
3369
            audio_enc->sample_rate = audio_sample_rate;
3370
        }
3371

    
3372
        oc->nb_streams = nb_streams;
3373

    
3374
        if (!nb_streams) {
3375
            fprintf(stderr, "No audio or video streams available\n");
3376
            exit(1);
3377
        }
3378

    
3379
        oc->timestamp = rec_timestamp;
3380
            
3381
        if (str_title)
3382
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3383
        if (str_author)
3384
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3385
        if (str_copyright)
3386
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3387
        if (str_comment)
3388
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3389
    }
3390

    
3391
    output_files[nb_output_files++] = oc;
3392

    
3393
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3394

    
3395
    /* check filename in case of an image number is expected */
3396
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3397
        if (filename_number_test(oc->filename) < 0) {
3398
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3399
            exit(1);
3400
        }
3401
    }
3402

    
3403
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3404
        /* test if it already exists to avoid loosing precious files */
3405
        if (!file_overwrite && 
3406
            (strchr(filename, ':') == NULL ||
3407
             strstart(filename, "file:", NULL))) {
3408
            if (url_exist(filename)) {
3409
                int c;
3410
                
3411
                if ( !using_stdin ) {
3412
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3413
                    fflush(stderr);
3414
                    c = getchar();
3415
                    if (toupper(c) != 'Y') {
3416
                        fprintf(stderr, "Not overwriting - exiting\n");
3417
                        exit(1);
3418
                    }
3419
                                }
3420
                                else {
3421
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3422
                    exit(1);
3423
                                }
3424
            }
3425
        }
3426
        
3427
        /* open the file */
3428
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3429
            fprintf(stderr, "Could not open '%s'\n", filename);
3430
            exit(1);
3431
        }
3432
    }
3433

    
3434
    memset(ap, 0, sizeof(*ap));
3435
    ap->image_format = image_format;
3436
    if (av_set_parameters(oc, ap) < 0) {
3437
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3438
                oc->filename);
3439
        exit(1);
3440
    }
3441

    
3442
    oc->packet_size= mux_packet_size;
3443
    oc->mux_rate= mux_rate;
3444
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3445
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3446

    
3447
    /* reset some options */
3448
    file_oformat = NULL;
3449
    file_iformat = NULL;
3450
    image_format = NULL;
3451
    audio_disable = 0;
3452
    video_disable = 0;
3453
    audio_codec_id = CODEC_ID_NONE;
3454
    video_codec_id = CODEC_ID_NONE;
3455
    audio_stream_copy = 0;
3456
    video_stream_copy = 0;
3457
}
3458

    
3459
/* prepare dummy protocols for grab */
3460
static void prepare_grab(void)
3461
{
3462
    int has_video, has_audio, i, j;
3463
    AVFormatContext *oc;
3464
    AVFormatContext *ic;
3465
    AVFormatParameters vp1, *vp = &vp1;
3466
    AVFormatParameters ap1, *ap = &ap1;
3467
    
3468
    /* see if audio/video inputs are needed */
3469
    has_video = 0;
3470
    has_audio = 0;
3471
    memset(ap, 0, sizeof(*ap));
3472
    memset(vp, 0, sizeof(*vp));
3473
    vp->frame_rate_base= 1;
3474
    for(j=0;j<nb_output_files;j++) {
3475
        oc = output_files[j];
3476
        for(i=0;i<oc->nb_streams;i++) {
3477
            AVCodecContext *enc = &oc->streams[i]->codec;
3478
            switch(enc->codec_type) {
3479
            case CODEC_TYPE_AUDIO:
3480
                if (enc->sample_rate > ap->sample_rate)
3481
                    ap->sample_rate = enc->sample_rate;
3482
                if (enc->channels > ap->channels)
3483
                    ap->channels = enc->channels;
3484
                has_audio = 1;
3485
                break;
3486
            case CODEC_TYPE_VIDEO:
3487
                if (enc->width > vp->width)
3488
                    vp->width = enc->width;
3489
                if (enc->height > vp->height)
3490
                    vp->height = enc->height;
3491
                
3492
                if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3493
                    vp->frame_rate      = enc->frame_rate;
3494
                    vp->frame_rate_base = enc->frame_rate_base;
3495
                }
3496
                has_video = 1;
3497
                break;
3498
            default:
3499
                av_abort();
3500
            }
3501
        }
3502
    }
3503
    
3504
    if (has_video == 0 && has_audio == 0) {
3505
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3506
        exit(1);
3507
    }
3508
    
3509
    if (has_video) {
3510
        AVInputFormat *fmt1;
3511
        fmt1 = av_find_input_format(video_grab_format);
3512
        vp->device  = video_device;
3513
        vp->channel = video_channel;
3514
        vp->standard = video_standard;
3515
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3516
            fprintf(stderr, "Could not find video grab device\n");
3517
            exit(1);
3518
        }
3519
        /* If not enough info to get the stream parameters, we decode the
3520
           first frames to get it. */
3521
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3522
            fprintf(stderr, "Could not find video grab parameters\n");
3523
            exit(1);
3524
        }
3525
        /* by now video grab has one stream */
3526
        ic->streams[0]->r_frame_rate      = vp->frame_rate;
3527
        ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3528
        input_files[nb_input_files] = ic;
3529

    
3530
        if (verbose >= 0)
3531
            dump_format(ic, nb_input_files, "", 0);
3532

    
3533
        nb_input_files++;
3534
    }
3535
    if (has_audio && audio_grab_format) {
3536
        AVInputFormat *fmt1;
3537
        fmt1 = av_find_input_format(audio_grab_format);
3538
        ap->device = audio_device;
3539
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3540
            fprintf(stderr, "Could not find audio grab device\n");
3541
            exit(1);
3542
        }
3543
        input_files[nb_input_files] = ic;
3544

    
3545
        if (verbose >= 0)
3546
            dump_format(ic, nb_input_files, "", 0);
3547

    
3548
        nb_input_files++;
3549
    }
3550
}
3551

    
3552
/* same option as mencoder */
3553
static void opt_pass(const char *pass_str)
3554
{
3555
    int pass;
3556
    pass = atoi(pass_str);
3557
    if (pass != 1 && pass != 2) {
3558
        fprintf(stderr, "pass number can be only 1 or 2\n");
3559
        exit(1);
3560
    }
3561
    do_pass = pass;
3562
}
3563

    
3564
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3565
static int64_t getutime(void)
3566
{
3567
  return av_gettime();
3568
}
3569
#else
3570
static int64_t getutime(void)
3571
{
3572
    struct rusage rusage;
3573

    
3574
    getrusage(RUSAGE_SELF, &rusage);
3575
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3576
}
3577
#endif
3578

    
3579
extern int ffm_nopts;
3580

    
3581
static void opt_bitexact(void)
3582
{
3583
    bitexact=1;
3584
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3585
    ffm_nopts = 1;
3586
}
3587

    
3588
static void show_formats(void)
3589
{
3590
    AVInputFormat *ifmt;
3591
    AVOutputFormat *ofmt;
3592
    AVImageFormat *image_fmt;
3593
    URLProtocol *up;
3594
    AVCodec *p, *p2;
3595
    const char **pp, *last_name;
3596

    
3597
    printf("File formats:\n");
3598
    last_name= "000";
3599
    for(;;){
3600
        int decode=0;
3601
        int encode=0;
3602
        const char *name=NULL;
3603
        const char *long_name=NULL;
3604

    
3605
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3606
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3607
                strcmp(ofmt->name, last_name)>0){
3608
                name= ofmt->name;
3609
                long_name= ofmt->long_name;
3610
                encode=1;
3611
            }
3612
        }
3613
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3614
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3615
                strcmp(ifmt->name, last_name)>0){
3616
                name= ifmt->name;
3617
                long_name= ifmt->long_name;
3618
                encode=0;
3619
            }
3620
            if(name && strcmp(ifmt->name, name)==0)
3621
                decode=1;
3622
        }
3623
        if(name==NULL)
3624
            break;
3625
        last_name= name;
3626
        
3627
        printf(
3628
            " %s%s %-15s %s\n", 
3629
            decode ? "D":" ", 
3630
            encode ? "E":" ", 
3631
            name,
3632
            long_name ? long_name:" ");
3633
    }
3634
    printf("\n");
3635

    
3636
    printf("Image formats (filename extensions, if any, follow):\n");
3637
    for(image_fmt = first_image_format; image_fmt != NULL; 
3638
        image_fmt = image_fmt->next) {
3639
        printf(
3640
            " %s%s %-6s %s\n",
3641
            image_fmt->img_read  ? "D":" ",
3642
            image_fmt->img_write ? "E":" ",
3643
            image_fmt->name,
3644
            image_fmt->extensions ? image_fmt->extensions:" ");
3645
    }
3646
    printf("\n");
3647

    
3648
    printf("Codecs:\n");
3649
    last_name= "000";
3650
    for(;;){
3651
        int decode=0;
3652
        int encode=0;
3653
        int cap=0;
3654

    
3655
        p2=NULL;
3656
        for(p = first_avcodec; p != NULL; p = p->next) {
3657
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3658
                strcmp(p->name, last_name)>0){
3659
                p2= p;
3660
                decode= encode= cap=0;
3661
            }
3662
            if(p2 && strcmp(p->name, p2->name)==0){
3663
                if(p->decode) decode=1;
3664
                if(p->encode) encode=1;
3665
                cap |= p->capabilities;
3666
            }
3667
        }
3668
        if(p2==NULL)
3669
            break;
3670
        last_name= p2->name;
3671
        
3672
        printf(
3673
            " %s%s%s%s%s%s %s", 
3674
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
3675
            encode ? "E":" ", 
3676
            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3677
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3678
            cap & CODEC_CAP_DR1 ? "D":" ",
3679
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3680
            p2->name);
3681
       /* if(p2->decoder && decode==0)
3682
            printf(" use %s for decoding", p2->decoder->name);*/
3683
        printf("\n");
3684
    }
3685
    printf("\n");
3686

    
3687
    printf("Supported file protocols:\n");
3688
    for(up = first_protocol; up != NULL; up = up->next)
3689
        printf(" %s:", up->name);
3690
    printf("\n");
3691
    
3692
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3693
    printf("Motion estimation methods:\n");
3694
    pp = motion_str;
3695
    while (*pp) {
3696
        printf(" %s", *pp);
3697
        if ((pp - motion_str + 1) == ME_ZERO) 
3698
            printf("(fastest)");
3699
        else if ((pp - motion_str + 1) == ME_FULL) 
3700
            printf("(slowest)");
3701
        else if ((pp - motion_str + 1) == ME_EPZS) 
3702
            printf("(default)");
3703
        pp++;
3704
    }
3705
    printf("\n\n");
3706
    printf(
3707
"Note, the names of encoders and decoders dont always match, so there are\n"
3708
"several cases where the above table shows encoder only or decoder only entries\n"
3709
"even though both encoding and decoding are supported for example, the h263\n"
3710
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3711
"worse\n");
3712
    exit(1);
3713
}
3714

    
3715
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3716
{
3717
    int i;
3718
    const char *p = str;
3719
    for(i = 0;; i++) {
3720
        dest[i] = atoi(p);
3721
        if(i == 63)
3722
            break;
3723
        p = strchr(p, ',');
3724
        if(!p) {
3725
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3726
            exit(1);
3727
        }
3728
        p++;
3729
    }
3730
}
3731

    
3732
void opt_inter_matrix(const char *arg)
3733
{
3734
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3735
    parse_matrix_coeffs(inter_matrix, arg);
3736
}
3737

    
3738
void opt_intra_matrix(const char *arg)
3739
{
3740
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3741
    parse_matrix_coeffs(intra_matrix, arg);
3742
}
3743

    
3744
static void opt_target(const char *arg)
3745
{
3746
    int norm = -1;
3747
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3748

    
3749
    if(!strncmp(arg, "pal-", 4)) {
3750
        norm = 0;
3751
        arg += 4;
3752
    } else if(!strncmp(arg, "ntsc-", 5)) {
3753
        norm = 1;
3754
        arg += 5;
3755
    } else if(!strncmp(arg, "film-", 5)) {
3756
        norm = 2;
3757
        arg += 5;
3758
    } else {
3759
        int fr;
3760
        /* Calculate FR via float to avoid int overflow */
3761
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3762
        if(fr == 25000) {
3763
            norm = 0;
3764
        } else if((fr == 29970) || (fr == 23976)) {
3765
            norm = 1;
3766
        } else {
3767
            /* Try to determine PAL/NTSC by peeking in the input files */
3768
            if(nb_input_files) {
3769
                int i, j;
3770
                for(j = 0; j < nb_input_files; j++) {
3771
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3772
                        AVCodecContext *c = &input_files[j]->streams[i]->codec;
3773
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3774
                            continue;
3775
                        fr = c->frame_rate * 1000 / c->frame_rate_base;
3776
                        if(fr == 25000) {
3777
                            norm = 0;
3778
                            break;
3779
                        } else if((fr == 29970) || (fr == 23976)) {
3780
                            norm = 1;
3781
                            break;
3782
                        }
3783
                    }
3784
                    if(norm >= 0)
3785
                        break;
3786
                }
3787
            }
3788
        }
3789
        if(verbose && norm >= 0)
3790
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3791
    }
3792

    
3793
    if(norm < 0) {
3794
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3795
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3796
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3797
        exit(1);
3798
    }
3799

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

    
3802
        opt_video_codec("mpeg1video");
3803
        opt_audio_codec("mp2");
3804
        opt_format("vcd");
3805

    
3806
        opt_frame_size(norm ? "352x240" : "352x288");
3807
        opt_frame_rate(frame_rates[norm]);
3808
        opt_gop_size(norm ? "18" : "15");
3809

    
3810
        video_bit_rate = 1150000;
3811
        video_rc_max_rate = 1150000;
3812
        video_rc_min_rate = 1150000;
3813
        video_rc_buffer_size = 40*1024*8;
3814

    
3815
        audio_bit_rate = 224000;
3816
        audio_sample_rate = 44100;
3817
        
3818
        mux_packet_size= 2324;
3819
        mux_rate= 2352 * 75 * 8;
3820

    
3821
        /* We have to offset the PTS, so that it is consistent with the SCR.
3822
           SCR starts at 36000, but the first two packs contain only padding
3823
           and the first pack from the other stream, respectively, may also have
3824
           been written before.
3825
           So the real data starts at SCR 36000+3*1200. */
3826
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3827
    } else if(!strcmp(arg, "svcd")) {
3828

    
3829
        opt_video_codec("mpeg2video");
3830
        opt_audio_codec("mp2");
3831
        opt_format("svcd");
3832

    
3833
        opt_frame_size(norm ? "480x480" : "480x576");
3834
        opt_frame_rate(frame_rates[norm]);
3835
        opt_gop_size(norm ? "18" : "15");
3836

    
3837
        video_bit_rate = 2040000;
3838
        video_rc_max_rate = 2516000;
3839
        video_rc_min_rate = 0; //1145000;
3840
        video_rc_buffer_size = 224*1024*8;
3841
        use_scan_offset = 1;
3842

    
3843
        audio_bit_rate = 224000;
3844
        audio_sample_rate = 44100;
3845

    
3846
        mux_packet_size= 2324;
3847

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

    
3850
        opt_video_codec("mpeg2video");
3851
        opt_audio_codec("ac3");
3852
        opt_format("dvd");
3853

    
3854
        opt_frame_size(norm ? "720x480" : "720x576");
3855
        opt_frame_rate(frame_rates[norm]);
3856
        opt_gop_size(norm ? "18" : "15");
3857

    
3858
        video_bit_rate = 6000000;
3859
        video_rc_max_rate = 9000000;
3860
        video_rc_min_rate = 0; //1500000;
3861
        video_rc_buffer_size = 224*1024*8;
3862

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

    
3866
        audio_bit_rate = 448000;
3867
        audio_sample_rate = 48000;
3868

    
3869
    } else if(!strcmp(arg, "dv")) {
3870

    
3871
        opt_format("dv");
3872

    
3873
        opt_frame_size(norm ? "720x480" : "720x576");
3874
        opt_frame_rate(frame_rates[norm]);
3875

    
3876
        audio_sample_rate = 48000;
3877
        audio_channels = 2;
3878

    
3879
    } else {
3880
        fprintf(stderr, "Unknown target: %s\n", arg);
3881
        exit(1);
3882
    }
3883
}
3884

    
3885
static void show_version(void)
3886
{
3887
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3888
           "libavcodec  %d\n"
3889
           "libavformat %d\n", 
3890
           avcodec_build(), LIBAVFORMAT_BUILD);
3891
    exit(1);
3892
}
3893

    
3894
const OptionDef options[] = {
3895
    /* main options */
3896
    { "L", 0, {(void*)show_license}, "show license" },
3897
    { "h", 0, {(void*)show_help}, "show help" },
3898
    { "version", 0, {(void*)show_version}, "show version" },
3899
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3900
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3901
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3902
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3903
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3904
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3905
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3906
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3907
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3908
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3909
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3910
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3911
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3912
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3913
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3914
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3915
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3916
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
3917
      "add timings for benchmarking" },
3918
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
3919
      "dump each input packet" },
3920
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
3921
      "when dumping packets, also dump the payload" },
3922
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
3923
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3924
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3925
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3926
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3927
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3928
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3929
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3930
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3931

    
3932
    /* video options */
3933
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3934
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3935
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3936
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3937
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3938
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3939
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3940
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3941
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3942
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3943
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3944
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3945
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3946
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3947
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3948
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3949
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3950
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3951
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3952
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3953
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold" },
3954
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3955
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3956
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3957
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3958
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3959
    { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3960
    { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3961
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3962
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3963
    { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
3964
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3965
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3966
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3967
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3968
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3969
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3970
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3971
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3972
//    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3973
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3974
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3975
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3976
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3977
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3978
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3979
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3980
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
3981
      "method" },
3982
    { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3983
    { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3984
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3985
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3986
    { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3987
    { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3988
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3989
    { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3990
    { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3991
    { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3992
    { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3993
    { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3994
    { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3995
    { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3996
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3997
    { "lelim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lelim}, "single coefficient elimination threshold for luminance (negative values also consider DC coefficient)", "elim" },
3998
    { "celim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_celim}, "single coefficient elimination threshold for chrominance (negative values also consider DC coefficient)", "elim" },
3999
    { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
4000
    { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
4001
    { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
4002
    { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
4003
    { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
4004
    { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
4005
    { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
4006
    { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
4007
    { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
4008
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4009
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4010
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4011
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4012
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
4013
      "use same video quality as source (implies VBR)" },
4014
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4015
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4016
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
4017
      "deinterlace pictures" },
4018
    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 
4019
      "force interlaced dct support in encoder (MPEG2/MPEG4)" },
4020
    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 
4021
      "force interlaced me support in encoder (MPEG2/MPEG4)" },
4022
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4023
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
4024
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4025
    { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
4026
    { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
4027
    { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
4028
    { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
4029
    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
4030
    { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
4031
    { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
4032
    { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
4033
    { "mv0", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_mv0}, "try to encode each MB with MV=<0,0> and choose the better one (has no effect if mbd=0)" },
4034
    { "naq", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_normalize_aqp}, "normalize adaptive quantization" },
4035
    { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
4036
    { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
4037
    { "noout", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&no_output}, "skip bitstream encoding" },
4038
    { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
4039
    { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
4040
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4041
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4042
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4043
    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
4044
    { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
4045
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4046
    { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4047
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4048
    { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
4049
    { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
4050
    { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
4051
    { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
4052
    { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
4053
    { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
4054
    { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
4055
    { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
4056
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4057
    { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4058
    { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4059
    { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4060
    { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
4061

    
4062
    /* audio options */
4063
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4064
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4065
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4066
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4067
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4068
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4069

    
4070
    /* grab options */
4071
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4072
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4073
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4074
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4075

    
4076
    /* G.2 grab options */ 
4077
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4078
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4079
 
4080
    /* muxer options */   
4081
    { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4082
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4083
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4084
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4085
    { NULL, },
4086
};
4087

    
4088
static void show_banner(void)
4089
{
4090
    fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4091
        LIBAVCODEC_BUILD);
4092
    fprintf(stderr, "  configuration: %s\n", FFMPEG_CONFIGURATION);
4093
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4094
#ifdef __GNUC__
4095
    fprintf(stderr, ", gcc: %s\n", __VERSION__);
4096
#else
4097
    fprintf(stderr, ", using a non-gcc compiler\n");
4098
#endif
4099
}
4100

    
4101
static void show_license(void)
4102
{
4103
    show_banner();
4104
#ifdef CONFIG_GPL
4105
    printf(
4106
    "This program is free software; you can redistribute it and/or modify\n"   
4107
    "it under the terms of the GNU General Public License as published by\n"
4108
    "the Free Software Foundation; either version 2 of the License, or\n"
4109
    "(at your option) any later version.\n"
4110
    "\n"
4111
    "This program is distributed in the hope that it will be useful,\n"
4112
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4113
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4114
    "GNU General Public License for more details.\n"
4115
    "\n"
4116
    "You should have received a copy of the GNU General Public License\n"
4117
    "along with this program; if not, write to the Free Software\n"
4118
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4119
    );
4120
#else
4121
    printf(
4122
    "This library is free software; you can redistribute it and/or\n"
4123
    "modify it under the terms of the GNU Lesser General Public\n"
4124
    "License as published by the Free Software Foundation; either\n"
4125
    "version 2 of the License, or (at your option) any later version.\n"
4126
    "\n"
4127
    "This library is distributed in the hope that it will be useful,\n"
4128
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4129
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4130
    "Lesser General Public License for more details.\n"
4131
    "\n"
4132
    "You should have received a copy of the GNU Lesser General Public\n"
4133
    "License along with this library; if not, write to the Free Software\n"
4134
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4135
    );
4136
#endif
4137
    exit(1);
4138
}
4139

    
4140
static void show_help(void)
4141
{
4142
    show_banner();
4143
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4144
           "Hyper fast Audio and Video encoder\n");
4145
    printf("\n");
4146
    show_help_options(options, "Main options:\n",
4147
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4148
    show_help_options(options, "\nVideo options:\n",
4149
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4150
                      OPT_VIDEO);
4151
    show_help_options(options, "\nAdvanced Video options:\n",
4152
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4153
                      OPT_VIDEO | OPT_EXPERT);
4154
    show_help_options(options, "\nAudio options:\n",
4155
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4156
                      OPT_AUDIO);
4157
    show_help_options(options, "\nAdvanced Audio options:\n",
4158
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4159
                      OPT_AUDIO | OPT_EXPERT);
4160
    show_help_options(options, "\nAudio/Video grab options:\n",
4161
                      OPT_GRAB, 
4162
                      OPT_GRAB);
4163
    show_help_options(options, "\nAdvanced options:\n",
4164
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4165
                      OPT_EXPERT);
4166
    exit(1);
4167
}
4168

    
4169
void parse_arg_file(const char *filename)
4170
{
4171
    opt_output_file(filename);
4172
}
4173

    
4174
int main(int argc, char **argv)
4175
{
4176
    int i;
4177
    int64_t ti;
4178

    
4179
    av_register_all();
4180

    
4181
    if (argc <= 1)
4182
        show_help();
4183
    else
4184
        show_banner();
4185
    
4186
    /* parse options */
4187
    parse_options(argc, argv, options);
4188

    
4189
    /* file converter / grab */
4190
    if (nb_output_files <= 0) {
4191
        fprintf(stderr, "Must supply at least one output file\n");
4192
        exit(1);
4193
    }
4194
    
4195
    if (nb_input_files == 0) {
4196
        input_sync = 1;
4197
        prepare_grab();
4198
    }
4199

    
4200
    ti = getutime();
4201
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
4202
              stream_maps, nb_stream_maps);
4203
    ti = getutime() - ti;
4204
    if (do_benchmark) {
4205
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4206
    }
4207

    
4208
    /* close files */
4209
    for(i=0;i<nb_output_files;i++) {
4210
        /* maybe av_close_output_file ??? */
4211
        AVFormatContext *s = output_files[i];
4212
        int j;
4213
        if (!(s->oformat->flags & AVFMT_NOFILE))
4214
            url_fclose(&s->pb);
4215
        for(j=0;j<s->nb_streams;j++)
4216
            av_free(s->streams[j]);
4217
        av_free(s);
4218
    }
4219
    for(i=0;i<nb_input_files;i++)
4220
        av_close_input_file(input_files[i]);
4221

    
4222
    av_free_static();
4223

    
4224
    if(intra_matrix)
4225
        av_free(intra_matrix);
4226
    if(inter_matrix)
4227
        av_free(inter_matrix);
4228
    
4229
#ifdef POWERPC_PERFORMANCE_REPORT
4230
    extern void powerpc_display_perf_report(void);
4231
    powerpc_display_perf_report();
4232
#endif /* POWERPC_PERFORMANCE_REPORT */
4233

    
4234
#ifndef CONFIG_WIN32
4235
    if (received_sigterm) {
4236
        fprintf(stderr,
4237
            "Received signal %d: terminating.\n",
4238
            (int) received_sigterm);
4239
        exit (255);
4240
    }
4241
#endif
4242
    exit(0); /* not all OS-es handle main() return value */
4243
    return 0;
4244
}