Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ dffbfd06

History | View | Annotate | Download (148 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
static int opt_shortest = 0; //
246

    
247
static int rate_emu = 0;
248

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

    
255
static char *audio_grab_format = "audio_device";
256
static char *audio_device = NULL;
257
static int audio_volume = 256;
258

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

    
273
static int pgmyuv_compatibility_hack=0;
274

    
275

    
276
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
277

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

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

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

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

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

    
336
#ifndef CONFIG_WIN32
337

    
338
/* init terminal so that we can grab keys */
339
static struct termios oldtty;
340

    
341
static void term_exit(void)
342
{
343
    tcsetattr (0, TCSANOW, &oldtty);
344
}
345

    
346
static volatile sig_atomic_t received_sigterm = 0;
347

    
348
static void
349
sigterm_handler(int sig)
350
{
351
    received_sigterm = sig;
352
    term_exit();
353
}
354

    
355
static void term_init(void)
356
{
357
    struct termios tty;
358

    
359
    tcgetattr (0, &tty);
360
    oldtty = tty;
361

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

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

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

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

    
405
        return n;
406
    }
407
    return -1;
408
}
409

    
410
static int decode_interrupt_cb(void)
411
{
412
    return q_pressed || (q_pressed = read_key() == 'q');
413
}
414

    
415
#else
416

    
417
static volatile int received_sigterm = 0;
418

    
419
/* no interactive support */
420
static void term_exit(void)
421
{
422
}
423

    
424
static void term_init(void)
425
{
426
}
427

    
428
static int read_key(void)
429
{
430
    return 0;
431
}
432

    
433
#endif
434

    
435
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
436
{
437
    int i, err;
438
    AVFormatContext *ic;
439

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

    
448
        st = av_mallocz(sizeof(AVStream));
449
        memcpy(st, ic->streams[i], sizeof(AVStream));
450
        s->streams[i] = st;
451
    }
452

    
453
    av_close_input_file(ic);
454
    return 0;
455
}
456

    
457
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
458

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

    
469
    int size_out, frame_bytes, ret;
470
    AVCodecContext *enc= &ost->st->codec;
471

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

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

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

    
502
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
503
                        ist->is_start=0;
504
                    else
505
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
506

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

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

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

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

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

    
568
        ost->sync_opts += size_out / (2 * enc->channels);
569

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

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

    
602
    dec = &ist->st->codec;
603

    
604
    /* deinterlace : must be done before any resize */
605
    if (do_deinterlace || using_vhook) {
606
        int size;
607

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

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

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

    
640
    if (picture != picture2)
641
        *picture = *picture2;
642
    *bufp = buf;
643
}
644

    
645
/* we begin to correct av delay at this threshold */
646
#define AV_DELAY_MAX 0.100
647

    
648

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

    
664
        if (padleft || padright) {
665
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
666
                (img->linesize[i] - (padright >> shift));
667

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

    
681
static int bit_buffer_size= 1024*256;
682
static uint8_t *bit_buffer= NULL;
683

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

    
700
    enc = &ost->st->codec;
701
    dec = &ist->st->codec;
702

    
703
    /* by default, we output a single frame */
704
    nb_frames = 1;
705

    
706
    *frame_size = 0;
707

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

    
729
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
730
    if (nb_frames <= 0) 
731
        return;
732

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

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

    
751
            if (verbose >= 0)
752
                fprintf(stderr, "pixel format conversion not handled\n");
753

    
754
            goto the_end;
755
        }
756
    } else {
757
        formatted_picture = in_picture;
758
    }
759

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

    
789
                if (verbose >= 0)
790
                    fprintf(stderr, "pixel format conversion not handled\n");
791

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

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

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

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

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

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

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

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

    
849
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
850
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
851
                        enc->width, enc->height) < 0) {
852

    
853
                if (verbose >= 0)
854
                    fprintf(stderr, "pixel format conversion not handled\n");
855

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

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

    
881
            av_interleaved_write_frame(s, &pkt);
882
            enc->coded_frame = old_frame;
883
        } else {
884
            AVFrame big_picture;
885

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

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

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

    
942
static double psnr(double d){
943
    if(d==0) return INFINITY;
944
    return -10.0*log(d)/log(10.0);
945
}
946

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

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

    
1020

    
1021
    oc = output_files[0];
1022

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

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

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

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

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

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

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

    
1213
            // preprocess audio (volume)
1214
            if (ist->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1215
                if (audio_volume != 256) {
1216
                    short *volp;
1217
                    volp = samples;
1218
                    for(i=0;i<(data_size / sizeof(short));i++) {
1219
                        int v = ((*volp) * audio_volume + 128) >> 8;
1220
                        if (v < -32768) v = -32768;
1221
                        if (v >  32767) v = 32767;
1222
                        *volp++ = v;
1223
                    }
1224
                }
1225
            }
1226

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

    
1234
                ist->frame++;
1235
            }
1236

    
1237
#if 0
1238
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1239
               is the one of the next displayed one */
1240
            /* XXX: add mpeg4 too ? */
1241
            if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1242
                if (ist->st->codec.pict_type != B_TYPE) {
1243
                    int64_t tmp;
1244
                    tmp = ist->last_ip_pts;
1245
                    ist->last_ip_pts  = ist->frac_pts.val;
1246
                    ist->frac_pts.val = tmp;
1247
                }
1248
            }
1249
#endif
1250
            /* if output time reached then transcode raw format, 
1251
               encode packets and output them */
1252
            if (start_time == 0 || ist->pts >= start_time)
1253
                for(i=0;i<nb_ostreams;i++) {
1254
                    int frame_size;
1255

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

    
1260
#if 0
1261
                        printf("%d: got pts=%0.3f %0.3f\n", i, 
1262
                               (double)pkt->pts / AV_TIME_BASE, 
1263
                               ((double)ist->pts / AV_TIME_BASE) - 
1264
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1265
#endif
1266
                        /* set the input output pts pairs */
1267
                        ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1268

    
1269
                        if (ost->encoding_needed) {
1270
                            switch(ost->st->codec.codec_type) {
1271
                            case CODEC_TYPE_AUDIO:
1272
                                do_audio_out(os, ost, ist, data_buf, data_size);
1273
                                break;
1274
                            case CODEC_TYPE_VIDEO:
1275
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1276
                                    video_size += frame_size;
1277
                                    if (do_vstats && frame_size)
1278
                                        do_video_stats(os, ost, frame_size);
1279
                                break;
1280
                            default:
1281
                                av_abort();
1282
                            }
1283
                        } else {
1284
                            AVFrame avframe; //FIXME/XXX remove this
1285
                            AVPacket opkt;
1286
                            av_init_packet(&opkt);
1287

    
1288
                            /* no reencoding needed : output the packet directly */
1289
                            /* force the input stream PTS */
1290
                        
1291
                            avcodec_get_frame_defaults(&avframe);
1292
                            ost->st->codec.coded_frame= &avframe;
1293
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1294

    
1295
                            if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1296
                                audio_size += data_size;
1297
                            else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1298
                                video_size += data_size;
1299
                                ost->sync_opts++;
1300
                            }
1301

    
1302
                            opkt.stream_index= ost->index;
1303
                            opkt.data= data_buf;
1304
                            opkt.size= data_size;
1305
                            if(pkt->pts != AV_NOPTS_VALUE)
1306
                                opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1307
                            else
1308
                                opkt.pts= AV_NOPTS_VALUE;
1309
                            opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1310
                            opkt.flags= pkt->flags;
1311
                            
1312
                            av_interleaved_write_frame(os, &opkt);
1313
                            ost->st->codec.frame_number++;
1314
                            ost->frame_number++;
1315
                        }
1316
                    }
1317
                }
1318
            av_free(buffer_to_free);
1319
        }
1320
 discard_packet:
1321
    if (pkt == NULL) {
1322
        /* EOF handling */
1323
  
1324
        for(i=0;i<nb_ostreams;i++) {
1325
            ost = ost_table[i];
1326
            if (ost->source_index == ist_index) {
1327
                AVCodecContext *enc= &ost->st->codec;
1328
                os = output_files[ost->file_index];
1329
                
1330
                if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1331
                    continue;
1332
                if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1333
                    continue;
1334

    
1335
                if (ost->encoding_needed) {
1336
                    for(;;) {
1337
                        AVPacket pkt;
1338
                        av_init_packet(&pkt);
1339
                        pkt.stream_index= ost->index;
1340
 
1341
                        switch(ost->st->codec.codec_type) {
1342
                        case CODEC_TYPE_AUDIO:        
1343
                            ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1344
                            audio_size += ret;
1345
                            pkt.flags |= PKT_FLAG_KEY;
1346
                            break;
1347
                        case CODEC_TYPE_VIDEO:
1348
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1349
                            video_size += ret;
1350
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1351
                                pkt.flags |= PKT_FLAG_KEY;
1352
                            if (ost->logfile && enc->stats_out) {
1353
                                fprintf(ost->logfile, "%s", enc->stats_out);
1354
                            }
1355
                            break;
1356
                        default:
1357
                            ret=-1;
1358
                        }
1359
                            
1360
                        if(ret<=0)
1361
                            break;
1362
                        pkt.data= bit_buffer;
1363
                        pkt.size= ret;
1364
                        if(enc->coded_frame)
1365
                            pkt.pts= enc->coded_frame->pts;
1366
                        av_interleaved_write_frame(os, &pkt);
1367
                    }
1368
                }
1369
            }
1370
        }
1371
    }
1372
 
1373
    return 0;
1374
 fail_decode:
1375
    return -1;
1376
}
1377

    
1378

    
1379
/*
1380
 * The following code is the main loop of the file converter
1381
 */
1382
static int av_encode(AVFormatContext **output_files,
1383
                     int nb_output_files,
1384
                     AVFormatContext **input_files,
1385
                     int nb_input_files,
1386
                     AVStreamMap *stream_maps, int nb_stream_maps)
1387
{
1388
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1389
    AVFormatContext *is, *os;
1390
    AVCodecContext *codec, *icodec;
1391
    AVOutputStream *ost, **ost_table = NULL;
1392
    AVInputStream *ist, **ist_table = NULL;
1393
    AVInputFile *file_table;
1394
    AVFormatContext *stream_no_data;
1395
    int key;
1396

    
1397
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1398
    if (!file_table)
1399
        goto fail;
1400
        
1401
    /* input stream init */
1402
    j = 0;
1403
    for(i=0;i<nb_input_files;i++) {
1404
        is = input_files[i];
1405
        file_table[i].ist_index = j;
1406
        file_table[i].nb_streams = is->nb_streams;
1407
        j += is->nb_streams;
1408
    }
1409
    nb_istreams = j;
1410

    
1411
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1412
    if (!ist_table)
1413
        goto fail;
1414
    
1415
    for(i=0;i<nb_istreams;i++) {
1416
        ist = av_mallocz(sizeof(AVInputStream));
1417
        if (!ist)
1418
            goto fail;
1419
        ist_table[i] = ist;
1420
    }
1421
    j = 0;
1422
    for(i=0;i<nb_input_files;i++) {
1423
        is = input_files[i];
1424
        for(k=0;k<is->nb_streams;k++) {
1425
            ist = ist_table[j++];
1426
            ist->st = is->streams[k];
1427
            ist->file_index = i;
1428
            ist->index = k;
1429
            ist->discard = 1; /* the stream is discarded by default
1430
                                 (changed later) */
1431

    
1432
            if (ist->st->codec.rate_emu) {
1433
                ist->start = av_gettime();
1434
                ist->frame = 0;
1435
            }
1436
        }
1437
    }
1438

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

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

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

    
1532
        codec = &ost->st->codec;
1533
        icodec = &ist->st->codec;
1534

    
1535
        if (ost->st->stream_copy) {
1536
            /* if stream_copy is selected, no need to decode or encode */
1537
            codec->codec_id = icodec->codec_id;
1538
            codec->codec_type = icodec->codec_type;
1539
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1540
            codec->bit_rate = icodec->bit_rate;
1541
            codec->extradata= icodec->extradata;
1542
            codec->extradata_size= icodec->extradata_size;
1543
            switch(codec->codec_type) {
1544
            case CODEC_TYPE_AUDIO:
1545
                codec->sample_rate = icodec->sample_rate;
1546
                codec->channels = icodec->channels;
1547
                codec->frame_size = icodec->frame_size;
1548
                codec->block_align= icodec->block_align;
1549
                break;
1550
            case CODEC_TYPE_VIDEO:
1551
                codec->frame_rate = icodec->frame_rate;
1552
                codec->frame_rate_base = icodec->frame_rate_base;
1553
                codec->width = icodec->width;
1554
                codec->height = icodec->height;
1555
                codec->has_b_frames = icodec->has_b_frames;
1556
                break;
1557
            default:
1558
                av_abort();
1559
            }
1560
        } else {
1561
            switch(codec->codec_type) {
1562
            case CODEC_TYPE_AUDIO:
1563
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1564
                    goto fail;
1565
                
1566
                if (codec->channels == icodec->channels &&
1567
                    codec->sample_rate == icodec->sample_rate) {
1568
                    ost->audio_resample = 0;
1569
                } else {
1570
                    if (codec->channels != icodec->channels &&
1571
                        (icodec->codec_id == CODEC_ID_AC3 ||
1572
                         icodec->codec_id == CODEC_ID_DTS)) {
1573
                        /* Special case for 5:1 AC3 and DTS input */
1574
                        /* and mono or stereo output      */
1575
                        /* Request specific number of channels */
1576
                        icodec->channels = codec->channels;
1577
                        if (codec->sample_rate == icodec->sample_rate)
1578
                            ost->audio_resample = 0;
1579
                        else {
1580
                            ost->audio_resample = 1;
1581
                        }
1582
                    } else {
1583
                        ost->audio_resample = 1; 
1584
                    }
1585
                }
1586
                if(audio_sync_method>1)
1587
                    ost->audio_resample = 1;
1588

    
1589
                if(ost->audio_resample){
1590
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1591
                                                    codec->sample_rate, icodec->sample_rate);
1592
                    if(!ost->resample){
1593
                        printf("Can't resample.  Aborting.\n");
1594
                        av_abort();
1595
                    }
1596
                }
1597
                ist->decoding_needed = 1;
1598
                ost->encoding_needed = 1;
1599
                break;
1600
            case CODEC_TYPE_VIDEO:
1601
                if (codec->width == icodec->width &&
1602
                    codec->height == icodec->height &&
1603
                    frame_topBand == 0 &&
1604
                    frame_bottomBand == 0 &&
1605
                    frame_leftBand == 0 &&
1606
                    frame_rightBand == 0 && 
1607
                    frame_padtop == 0 &&
1608
                    frame_padbottom == 0 &&
1609
                    frame_padleft == 0 &&
1610
                    frame_padright == 0)
1611
                {
1612
                    ost->video_resample = 0;
1613
                    ost->video_crop = 0;
1614
                    ost->video_pad = 0;
1615
                } else if ((codec->width == icodec->width -
1616
                                (frame_leftBand + frame_rightBand)) &&
1617
                        (codec->height == icodec->height -
1618
                                (frame_topBand  + frame_bottomBand)))
1619
                {
1620
                    ost->video_resample = 0;
1621
                    ost->video_crop = 1;
1622
                    ost->topBand = frame_topBand;
1623
                    ost->leftBand = frame_leftBand;
1624
                } else if ((codec->width == icodec->width + 
1625
                                (frame_padleft + frame_padright)) &&
1626
                        (codec->height == icodec->height +
1627
                                (frame_padtop + frame_padbottom))) {
1628
                    ost->video_resample = 0;
1629
                    ost->video_crop = 0;
1630
                    ost->video_pad = 1;
1631
                    ost->padtop = frame_padtop;
1632
                    ost->padleft = frame_padleft;
1633
                    ost->padbottom = frame_padbottom;
1634
                    ost->padright = frame_padright;
1635
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1636
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1637
                                codec->width, codec->height ) )
1638
                        goto fail;
1639
                } else {
1640
                    ost->video_resample = 1;
1641
                    ost->video_crop = 0; // cropping is handled as part of resample
1642
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1643
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1644
                                         codec->width, codec->height ) )
1645
                        goto fail;
1646

    
1647
                    ost->img_resample_ctx = img_resample_full_init( 
1648
                                      ost->st->codec.width, ost->st->codec.height,
1649
                                      ist->st->codec.width, ist->st->codec.height,
1650
                                      frame_topBand, frame_bottomBand,
1651
                            frame_leftBand, frame_rightBand, 
1652
                            frame_padtop, frame_padbottom, 
1653
                            frame_padleft, frame_padright);
1654
                    
1655
                    ost->padtop = frame_padtop;
1656
                    ost->padleft = frame_padleft;
1657
                    ost->padbottom = frame_padbottom;
1658
                    ost->padright = frame_padright;
1659
                   
1660
                }
1661
                ost->encoding_needed = 1;
1662
                ist->decoding_needed = 1;
1663
                break;
1664
            default:
1665
                av_abort();
1666
            }
1667
            /* two pass mode */
1668
            if (ost->encoding_needed && 
1669
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1670
                char logfilename[1024];
1671
                FILE *f;
1672
                int size;
1673
                char *logbuffer;
1674
                
1675
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 
1676
                         pass_logfilename ? 
1677
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1678
                if (codec->flags & CODEC_FLAG_PASS1) {
1679
                    f = fopen(logfilename, "w");
1680
                    if (!f) {
1681
                        perror(logfilename);
1682
                        exit(1);
1683
                    }
1684
                    ost->logfile = f;
1685
                } else {
1686
                    /* read the log file */
1687
                    f = fopen(logfilename, "r");
1688
                    if (!f) {
1689
                        perror(logfilename);
1690
                        exit(1);
1691
                    }
1692
                    fseek(f, 0, SEEK_END);
1693
                    size = ftell(f);
1694
                    fseek(f, 0, SEEK_SET);
1695
                    logbuffer = av_malloc(size + 1);
1696
                    if (!logbuffer) {
1697
                        fprintf(stderr, "Could not allocate log buffer\n");
1698
                        exit(1);
1699
                    }
1700
                    size = fread(logbuffer, 1, size, f);
1701
                    fclose(f);
1702
                    logbuffer[size] = '\0';
1703
                    codec->stats_in = logbuffer;
1704
                }
1705
            }
1706
        }
1707
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1708
            int size= codec->width * codec->height;
1709
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1710
        }
1711
    }
1712

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

    
1718
    /* dump the file output parameters - cannot be done before in case
1719
       of stream copy */
1720
    for(i=0;i<nb_output_files;i++) {
1721
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1722
    }
1723

    
1724
    /* dump the stream mapping */
1725
    if (verbose >= 0) {
1726
        fprintf(stderr, "Stream mapping:\n");
1727
        for(i=0;i<nb_ostreams;i++) {
1728
            ost = ost_table[i];
1729
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1730
                    ist_table[ost->source_index]->file_index,
1731
                    ist_table[ost->source_index]->index,
1732
                    ost->file_index, 
1733
                    ost->index);
1734
        }
1735
    }
1736

    
1737
    /* open each encoder */
1738
    for(i=0;i<nb_ostreams;i++) {
1739
        ost = ost_table[i];
1740
        if (ost->encoding_needed) {
1741
            AVCodec *codec;
1742
            codec = avcodec_find_encoder(ost->st->codec.codec_id);
1743
            if (!codec) {
1744
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n", 
1745
                        ost->file_index, ost->index);
1746
                exit(1);
1747
            }
1748
            if (avcodec_open(&ost->st->codec, codec) < 0) {
1749
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n", 
1750
                        ost->file_index, ost->index);
1751
                exit(1);
1752
            }
1753
            extra_size += ost->st->codec.extradata_size;
1754
        }
1755
    }
1756

    
1757
    /* open each decoder */
1758
    for(i=0;i<nb_istreams;i++) {
1759
        ist = ist_table[i];
1760
        if (ist->decoding_needed) {
1761
            AVCodec *codec;
1762
            codec = avcodec_find_decoder(ist->st->codec.codec_id);
1763
            if (!codec) {
1764
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n", 
1765
                        ist->st->codec.codec_id, ist->file_index, ist->index);
1766
                exit(1);
1767
            }
1768
            if (avcodec_open(&ist->st->codec, codec) < 0) {
1769
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
1770
                        ist->file_index, ist->index);
1771
                exit(1);
1772
            }
1773
            //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1774
            //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1775
        }
1776
    }
1777

    
1778
    /* init pts */
1779
    for(i=0;i<nb_istreams;i++) {
1780
        ist = ist_table[i];
1781
        is = input_files[ist->file_index];
1782
        ist->pts = 0;
1783
        ist->next_pts = ist->st->start_time;
1784
        if(ist->next_pts == AV_NOPTS_VALUE) 
1785
            ist->next_pts=0;
1786
        if(input_files_ts_offset[ist->file_index])
1787
            ist->next_pts= AV_NOPTS_VALUE;
1788
        ist->is_start = 1;
1789
    }
1790

    
1791
    /* compute buffer size max (should use a complete heuristic) */
1792
    for(i=0;i<nb_input_files;i++) {
1793
        file_table[i].buffer_size_max = 2048;
1794
    }
1795

    
1796
    /* set meta data information from input file if required */
1797
    for (i=0;i<nb_meta_data_maps;i++) {
1798
        AVFormatContext *out_file;
1799
        AVFormatContext *in_file;
1800

    
1801
        int out_file_index = meta_data_maps[i].out_file;
1802
        int in_file_index = meta_data_maps[i].in_file;
1803
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1804
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1805
            ret = -EINVAL;
1806
            goto fail;
1807
        }
1808
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1809
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1810
            ret = -EINVAL;
1811
            goto fail;
1812
        }                
1813
                 
1814
        out_file = output_files[out_file_index];
1815
        in_file = input_files[in_file_index];
1816

    
1817
        strcpy(out_file->title, in_file->title);
1818
        strcpy(out_file->author, in_file->author);
1819
        strcpy(out_file->copyright, in_file->copyright);
1820
        strcpy(out_file->comment, in_file->comment);
1821
        strcpy(out_file->album, in_file->album);
1822
        out_file->year = in_file->year;
1823
        out_file->track = in_file->track;
1824
        strcpy(out_file->genre, in_file->genre);
1825
    }
1826
        
1827
    /* open files and write file headers */
1828
    for(i=0;i<nb_output_files;i++) {
1829
        os = output_files[i];
1830
        if (av_write_header(os) < 0) {
1831
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1832
            ret = -EINVAL;
1833
            goto fail;
1834
        }
1835
    }
1836

    
1837
#ifndef CONFIG_WIN32
1838
    if ( !using_stdin && verbose >= 0) {
1839
        fprintf(stderr, "Press [q] to stop encoding\n");
1840
        url_set_interrupt_cb(decode_interrupt_cb);
1841
    }
1842
#endif
1843
    term_init();
1844

    
1845
    stream_no_data = 0;
1846
    key = -1;
1847

    
1848
    for(; received_sigterm == 0;) {
1849
        int file_index, ist_index;
1850
        AVPacket pkt;
1851
        double ipts_min;
1852
        double opts_min;
1853

    
1854
    redo:
1855
        ipts_min= 1e100;
1856
        opts_min= 1e100;
1857
        /* if 'q' pressed, exits */
1858
        if (!using_stdin) {
1859
            if (q_pressed)
1860
                break;
1861
            /* read_key() returns 0 on EOF */
1862
            key = read_key();
1863
            if (key == 'q')
1864
                break;
1865
        }
1866

    
1867
        /* select the stream that we must read now by looking at the
1868
           smallest output pts */
1869
        file_index = -1;
1870
        for(i=0;i<nb_ostreams;i++) {
1871
            double ipts, opts;
1872
            ost = ost_table[i];
1873
            os = output_files[ost->file_index];
1874
            ist = ist_table[ost->source_index];
1875
            if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1876
                opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1877
            else
1878
                opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1879
            ipts = (double)ist->pts;
1880
            if (!file_table[ist->file_index].eof_reached){
1881
                if(ipts < ipts_min) {
1882
                    ipts_min = ipts;
1883
                    if(input_sync ) file_index = ist->file_index;
1884
                }
1885
                if(opts < opts_min) {
1886
                    opts_min = opts;
1887
                    if(!input_sync) file_index = ist->file_index;
1888
                }
1889
            }
1890
            if(ost->frame_number >= max_frames[ost->st->codec.codec_type]){
1891
                file_index= -1;
1892
                break;
1893
            }
1894
        }
1895
        /* if none, if is finished */
1896
        if (file_index < 0) {
1897
            break;
1898
        }
1899

    
1900
        /* finish if recording time exhausted */
1901
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1902
            break;
1903

    
1904
        /* finish if limit size exhausted */
1905
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1906
            break;
1907

    
1908
        /* read a frame from it and output it in the fifo */
1909
        is = input_files[file_index];
1910
        if (av_read_frame(is, &pkt) < 0) {
1911
            file_table[file_index].eof_reached = 1;
1912
            if (opt_shortest) break; else continue; //
1913
        }
1914

    
1915
        if (!pkt.size) {
1916
            stream_no_data = is;
1917
        } else {
1918
            stream_no_data = 0;
1919
        }
1920
        if (do_pkt_dump) {
1921
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1922
        }
1923
        /* the following test is needed in case new streams appear
1924
           dynamically in stream : we ignore them */
1925
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1926
            goto discard_packet;
1927
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1928
        ist = ist_table[ist_index];
1929
        if (ist->discard)
1930
            goto discard_packet;
1931

    
1932
//        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);
1933
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1934
            int64_t delta= pkt.dts - ist->next_pts;
1935
            if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1936
                input_files_ts_offset[ist->file_index]-= delta;
1937
                if (verbose > 2)
1938
                    fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1939
                for(i=0; i<file_table[file_index].nb_streams; i++){
1940
                    int index= file_table[file_index].ist_index + i;
1941
                    ist_table[index]->next_pts += delta;
1942
                    ist_table[index]->is_start=1;
1943
                }
1944
            }
1945
        }
1946

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

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

    
1954
            av_free_packet(&pkt);
1955
            goto redo;
1956
        }
1957
        
1958
    discard_packet:
1959
        av_free_packet(&pkt);
1960
        
1961
        /* dump report by using the output first video and audio streams */
1962
        print_report(output_files, ost_table, nb_ostreams, 0);
1963
    }
1964

    
1965
    /* at the end of stream, we must flush the decoder buffers */
1966
    for(i=0;i<nb_istreams;i++) {
1967
        ist = ist_table[i];
1968
        if (ist->decoding_needed) {
1969
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1970
        }
1971
    }
1972

    
1973
    term_exit();
1974

    
1975
    /* write the trailer if needed and close file */
1976
    for(i=0;i<nb_output_files;i++) {
1977
        os = output_files[i];
1978
        av_write_trailer(os);
1979
    }
1980

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

    
1984
    /* close each encoder */
1985
    for(i=0;i<nb_ostreams;i++) {
1986
        ost = ost_table[i];
1987
        if (ost->encoding_needed) {
1988
            av_freep(&ost->st->codec.stats_in);
1989
            avcodec_close(&ost->st->codec);
1990
        }
1991
    }
1992
    
1993
    /* close each decoder */
1994
    for(i=0;i<nb_istreams;i++) {
1995
        ist = ist_table[i];
1996
        if (ist->decoding_needed) {
1997
            avcodec_close(&ist->st->codec);
1998
        }
1999
    }
2000

    
2001
    /* finished ! */
2002
    
2003
    ret = 0;
2004
 fail1:
2005
    av_freep(&bit_buffer);
2006
    av_free(file_table);
2007

    
2008
    if (ist_table) {
2009
        for(i=0;i<nb_istreams;i++) {
2010
            ist = ist_table[i];
2011
            av_free(ist);
2012
        }
2013
        av_free(ist_table);
2014
    }
2015
    if (ost_table) {
2016
        for(i=0;i<nb_ostreams;i++) {
2017
            ost = ost_table[i];
2018
            if (ost) {
2019
                if (ost->logfile) {
2020
                    fclose(ost->logfile);
2021
                    ost->logfile = NULL;
2022
                }
2023
                fifo_free(&ost->fifo); /* works even if fifo is not
2024
                                          initialized but set to zero */
2025
                av_free(ost->pict_tmp.data[0]);
2026
                if (ost->video_resample)
2027
                    img_resample_close(ost->img_resample_ctx);
2028
                if (ost->audio_resample)
2029
                    audio_resample_close(ost->resample);
2030
                av_free(ost);
2031
            }
2032
        }
2033
        av_free(ost_table);
2034
    }
2035
    return ret;
2036
 fail:
2037
    ret = -ENOMEM;
2038
    goto fail1;
2039
}
2040

    
2041
#if 0
2042
int file_read(const char *filename)
2043
{
2044
    URLContext *h;
2045
    unsigned char buffer[1024];
2046
    int len, i;
2047

2048
    if (url_open(&h, filename, O_RDONLY) < 0) {
2049
        printf("could not open '%s'\n", filename);
2050
        return -1;
2051
    }
2052
    for(;;) {
2053
        len = url_read(h, buffer, sizeof(buffer));
2054
        if (len <= 0)
2055
            break;
2056
        for(i=0;i<len;i++) putchar(buffer[i]);
2057
    }
2058
    url_close(h);
2059
    return 0;
2060
}
2061
#endif
2062

    
2063
static void opt_image_format(const char *arg)
2064
{
2065
    AVImageFormat *f;
2066
    
2067
    for(f = first_image_format; f != NULL; f = f->next) {
2068
        if (!strcmp(arg, f->name))
2069
            break;
2070
    }
2071
    if (!f) {
2072
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2073
        exit(1);
2074
    }
2075
    image_format = f;
2076
}
2077

    
2078
static void opt_format(const char *arg)
2079
{
2080
    /* compatibility stuff for pgmyuv */
2081
    if (!strcmp(arg, "pgmyuv")) {
2082
        pgmyuv_compatibility_hack=1;
2083
//        opt_image_format(arg);
2084
        arg = "image2";
2085
    }
2086

    
2087
    file_iformat = av_find_input_format(arg);
2088
    file_oformat = guess_format(arg, NULL, NULL);
2089
    if (!file_iformat && !file_oformat) {
2090
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2091
        exit(1);
2092
    }
2093
}
2094

    
2095
static void opt_video_bitrate(const char *arg)
2096
{
2097
    video_bit_rate = atoi(arg) * 1000;
2098
}
2099

    
2100
static void opt_video_bitrate_tolerance(const char *arg)
2101
{
2102
    video_bit_rate_tolerance = atoi(arg) * 1000;
2103
}
2104

    
2105
static void opt_video_bitrate_max(const char *arg)
2106
{
2107
    video_rc_max_rate = atoi(arg) * 1000;
2108
}
2109

    
2110
static void opt_video_bitrate_min(const char *arg)
2111
{
2112
    video_rc_min_rate = atoi(arg) * 1000;
2113
}
2114

    
2115
static void opt_video_buffer_size(const char *arg)
2116
{
2117
    video_rc_buffer_size = atoi(arg) * 8*1024;
2118
}
2119

    
2120
static void opt_video_rc_eq(char *arg)
2121
{
2122
    video_rc_eq = arg;
2123
}
2124

    
2125
static void opt_video_rc_override_string(char *arg)
2126
{
2127
    video_rc_override_string = arg;
2128
}
2129

    
2130

    
2131
static void opt_workaround_bugs(const char *arg)
2132
{
2133
    workaround_bugs = atoi(arg);
2134
}
2135

    
2136
static void opt_dct_algo(const char *arg)
2137
{
2138
    dct_algo = atoi(arg);
2139
}
2140

    
2141
static void opt_idct_algo(const char *arg)
2142
{
2143
    idct_algo = atoi(arg);
2144
}
2145

    
2146
static void opt_me_threshold(const char *arg)
2147
{
2148
    me_threshold = atoi(arg);
2149
}
2150

    
2151
static void opt_mb_threshold(const char *arg)
2152
{
2153
    mb_threshold = atoi(arg);
2154
}
2155

    
2156
static void opt_error_resilience(const char *arg)
2157
{
2158
    error_resilience = atoi(arg);
2159
}
2160

    
2161
static void opt_error_concealment(const char *arg)
2162
{
2163
    error_concealment = atoi(arg);
2164
}
2165

    
2166
static void opt_debug(const char *arg)
2167
{
2168
    debug = atoi(arg);
2169
}
2170

    
2171
static void opt_vismv(const char *arg)
2172
{
2173
    debug_mv = atoi(arg);
2174
}
2175
    
2176
static void opt_verbose(const char *arg)
2177
{
2178
    verbose = atoi(arg);
2179
    av_log_set_level(atoi(arg));
2180
}
2181

    
2182
static void opt_frame_rate(const char *arg)
2183
{
2184
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2185
        fprintf(stderr, "Incorrect frame rate\n");
2186
        exit(1);
2187
    }
2188
}
2189

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

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

    
2226
static void opt_frame_crop_left(const char *arg)
2227
{
2228
    frame_leftBand = atoi(arg);
2229
    if (frame_leftBand < 0) {
2230
        fprintf(stderr, "Incorrect left crop size\n");
2231
        exit(1);
2232
    }
2233
    if ((frame_leftBand % 2) != 0) {
2234
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2235
        exit(1);
2236
    }
2237
    if ((frame_leftBand) >= frame_width){
2238
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2239
        exit(1);
2240
    }
2241
    frame_width -= frame_leftBand;
2242
}
2243

    
2244
static void opt_frame_crop_right(const char *arg)
2245
{
2246
    frame_rightBand = atoi(arg);
2247
    if (frame_rightBand < 0) {
2248
        fprintf(stderr, "Incorrect right crop size\n");
2249
        exit(1);
2250
    }
2251
    if ((frame_rightBand % 2) != 0) {
2252
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2253
        exit(1);        
2254
    }
2255
    if ((frame_rightBand) >= frame_width){
2256
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2257
        exit(1);
2258
    }
2259
    frame_width -= frame_rightBand;
2260
}
2261

    
2262
static void opt_frame_size(const char *arg)
2263
{
2264
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2265
        fprintf(stderr, "Incorrect frame size\n");
2266
        exit(1);
2267
    }
2268
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2269
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2270
        exit(1);
2271
    }
2272
}
2273

    
2274

    
2275
#define SCALEBITS 10
2276
#define ONE_HALF  (1 << (SCALEBITS - 1))
2277
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
2278

    
2279
#define RGB_TO_Y(r, g, b) \
2280
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2281
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2282

    
2283
#define RGB_TO_U(r1, g1, b1, shift)\
2284
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2285
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2286

    
2287
#define RGB_TO_V(r1, g1, b1, shift)\
2288
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2289
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2290

    
2291
static void opt_pad_color(const char *arg) {
2292
    /* Input is expected to be six hex digits similar to
2293
       how colors are expressed in html tags (but without the #) */
2294
    int rgb = strtol(arg, NULL, 16);
2295
    int r,g,b;
2296
    
2297
    r = (rgb >> 16); 
2298
    g = ((rgb >> 8) & 255);
2299
    b = (rgb & 255);
2300

    
2301
    padcolor[0] = RGB_TO_Y(r,g,b);
2302
    padcolor[1] = RGB_TO_U(r,g,b,0);
2303
    padcolor[2] = RGB_TO_V(r,g,b,0);
2304
}
2305

    
2306
static void opt_frame_pad_top(const char *arg)
2307
{
2308
    frame_padtop = atoi(arg); 
2309
    if (frame_padtop < 0) {
2310
        fprintf(stderr, "Incorrect top pad size\n");
2311
        exit(1);
2312
    }
2313
    if ((frame_padtop % 2) != 0) {
2314
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2315
        exit(1);
2316
    }
2317
}
2318

    
2319
static void opt_frame_pad_bottom(const char *arg)
2320
{
2321
    frame_padbottom = atoi(arg); 
2322
    if (frame_padbottom < 0) {
2323
        fprintf(stderr, "Incorrect bottom pad size\n");
2324
        exit(1);
2325
    }
2326
    if ((frame_padbottom % 2) != 0) {
2327
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2328
        exit(1);
2329
    }
2330
}
2331

    
2332

    
2333
static void opt_frame_pad_left(const char *arg)
2334
{
2335
    frame_padleft = atoi(arg); 
2336
    if (frame_padleft < 0) {
2337
        fprintf(stderr, "Incorrect left pad size\n");
2338
        exit(1);
2339
    }
2340
    if ((frame_padleft % 2) != 0) {
2341
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2342
        exit(1);
2343
    }
2344
}
2345

    
2346

    
2347
static void opt_frame_pad_right(const char *arg)
2348
{
2349
    frame_padright = atoi(arg); 
2350
    if (frame_padright < 0) {
2351
        fprintf(stderr, "Incorrect right pad size\n");
2352
        exit(1);
2353
    }
2354
    if ((frame_padright % 2) != 0) {
2355
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2356
        exit(1);
2357
    }
2358
}
2359

    
2360

    
2361
static void opt_frame_pix_fmt(const char *arg)
2362
{
2363
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2364
}
2365

    
2366
static void opt_frame_aspect_ratio(const char *arg)
2367
{
2368
    int x = 0, y = 0;
2369
    double ar = 0;
2370
    const char *p;
2371
    
2372
    p = strchr(arg, ':');
2373
    if (p) {
2374
        x = strtol(arg, (char **)&arg, 10);
2375
        if (arg == p)
2376
            y = strtol(arg+1, (char **)&arg, 10);
2377
        if (x > 0 && y > 0)
2378
            ar = (double)x / (double)y;
2379
    } else
2380
        ar = strtod(arg, (char **)&arg);
2381

    
2382
    if (!ar) {
2383
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2384
        exit(1);
2385
    }
2386
    frame_aspect_ratio = ar;
2387
}
2388

    
2389
static void opt_gop_size(const char *arg)
2390
{
2391
    gop_size = atoi(arg);
2392
}
2393

    
2394
static void opt_b_frames(const char *arg)
2395
{
2396
    b_frames = atoi(arg);
2397
    if (b_frames > FF_MAX_B_FRAMES) {
2398
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2399
        exit(1);
2400
    } else if (b_frames < 1) {
2401
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2402
        exit(1);
2403
    }
2404
}
2405

    
2406
static void opt_mb_decision(const char *arg)
2407
{
2408
    mb_decision = atoi(arg);
2409
}
2410

    
2411
static void opt_mb_cmp(const char *arg)
2412
{
2413
    mb_cmp = atoi(arg);
2414
}
2415

    
2416
static void opt_ildct_cmp(const char *arg)
2417
{
2418
    ildct_cmp = atoi(arg);
2419
}
2420

    
2421
static void opt_sub_cmp(const char *arg)
2422
{
2423
    sub_cmp = atoi(arg);
2424
}
2425

    
2426
static void opt_cmp(const char *arg)
2427
{
2428
    cmp = atoi(arg);
2429
}
2430

    
2431
static void opt_pre_cmp(const char *arg)
2432
{
2433
    pre_cmp = atoi(arg);
2434
}
2435

    
2436
static void opt_pre_me(const char *arg)
2437
{
2438
    pre_me = atoi(arg);
2439
}
2440

    
2441
static void opt_lumi_mask(const char *arg)
2442
{
2443
    lumi_mask = atof(arg);
2444
}
2445

    
2446
static void opt_dark_mask(const char *arg)
2447
{
2448
    dark_mask = atof(arg);
2449
}
2450

    
2451
static void opt_scplx_mask(const char *arg)
2452
{
2453
    scplx_mask = atof(arg);
2454
}
2455

    
2456
static void opt_tcplx_mask(const char *arg)
2457
{
2458
    tcplx_mask = atof(arg);
2459
}
2460

    
2461
static void opt_p_mask(const char *arg)
2462
{
2463
    p_mask = atof(arg);
2464
}
2465

    
2466
static void opt_qscale(const char *arg)
2467
{
2468
    video_qscale = atof(arg);
2469
    if (video_qscale < 0.01 ||
2470
        video_qscale > 255) {
2471
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2472
        exit(1);
2473
    }
2474
}
2475

    
2476
static void opt_qsquish(const char *arg)
2477
{
2478
    video_qsquish = atof(arg);
2479
    if (video_qsquish < 0.0 ||
2480
        video_qsquish > 99.0) {
2481
        fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2482
        exit(1);
2483
    }
2484
}
2485

    
2486
static void opt_lelim(const char *arg)
2487
{
2488
    video_lelim = atoi(arg);
2489
    if (video_lelim < -99 ||
2490
        video_lelim > 99) {
2491
        fprintf(stderr, "lelim must be >= -99 and <= 99\n");
2492
        exit(1);
2493
    }
2494
}
2495

    
2496
static void opt_celim(const char *arg)
2497
{
2498
    video_celim = atoi(arg);
2499
    if (video_celim < -99 ||
2500
        video_celim > 99) {
2501
        fprintf(stderr, "celim must be >= -99 and <= 99\n");
2502
        exit(1);
2503
    }
2504
}
2505

    
2506
static void opt_lmax(const char *arg)
2507
{
2508
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2509
}
2510

    
2511
static void opt_lmin(const char *arg)
2512
{
2513
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2514
}
2515

    
2516
static void opt_qmin(const char *arg)
2517
{
2518
    video_qmin = atoi(arg);
2519
    if (video_qmin < 1 ||
2520
        video_qmin > 31) {
2521
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2522
        exit(1);
2523
    }
2524
}
2525

    
2526
static void opt_qmax(const char *arg)
2527
{
2528
    video_qmax = atoi(arg);
2529
    if (video_qmax < 1 ||
2530
        video_qmax > 31) {
2531
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2532
        exit(1);
2533
    }
2534
}
2535

    
2536
static void opt_mb_lmin(const char *arg)
2537
{
2538
    video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2539
    if (video_mb_lmin < 1 ||
2540
        video_mb_lmin > FF_LAMBDA_MAX) {
2541
        fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2542
        exit(1);
2543
    }
2544
}
2545

    
2546
static void opt_mb_lmax(const char *arg)
2547
{
2548
    video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2549
    if (video_mb_lmax < 1 ||
2550
        video_mb_lmax > FF_LAMBDA_MAX) {
2551
        fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2552
        exit(1);
2553
    }
2554
}
2555

    
2556
static void opt_qdiff(const char *arg)
2557
{
2558
    video_qdiff = atoi(arg);
2559
    if (video_qdiff < 0 ||
2560
        video_qdiff > 31) {
2561
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2562
        exit(1);
2563
    }
2564
}
2565

    
2566
static void opt_qblur(const char *arg)
2567
{
2568
    video_qblur = atof(arg);
2569
}
2570

    
2571
static void opt_qcomp(const char *arg)
2572
{
2573
    video_qcomp = atof(arg);
2574
}
2575

    
2576
static void opt_rc_initial_cplx(const char *arg)
2577
{
2578
    video_rc_initial_cplx = atof(arg);
2579
}
2580
static void opt_b_qfactor(const char *arg)
2581
{
2582
    video_b_qfactor = atof(arg);
2583
}
2584
static void opt_i_qfactor(const char *arg)
2585
{
2586
    video_i_qfactor = atof(arg);
2587
}
2588
static void opt_b_qoffset(const char *arg)
2589
{
2590
    video_b_qoffset = atof(arg);
2591
}
2592
static void opt_i_qoffset(const char *arg)
2593
{
2594
    video_i_qoffset = atof(arg);
2595
}
2596

    
2597
static void opt_ibias(const char *arg)
2598
{
2599
    video_intra_quant_bias = atoi(arg);
2600
}
2601
static void opt_pbias(const char *arg)
2602
{
2603
    video_inter_quant_bias = atoi(arg);
2604
}
2605

    
2606
static void opt_packet_size(const char *arg)
2607
{
2608
    packet_size= atoi(arg);
2609
}
2610

    
2611
static void opt_error_rate(const char *arg)
2612
{
2613
    error_rate= atoi(arg);
2614
}
2615

    
2616
static void opt_strict(const char *arg)
2617
{
2618
    strict= atoi(arg);
2619
}
2620

    
2621
static void opt_top_field_first(const char *arg)
2622
{
2623
    top_field_first= atoi(arg);
2624
}
2625

    
2626
static void opt_noise_reduction(const char *arg)
2627
{
2628
    noise_reduction= atoi(arg);
2629
}
2630

    
2631
static void opt_qns(const char *arg)
2632
{
2633
    qns= atoi(arg);
2634
}
2635

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

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

    
2646
static void opt_thread_count(const char *arg)
2647
{
2648
    thread_count= atoi(arg);
2649
#if !defined(HAVE_THREADS)
2650
    if (verbose >= 0)
2651
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2652
#endif
2653
}
2654

    
2655
static void opt_audio_bitrate(const char *arg)
2656
{
2657
    audio_bit_rate = atoi(arg) * 1000;
2658
}
2659

    
2660
static void opt_audio_rate(const char *arg)
2661
{
2662
    audio_sample_rate = atoi(arg);
2663
}
2664

    
2665
static void opt_audio_channels(const char *arg)
2666
{
2667
    audio_channels = atoi(arg);
2668
}
2669

    
2670
static void opt_video_device(const char *arg)
2671
{
2672
    video_device = av_strdup(arg);
2673
}
2674

    
2675
static void opt_grab_device(const char *arg)
2676
{
2677
    grab_device = av_strdup(arg);
2678
}
2679

    
2680
static void opt_video_channel(const char *arg)
2681
{
2682
    video_channel = strtol(arg, NULL, 0);
2683
}
2684

    
2685
static void opt_video_standard(const char *arg)
2686
{
2687
    video_standard = av_strdup(arg);
2688
}
2689

    
2690
static void opt_audio_device(const char *arg)
2691
{
2692
    audio_device = av_strdup(arg);
2693
}
2694

    
2695
static void opt_audio_codec(const char *arg)
2696
{
2697
    AVCodec *p;
2698

    
2699
    if (!strcmp(arg, "copy")) {
2700
        audio_stream_copy = 1;
2701
    } else {
2702
        p = first_avcodec;
2703
        while (p) {
2704
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2705
                break;
2706
            p = p->next;
2707
        }
2708
        if (p == NULL) {
2709
            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2710
            exit(1);
2711
        } else {
2712
            audio_codec_id = p->id;
2713
        }
2714
    }
2715
}
2716

    
2717
static void opt_audio_tag(const char *arg)
2718
{
2719
    char *tail;
2720
    audio_codec_tag= strtol(arg, &tail, 0);
2721

    
2722
    if(!tail || *tail)
2723
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2724
}
2725

    
2726
static void opt_video_tag(const char *arg)
2727
{
2728
    char *tail;
2729
    video_codec_tag= strtol(arg, &tail, 0);
2730

    
2731
    if(!tail || *tail)
2732
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2733
}
2734

    
2735
static void add_frame_hooker(const char *arg)
2736
{
2737
    int argc = 0;
2738
    char *argv[64];
2739
    int i;
2740
    char *args = av_strdup(arg);
2741

    
2742
    using_vhook = 1;
2743

    
2744
    argv[0] = strtok(args, " ");
2745
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2746
    }
2747

    
2748
    i = frame_hook_add(argc, argv);
2749

    
2750
    if (i != 0) {
2751
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2752
        exit(1);
2753
    }
2754
}
2755

    
2756
const char *motion_str[] = {
2757
    "zero",
2758
    "full",
2759
    "log",
2760
    "phods",
2761
    "epzs",
2762
    "x1",
2763
    NULL,
2764
};
2765

    
2766
static void opt_motion_estimation(const char *arg)
2767
{
2768
    const char **p;
2769
    p = motion_str;
2770
    for(;;) {
2771
        if (!*p) {
2772
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2773
            exit(1);
2774
        }
2775
        if (!strcmp(*p, arg))
2776
            break;
2777
        p++;
2778
    }
2779
    me_method = (p - motion_str) + 1;
2780
}
2781

    
2782
static void opt_video_codec(const char *arg)
2783
{
2784
    AVCodec *p;
2785

    
2786
    if (!strcmp(arg, "copy")) {
2787
        video_stream_copy = 1;
2788
    } else {
2789
        p = first_avcodec;
2790
        while (p) {
2791
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2792
                break;
2793
            p = p->next;
2794
        }
2795
        if (p == NULL) {
2796
            fprintf(stderr, "Unknown video codec '%s'\n", arg);
2797
            exit(1);
2798
        } else {
2799
            video_codec_id = p->id;
2800
        }
2801
    }
2802
}
2803

    
2804
static void opt_map(const char *arg)
2805
{
2806
    AVStreamMap *m;
2807
    const char *p;
2808

    
2809
    p = arg;
2810
    m = &stream_maps[nb_stream_maps++];
2811

    
2812
    m->file_index = strtol(arg, (char **)&p, 0);
2813
    if (*p)
2814
        p++;
2815

    
2816
    m->stream_index = strtol(p, (char **)&p, 0);
2817
}
2818

    
2819
static void opt_map_meta_data(const char *arg)
2820
{
2821
    AVMetaDataMap *m;
2822
    const char *p;
2823
        
2824
    p = arg;
2825
    m = &meta_data_maps[nb_meta_data_maps++];
2826

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

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

    
2834
static void opt_recording_time(const char *arg)
2835
{
2836
    recording_time = parse_date(arg, 1);
2837
}
2838

    
2839
static void opt_start_time(const char *arg)
2840
{
2841
    start_time = parse_date(arg, 1);
2842
}
2843

    
2844
static void opt_rec_timestamp(const char *arg)
2845
{
2846
    rec_timestamp = parse_date(arg, 0) / 1000000;
2847
}
2848

    
2849
static void opt_input_ts_offset(const char *arg)
2850
{
2851
    input_ts_offset = parse_date(arg, 1);
2852
}
2853

    
2854
static void opt_input_file(const char *filename)
2855
{
2856
    AVFormatContext *ic;
2857
    AVFormatParameters params, *ap = &params;
2858
    int err, i, ret, rfps, rfps_base;
2859
    int64_t timestamp;
2860

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

    
2864
    using_stdin |= !strncmp(filename, "pipe:", 5) || 
2865
                   !strcmp( filename, "/dev/stdin" );
2866

    
2867
    /* get default parameters from command line */
2868
    memset(ap, 0, sizeof(*ap));
2869
    ap->sample_rate = audio_sample_rate;
2870
    ap->channels = audio_channels;
2871
    ap->frame_rate = frame_rate;
2872
    ap->frame_rate_base = frame_rate_base;
2873
    ap->width = frame_width + frame_padleft + frame_padright;
2874
    ap->height = frame_height + frame_padtop + frame_padbottom;
2875
    ap->image_format = image_format;
2876
    ap->pix_fmt = frame_pix_fmt;
2877
    ap->device  = grab_device;
2878
    ap->channel = video_channel;
2879
    ap->standard = video_standard;
2880
    ap->video_codec_id = video_codec_id;
2881
    ap->audio_codec_id = audio_codec_id;
2882
    if(pgmyuv_compatibility_hack)
2883
        ap->video_codec_id= CODEC_ID_PGMYUV;
2884

    
2885
    /* open the input file with generic libav function */
2886
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2887
    if (err < 0) {
2888
        print_error(filename, err);
2889
        exit(1);
2890
    }
2891
    
2892
    /* If not enough info to get the stream parameters, we decode the
2893
       first frames to get it. (used in mpeg case for example) */
2894
    ret = av_find_stream_info(ic);
2895
    if (ret < 0 && verbose >= 0) {
2896
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2897
        exit(1);
2898
    }
2899

    
2900
    timestamp = start_time;
2901
    /* add the stream start time */
2902
    if (ic->start_time != AV_NOPTS_VALUE)
2903
        timestamp += ic->start_time;
2904

    
2905
    /* if seeking requested, we execute it */
2906
    if (start_time != 0) {
2907
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2908
        if (ret < 0) {
2909
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
2910
                    filename, (double)timestamp / AV_TIME_BASE);
2911
        }
2912
        /* reset seek info */
2913
        start_time = 0;
2914
    }
2915

    
2916
    /* update the current parameters so that they match the one of the input stream */
2917
    for(i=0;i<ic->nb_streams;i++) {
2918
        AVCodecContext *enc = &ic->streams[i]->codec;
2919
#if defined(HAVE_THREADS)
2920
        if(thread_count>1)
2921
            avcodec_thread_init(enc, thread_count);
2922
#endif
2923
        enc->thread_count= thread_count;
2924
        switch(enc->codec_type) {
2925
        case CODEC_TYPE_AUDIO:
2926
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2927
            audio_channels = enc->channels;
2928
            audio_sample_rate = enc->sample_rate;
2929
            if(audio_disable)
2930
                ic->streams[i]->discard= AVDISCARD_ALL;
2931
            break;
2932
        case CODEC_TYPE_VIDEO:
2933
            frame_height = enc->height;
2934
            frame_width = enc->width;
2935
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2936
            frame_pix_fmt = enc->pix_fmt;
2937
            rfps      = ic->streams[i]->r_frame_rate;
2938
            rfps_base = ic->streams[i]->r_frame_rate_base;
2939
            enc->workaround_bugs = workaround_bugs;
2940
            enc->error_resilience = error_resilience; 
2941
            enc->error_concealment = error_concealment; 
2942
            enc->idct_algo = idct_algo;
2943
            enc->debug = debug;
2944
            enc->debug_mv = debug_mv;            
2945
            enc->lowres= lowres;
2946
            if(bitexact)
2947
                enc->flags|= CODEC_FLAG_BITEXACT;
2948
            if(me_threshold)
2949
                enc->debug |= FF_DEBUG_MV;
2950

    
2951
            if (enc->frame_rate != rfps || enc->frame_rate_base != rfps_base) { 
2952

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

    
2957
                    (float)rfps / rfps_base, rfps, rfps_base);
2958
            }
2959
            /* update the current frame rate to match the stream frame rate */
2960
            frame_rate      = rfps;
2961
            frame_rate_base = rfps_base;
2962

    
2963
            enc->rate_emu = rate_emu;
2964
            if(video_disable)
2965
                ic->streams[i]->discard= AVDISCARD_ALL;
2966
            else if(video_discard)
2967
                ic->streams[i]->discard= video_discard;
2968
            break;
2969
        case CODEC_TYPE_DATA:
2970
            break;
2971
        default:
2972
            av_abort();
2973
        }
2974
    }
2975
    
2976
    input_files[nb_input_files] = ic;
2977
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2978
    /* dump the file content */
2979
    if (verbose >= 0)
2980
        dump_format(ic, nb_input_files, filename, 0);
2981

    
2982
    nb_input_files++;
2983
    file_iformat = NULL;
2984
    file_oformat = NULL;
2985
    image_format = NULL;
2986

    
2987
    grab_device = NULL;
2988
    video_channel = 0;
2989
    
2990
    rate_emu = 0;
2991
}
2992

    
2993
static void opt_grab(const char *arg)
2994
{
2995
    file_iformat = av_find_input_format(arg);
2996
    opt_input_file("");
2997
}
2998

    
2999
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3000
{
3001
    int has_video, has_audio, i, j;
3002
    AVFormatContext *ic;
3003

    
3004
    has_video = 0;
3005
    has_audio = 0;
3006
    for(j=0;j<nb_input_files;j++) {
3007
        ic = input_files[j];
3008
        for(i=0;i<ic->nb_streams;i++) {
3009
            AVCodecContext *enc = &ic->streams[i]->codec;
3010
            switch(enc->codec_type) {
3011
            case CODEC_TYPE_AUDIO:
3012
                has_audio = 1;
3013
                break;
3014
            case CODEC_TYPE_VIDEO:
3015
                has_video = 1;
3016
                break;
3017
            case CODEC_TYPE_DATA:
3018
                break;
3019
            default:
3020
                av_abort();
3021
            }
3022
        }
3023
    }
3024
    *has_video_ptr = has_video;
3025
    *has_audio_ptr = has_audio;
3026
}
3027

    
3028
static void opt_output_file(const char *filename)
3029
{
3030
    AVStream *st;
3031
    AVFormatContext *oc;
3032
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
3033
    int codec_id;
3034
    AVFormatParameters params, *ap = &params;
3035

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

    
3039
    oc = av_alloc_format_context();
3040

    
3041
    if (!file_oformat) {
3042
        file_oformat = guess_format(NULL, filename, NULL);
3043
        if (!file_oformat) {
3044
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3045
                    filename);
3046
            exit(1);
3047
        }
3048
    }
3049
    
3050
    oc->oformat = file_oformat;
3051

    
3052
    if (!strcmp(file_oformat->name, "ffm") && 
3053
        strstart(filename, "http:", NULL)) {
3054
        /* special case for files sent to ffserver: we get the stream
3055
           parameters from ffserver */
3056
        if (read_ffserver_streams(oc, filename) < 0) {
3057
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3058
            exit(1);
3059
        }
3060
    } else {
3061
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
3062
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
3063

    
3064
        /* disable if no corresponding type found and at least one
3065
           input file */
3066
        if (nb_input_files > 0) {
3067
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3068
            if (!input_has_video)
3069
                use_video = 0;
3070
            if (!input_has_audio)
3071
                use_audio = 0;
3072
        }
3073

    
3074
        /* manual disable */
3075
        if (audio_disable) {
3076
            use_audio = 0;
3077
        }
3078
        if (video_disable) {
3079
            use_video = 0;
3080
        }
3081
        
3082
        nb_streams = 0;
3083
        if (use_video) {
3084
            AVCodecContext *video_enc;
3085
            
3086
            st = av_new_stream(oc, nb_streams++);
3087
            if (!st) {
3088
                fprintf(stderr, "Could not alloc stream\n");
3089
                exit(1);
3090
            }
3091
#if defined(HAVE_THREADS)
3092
            if(thread_count>1)
3093
                avcodec_thread_init(&st->codec, thread_count);
3094
#endif
3095

    
3096
            video_enc = &st->codec;
3097
            
3098
            if(video_codec_tag)
3099
                video_enc->codec_tag= video_codec_tag;
3100
                
3101
            if (file_oformat->flags & AVFMT_GLOBALHEADER) 
3102
                video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3103
            if (video_stream_copy) {
3104
                st->stream_copy = 1;
3105
                video_enc->codec_type = CODEC_TYPE_VIDEO;
3106
            } else {
3107
                char *p;
3108
                int i;
3109
                AVCodec *codec;
3110
            
3111
                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
3112
                if (video_codec_id != CODEC_ID_NONE)
3113
                    codec_id = video_codec_id;
3114
                
3115
                video_enc->codec_id = codec_id;
3116
                codec = avcodec_find_encoder(codec_id);
3117
                
3118
                video_enc->bit_rate = video_bit_rate;
3119
                video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3120
                video_enc->frame_rate = frame_rate; 
3121
                video_enc->frame_rate_base = frame_rate_base; 
3122
                if(codec && codec->supported_framerates){
3123
                    const AVRational *p= codec->supported_framerates;
3124
                    AVRational req= (AVRational){frame_rate, frame_rate_base};
3125
                    const AVRational *best=NULL;
3126
                    AVRational best_error= (AVRational){INT_MAX, 1};
3127
                    for(; p->den!=0; p++){
3128
                        AVRational error= av_sub_q(req, *p);
3129
                        if(error.num <0) error.num *= -1;
3130
                        if(av_cmp_q(error, best_error) < 0){
3131
                            best_error= error;
3132
                            best= p;
3133
                        }
3134
                    }
3135
                    video_enc->frame_rate     = best->num;
3136
                    video_enc->frame_rate_base= best->den;
3137
                }
3138
                
3139
                video_enc->width = frame_width + frame_padright + frame_padleft;
3140
                video_enc->height = frame_height + frame_padtop + frame_padbottom;
3141
                video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3142
                video_enc->pix_fmt = frame_pix_fmt;
3143

    
3144
                if(codec && codec->pix_fmts){
3145
                    const enum PixelFormat *p= codec->pix_fmts;
3146
                    for(; *p!=-1; p++){
3147
                        if(*p == video_enc->pix_fmt)
3148
                            break;
3149
                    }
3150
                    if(*p == -1)
3151
                        video_enc->pix_fmt = codec->pix_fmts[0];
3152
                }
3153

    
3154
                if (!intra_only)
3155
                    video_enc->gop_size = gop_size;
3156
                else
3157
                    video_enc->gop_size = 0;
3158
                if (video_qscale || same_quality) {
3159
                    video_enc->flags |= CODEC_FLAG_QSCALE;
3160
                    video_enc->global_quality= 
3161
                    st->quality = FF_QP2LAMBDA * video_qscale;
3162
                }
3163

    
3164
                if(intra_matrix)
3165
                    video_enc->intra_matrix = intra_matrix;
3166
                if(inter_matrix)
3167
                    video_enc->inter_matrix = inter_matrix;
3168

    
3169
                if(bitexact)
3170
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
3171

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

    
3298
                video_enc->rc_max_rate = video_rc_max_rate;
3299
                video_enc->rc_min_rate = video_rc_min_rate;
3300
                video_enc->rc_buffer_size = video_rc_buffer_size;
3301
                video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3302
                video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3303
                video_enc->rc_initial_cplx= video_rc_initial_cplx;
3304
                video_enc->i_quant_factor = video_i_qfactor;
3305
                video_enc->b_quant_factor = video_b_qfactor;
3306
                video_enc->i_quant_offset = video_i_qoffset;
3307
                video_enc->b_quant_offset = video_b_qoffset;
3308
                video_enc->intra_quant_bias = video_intra_quant_bias;
3309
                video_enc->inter_quant_bias = video_inter_quant_bias;
3310
                video_enc->dct_algo = dct_algo;
3311
                video_enc->idct_algo = idct_algo;
3312
                video_enc->me_threshold= me_threshold;
3313
                video_enc->mb_threshold= mb_threshold;
3314
                video_enc->intra_dc_precision= intra_dc_precision - 8;
3315
                video_enc->strict_std_compliance = strict;
3316
                video_enc->error_rate = error_rate;
3317
                video_enc->noise_reduction= noise_reduction;
3318
                video_enc->scenechange_threshold= sc_threshold;
3319
                video_enc->me_range = me_range;
3320
                video_enc->coder_type= coder;
3321
                video_enc->context_model= context;
3322
                video_enc->prediction_method= predictor;
3323
                video_enc->profile= video_profile;
3324
                video_enc->level= video_level;
3325
                video_enc->nsse_weight= nsse_weight;
3326
                video_enc->me_subpel_quality= subpel_quality;
3327
                video_enc->frame_skip_threshold= frame_skip_threshold;
3328
                video_enc->frame_skip_factor= frame_skip_factor;
3329
                video_enc->frame_skip_exp= frame_skip_exp;
3330
                video_enc->frame_skip_cmp= frame_skip_cmp;
3331

    
3332
                if(packet_size){
3333
                    video_enc->rtp_mode= 1;
3334
                    video_enc->rtp_payload_size= packet_size;
3335
                }
3336
            
3337
                if (do_psnr)
3338
                    video_enc->flags|= CODEC_FLAG_PSNR;
3339
            
3340
                video_enc->me_method = me_method;
3341

    
3342
                /* two pass mode */
3343
                if (do_pass) {
3344
                    if (do_pass == 1) {
3345
                        video_enc->flags |= CODEC_FLAG_PASS1;
3346
                    } else {
3347
                        video_enc->flags |= CODEC_FLAG_PASS2;
3348
                    }
3349
                }
3350
            }
3351
        }
3352
    
3353
        if (use_audio) {
3354
            AVCodecContext *audio_enc;
3355

    
3356
            st = av_new_stream(oc, nb_streams++);
3357
            if (!st) {
3358
                fprintf(stderr, "Could not alloc stream\n");
3359
                exit(1);
3360
            }
3361
#if defined(HAVE_THREADS)
3362
            if(thread_count>1)
3363
                avcodec_thread_init(&st->codec, thread_count);
3364
#endif
3365

    
3366
            audio_enc = &st->codec;
3367
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3368

    
3369
            if(audio_codec_tag)
3370
                audio_enc->codec_tag= audio_codec_tag;
3371

    
3372
            if (file_oformat->flags & AVFMT_GLOBALHEADER) 
3373
                audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3374
            if (audio_stream_copy) {
3375
                st->stream_copy = 1;
3376
                audio_enc->channels = audio_channels;
3377
            } else {
3378
                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
3379
                if (audio_codec_id != CODEC_ID_NONE)
3380
                    codec_id = audio_codec_id;
3381
                audio_enc->codec_id = codec_id;
3382
                
3383
                audio_enc->bit_rate = audio_bit_rate;
3384
                audio_enc->strict_std_compliance = strict;
3385
                audio_enc->thread_count = thread_count;
3386
                /* For audio codecs other than AC3 or DTS we limit */
3387
                /* the number of coded channels to stereo   */
3388
                if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3389
                    && codec_id != CODEC_ID_DTS) {
3390
                    audio_enc->channels = 2;
3391
                } else
3392
                    audio_enc->channels = audio_channels;
3393
            }
3394
            audio_enc->sample_rate = audio_sample_rate;
3395
        }
3396

    
3397
        oc->nb_streams = nb_streams;
3398

    
3399
        if (!nb_streams) {
3400
            fprintf(stderr, "No audio or video streams available\n");
3401
            exit(1);
3402
        }
3403

    
3404
        oc->timestamp = rec_timestamp;
3405
            
3406
        if (str_title)
3407
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3408
        if (str_author)
3409
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3410
        if (str_copyright)
3411
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3412
        if (str_comment)
3413
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3414
    }
3415

    
3416
    output_files[nb_output_files++] = oc;
3417

    
3418
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3419

    
3420
    /* check filename in case of an image number is expected */
3421
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3422
        if (filename_number_test(oc->filename) < 0) {
3423
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3424
            exit(1);
3425
        }
3426
    }
3427

    
3428
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3429
        /* test if it already exists to avoid loosing precious files */
3430
        if (!file_overwrite && 
3431
            (strchr(filename, ':') == NULL ||
3432
             strstart(filename, "file:", NULL))) {
3433
            if (url_exist(filename)) {
3434
                int c;
3435
                
3436
                if ( !using_stdin ) {
3437
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3438
                    fflush(stderr);
3439
                    c = getchar();
3440
                    if (toupper(c) != 'Y') {
3441
                        fprintf(stderr, "Not overwriting - exiting\n");
3442
                        exit(1);
3443
                    }
3444
                                }
3445
                                else {
3446
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3447
                    exit(1);
3448
                                }
3449
            }
3450
        }
3451
        
3452
        /* open the file */
3453
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3454
            fprintf(stderr, "Could not open '%s'\n", filename);
3455
            exit(1);
3456
        }
3457
    }
3458

    
3459
    memset(ap, 0, sizeof(*ap));
3460
    ap->image_format = image_format;
3461
    if (av_set_parameters(oc, ap) < 0) {
3462
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3463
                oc->filename);
3464
        exit(1);
3465
    }
3466

    
3467
    oc->packet_size= mux_packet_size;
3468
    oc->mux_rate= mux_rate;
3469
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3470
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3471

    
3472
    /* reset some options */
3473
    file_oformat = NULL;
3474
    file_iformat = NULL;
3475
    image_format = NULL;
3476
    audio_disable = 0;
3477
    video_disable = 0;
3478
    audio_codec_id = CODEC_ID_NONE;
3479
    video_codec_id = CODEC_ID_NONE;
3480
    audio_stream_copy = 0;
3481
    video_stream_copy = 0;
3482
}
3483

    
3484
/* prepare dummy protocols for grab */
3485
static void prepare_grab(void)
3486
{
3487
    int has_video, has_audio, i, j;
3488
    AVFormatContext *oc;
3489
    AVFormatContext *ic;
3490
    AVFormatParameters vp1, *vp = &vp1;
3491
    AVFormatParameters ap1, *ap = &ap1;
3492
    
3493
    /* see if audio/video inputs are needed */
3494
    has_video = 0;
3495
    has_audio = 0;
3496
    memset(ap, 0, sizeof(*ap));
3497
    memset(vp, 0, sizeof(*vp));
3498
    vp->frame_rate_base= 1;
3499
    for(j=0;j<nb_output_files;j++) {
3500
        oc = output_files[j];
3501
        for(i=0;i<oc->nb_streams;i++) {
3502
            AVCodecContext *enc = &oc->streams[i]->codec;
3503
            switch(enc->codec_type) {
3504
            case CODEC_TYPE_AUDIO:
3505
                if (enc->sample_rate > ap->sample_rate)
3506
                    ap->sample_rate = enc->sample_rate;
3507
                if (enc->channels > ap->channels)
3508
                    ap->channels = enc->channels;
3509
                has_audio = 1;
3510
                break;
3511
            case CODEC_TYPE_VIDEO:
3512
                if (enc->width > vp->width)
3513
                    vp->width = enc->width;
3514
                if (enc->height > vp->height)
3515
                    vp->height = enc->height;
3516
                
3517
                if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3518
                    vp->frame_rate      = enc->frame_rate;
3519
                    vp->frame_rate_base = enc->frame_rate_base;
3520
                }
3521
                has_video = 1;
3522
                break;
3523
            default:
3524
                av_abort();
3525
            }
3526
        }
3527
    }
3528
    
3529
    if (has_video == 0 && has_audio == 0) {
3530
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3531
        exit(1);
3532
    }
3533
    
3534
    if (has_video) {
3535
        AVInputFormat *fmt1;
3536
        fmt1 = av_find_input_format(video_grab_format);
3537
        vp->device  = video_device;
3538
        vp->channel = video_channel;
3539
        vp->standard = video_standard;
3540
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3541
            fprintf(stderr, "Could not find video grab device\n");
3542
            exit(1);
3543
        }
3544
        /* If not enough info to get the stream parameters, we decode the
3545
           first frames to get it. */
3546
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3547
            fprintf(stderr, "Could not find video grab parameters\n");
3548
            exit(1);
3549
        }
3550
        /* by now video grab has one stream */
3551
        ic->streams[0]->r_frame_rate      = vp->frame_rate;
3552
        ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3553
        input_files[nb_input_files] = ic;
3554

    
3555
        if (verbose >= 0)
3556
            dump_format(ic, nb_input_files, "", 0);
3557

    
3558
        nb_input_files++;
3559
    }
3560
    if (has_audio && audio_grab_format) {
3561
        AVInputFormat *fmt1;
3562
        fmt1 = av_find_input_format(audio_grab_format);
3563
        ap->device = audio_device;
3564
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3565
            fprintf(stderr, "Could not find audio grab device\n");
3566
            exit(1);
3567
        }
3568
        input_files[nb_input_files] = ic;
3569

    
3570
        if (verbose >= 0)
3571
            dump_format(ic, nb_input_files, "", 0);
3572

    
3573
        nb_input_files++;
3574
    }
3575
}
3576

    
3577
/* same option as mencoder */
3578
static void opt_pass(const char *pass_str)
3579
{
3580
    int pass;
3581
    pass = atoi(pass_str);
3582
    if (pass != 1 && pass != 2) {
3583
        fprintf(stderr, "pass number can be only 1 or 2\n");
3584
        exit(1);
3585
    }
3586
    do_pass = pass;
3587
}
3588

    
3589
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3590
static int64_t getutime(void)
3591
{
3592
  return av_gettime();
3593
}
3594
#else
3595
static int64_t getutime(void)
3596
{
3597
    struct rusage rusage;
3598

    
3599
    getrusage(RUSAGE_SELF, &rusage);
3600
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3601
}
3602
#endif
3603

    
3604
extern int ffm_nopts;
3605

    
3606
static void opt_bitexact(void)
3607
{
3608
    bitexact=1;
3609
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3610
    ffm_nopts = 1;
3611
}
3612

    
3613
static void show_formats(void)
3614
{
3615
    AVInputFormat *ifmt;
3616
    AVOutputFormat *ofmt;
3617
    AVImageFormat *image_fmt;
3618
    URLProtocol *up;
3619
    AVCodec *p, *p2;
3620
    const char **pp, *last_name;
3621

    
3622
    printf("File formats:\n");
3623
    last_name= "000";
3624
    for(;;){
3625
        int decode=0;
3626
        int encode=0;
3627
        const char *name=NULL;
3628
        const char *long_name=NULL;
3629

    
3630
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3631
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3632
                strcmp(ofmt->name, last_name)>0){
3633
                name= ofmt->name;
3634
                long_name= ofmt->long_name;
3635
                encode=1;
3636
            }
3637
        }
3638
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3639
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3640
                strcmp(ifmt->name, last_name)>0){
3641
                name= ifmt->name;
3642
                long_name= ifmt->long_name;
3643
                encode=0;
3644
            }
3645
            if(name && strcmp(ifmt->name, name)==0)
3646
                decode=1;
3647
        }
3648
        if(name==NULL)
3649
            break;
3650
        last_name= name;
3651
        
3652
        printf(
3653
            " %s%s %-15s %s\n", 
3654
            decode ? "D":" ", 
3655
            encode ? "E":" ", 
3656
            name,
3657
            long_name ? long_name:" ");
3658
    }
3659
    printf("\n");
3660

    
3661
    printf("Image formats (filename extensions, if any, follow):\n");
3662
    for(image_fmt = first_image_format; image_fmt != NULL; 
3663
        image_fmt = image_fmt->next) {
3664
        printf(
3665
            " %s%s %-6s %s\n",
3666
            image_fmt->img_read  ? "D":" ",
3667
            image_fmt->img_write ? "E":" ",
3668
            image_fmt->name,
3669
            image_fmt->extensions ? image_fmt->extensions:" ");
3670
    }
3671
    printf("\n");
3672

    
3673
    printf("Codecs:\n");
3674
    last_name= "000";
3675
    for(;;){
3676
        int decode=0;
3677
        int encode=0;
3678
        int cap=0;
3679

    
3680
        p2=NULL;
3681
        for(p = first_avcodec; p != NULL; p = p->next) {
3682
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3683
                strcmp(p->name, last_name)>0){
3684
                p2= p;
3685
                decode= encode= cap=0;
3686
            }
3687
            if(p2 && strcmp(p->name, p2->name)==0){
3688
                if(p->decode) decode=1;
3689
                if(p->encode) encode=1;
3690
                cap |= p->capabilities;
3691
            }
3692
        }
3693
        if(p2==NULL)
3694
            break;
3695
        last_name= p2->name;
3696
        
3697
        printf(
3698
            " %s%s%s%s%s%s %s", 
3699
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
3700
            encode ? "E":" ", 
3701
            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3702
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3703
            cap & CODEC_CAP_DR1 ? "D":" ",
3704
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3705
            p2->name);
3706
       /* if(p2->decoder && decode==0)
3707
            printf(" use %s for decoding", p2->decoder->name);*/
3708
        printf("\n");
3709
    }
3710
    printf("\n");
3711

    
3712
    printf("Supported file protocols:\n");
3713
    for(up = first_protocol; up != NULL; up = up->next)
3714
        printf(" %s:", up->name);
3715
    printf("\n");
3716
    
3717
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3718
    printf("Motion estimation methods:\n");
3719
    pp = motion_str;
3720
    while (*pp) {
3721
        printf(" %s", *pp);
3722
        if ((pp - motion_str + 1) == ME_ZERO) 
3723
            printf("(fastest)");
3724
        else if ((pp - motion_str + 1) == ME_FULL) 
3725
            printf("(slowest)");
3726
        else if ((pp - motion_str + 1) == ME_EPZS) 
3727
            printf("(default)");
3728
        pp++;
3729
    }
3730
    printf("\n\n");
3731
    printf(
3732
"Note, the names of encoders and decoders dont always match, so there are\n"
3733
"several cases where the above table shows encoder only or decoder only entries\n"
3734
"even though both encoding and decoding are supported for example, the h263\n"
3735
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3736
"worse\n");
3737
    exit(1);
3738
}
3739

    
3740
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3741
{
3742
    int i;
3743
    const char *p = str;
3744
    for(i = 0;; i++) {
3745
        dest[i] = atoi(p);
3746
        if(i == 63)
3747
            break;
3748
        p = strchr(p, ',');
3749
        if(!p) {
3750
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3751
            exit(1);
3752
        }
3753
        p++;
3754
    }
3755
}
3756

    
3757
void opt_inter_matrix(const char *arg)
3758
{
3759
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3760
    parse_matrix_coeffs(inter_matrix, arg);
3761
}
3762

    
3763
void opt_intra_matrix(const char *arg)
3764
{
3765
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3766
    parse_matrix_coeffs(intra_matrix, arg);
3767
}
3768

    
3769
static void opt_target(const char *arg)
3770
{
3771
    int norm = -1;
3772
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3773

    
3774
    if(!strncmp(arg, "pal-", 4)) {
3775
        norm = 0;
3776
        arg += 4;
3777
    } else if(!strncmp(arg, "ntsc-", 5)) {
3778
        norm = 1;
3779
        arg += 5;
3780
    } else if(!strncmp(arg, "film-", 5)) {
3781
        norm = 2;
3782
        arg += 5;
3783
    } else {
3784
        int fr;
3785
        /* Calculate FR via float to avoid int overflow */
3786
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3787
        if(fr == 25000) {
3788
            norm = 0;
3789
        } else if((fr == 29970) || (fr == 23976)) {
3790
            norm = 1;
3791
        } else {
3792
            /* Try to determine PAL/NTSC by peeking in the input files */
3793
            if(nb_input_files) {
3794
                int i, j;
3795
                for(j = 0; j < nb_input_files; j++) {
3796
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3797
                        AVCodecContext *c = &input_files[j]->streams[i]->codec;
3798
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3799
                            continue;
3800
                        fr = c->frame_rate * 1000 / c->frame_rate_base;
3801
                        if(fr == 25000) {
3802
                            norm = 0;
3803
                            break;
3804
                        } else if((fr == 29970) || (fr == 23976)) {
3805
                            norm = 1;
3806
                            break;
3807
                        }
3808
                    }
3809
                    if(norm >= 0)
3810
                        break;
3811
                }
3812
            }
3813
        }
3814
        if(verbose && norm >= 0)
3815
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3816
    }
3817

    
3818
    if(norm < 0) {
3819
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3820
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3821
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3822
        exit(1);
3823
    }
3824

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

    
3827
        opt_video_codec("mpeg1video");
3828
        opt_audio_codec("mp2");
3829
        opt_format("vcd");
3830

    
3831
        opt_frame_size(norm ? "352x240" : "352x288");
3832
        opt_frame_rate(frame_rates[norm]);
3833
        opt_gop_size(norm ? "18" : "15");
3834

    
3835
        video_bit_rate = 1150000;
3836
        video_rc_max_rate = 1150000;
3837
        video_rc_min_rate = 1150000;
3838
        video_rc_buffer_size = 40*1024*8;
3839

    
3840
        audio_bit_rate = 224000;
3841
        audio_sample_rate = 44100;
3842
        
3843
        mux_packet_size= 2324;
3844
        mux_rate= 2352 * 75 * 8;
3845

    
3846
        /* We have to offset the PTS, so that it is consistent with the SCR.
3847
           SCR starts at 36000, but the first two packs contain only padding
3848
           and the first pack from the other stream, respectively, may also have
3849
           been written before.
3850
           So the real data starts at SCR 36000+3*1200. */
3851
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3852
    } else if(!strcmp(arg, "svcd")) {
3853

    
3854
        opt_video_codec("mpeg2video");
3855
        opt_audio_codec("mp2");
3856
        opt_format("svcd");
3857

    
3858
        opt_frame_size(norm ? "480x480" : "480x576");
3859
        opt_frame_rate(frame_rates[norm]);
3860
        opt_gop_size(norm ? "18" : "15");
3861

    
3862
        video_bit_rate = 2040000;
3863
        video_rc_max_rate = 2516000;
3864
        video_rc_min_rate = 0; //1145000;
3865
        video_rc_buffer_size = 224*1024*8;
3866
        use_scan_offset = 1;
3867

    
3868
        audio_bit_rate = 224000;
3869
        audio_sample_rate = 44100;
3870

    
3871
        mux_packet_size= 2324;
3872

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

    
3875
        opt_video_codec("mpeg2video");
3876
        opt_audio_codec("ac3");
3877
        opt_format("dvd");
3878

    
3879
        opt_frame_size(norm ? "720x480" : "720x576");
3880
        opt_frame_rate(frame_rates[norm]);
3881
        opt_gop_size(norm ? "18" : "15");
3882

    
3883
        video_bit_rate = 6000000;
3884
        video_rc_max_rate = 9000000;
3885
        video_rc_min_rate = 0; //1500000;
3886
        video_rc_buffer_size = 224*1024*8;
3887

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

    
3891
        audio_bit_rate = 448000;
3892
        audio_sample_rate = 48000;
3893

    
3894
    } else if(!strcmp(arg, "dv")) {
3895

    
3896
        opt_format("dv");
3897

    
3898
        opt_frame_size(norm ? "720x480" : "720x576");
3899
        opt_frame_rate(frame_rates[norm]);
3900

    
3901
        audio_sample_rate = 48000;
3902
        audio_channels = 2;
3903

    
3904
    } else {
3905
        fprintf(stderr, "Unknown target: %s\n", arg);
3906
        exit(1);
3907
    }
3908
}
3909

    
3910
static void show_version(void)
3911
{
3912
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3913
           "libavcodec  %d\n"
3914
           "libavformat %d\n", 
3915
           avcodec_build(), LIBAVFORMAT_BUILD);
3916
    exit(1);
3917
}
3918

    
3919
const OptionDef options[] = {
3920
    /* main options */
3921
    { "L", 0, {(void*)show_license}, "show license" },
3922
    { "h", 0, {(void*)show_help}, "show help" },
3923
    { "version", 0, {(void*)show_version}, "show version" },
3924
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3925
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3926
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3927
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3928
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3929
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3930
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3931
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3932
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3933
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3934
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3935
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3936
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3937
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3938
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3939
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3940
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3941
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3942
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
3943
      "add timings for benchmarking" },
3944
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
3945
      "dump each input packet" },
3946
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
3947
      "when dumping packets, also dump the payload" },
3948
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
3949
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3950
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3951
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3952
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3953
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3954
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3955
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3956
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3957
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3958

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

    
4089
    /* audio options */
4090
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4091
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4092
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4093
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4094
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4095
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4096
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4097

    
4098
    /* grab options */
4099
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4100
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4101
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4102
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4103

    
4104
    /* G.2 grab options */ 
4105
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4106
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4107
 
4108
    /* muxer options */   
4109
    { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4110
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4111
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4112
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4113
    { NULL, },
4114
};
4115

    
4116
static void show_banner(void)
4117
{
4118
    fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4119
        LIBAVCODEC_BUILD);
4120
    fprintf(stderr, "  configuration: %s\n", FFMPEG_CONFIGURATION);
4121
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4122
#ifdef __GNUC__
4123
    fprintf(stderr, ", gcc: %s\n", __VERSION__);
4124
#else
4125
    fprintf(stderr, ", using a non-gcc compiler\n");
4126
#endif
4127
}
4128

    
4129
static void show_license(void)
4130
{
4131
    show_banner();
4132
#ifdef CONFIG_GPL
4133
    printf(
4134
    "This program is free software; you can redistribute it and/or modify\n"   
4135
    "it under the terms of the GNU General Public License as published by\n"
4136
    "the Free Software Foundation; either version 2 of the License, or\n"
4137
    "(at your option) any later version.\n"
4138
    "\n"
4139
    "This program is distributed in the hope that it will be useful,\n"
4140
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4141
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4142
    "GNU General Public License for more details.\n"
4143
    "\n"
4144
    "You should have received a copy of the GNU General Public License\n"
4145
    "along with this program; if not, write to the Free Software\n"
4146
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4147
    );
4148
#else
4149
    printf(
4150
    "This library is free software; you can redistribute it and/or\n"
4151
    "modify it under the terms of the GNU Lesser General Public\n"
4152
    "License as published by the Free Software Foundation; either\n"
4153
    "version 2 of the License, or (at your option) any later version.\n"
4154
    "\n"
4155
    "This library is distributed in the hope that it will be useful,\n"
4156
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4157
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4158
    "Lesser General Public License for more details.\n"
4159
    "\n"
4160
    "You should have received a copy of the GNU Lesser General Public\n"
4161
    "License along with this library; if not, write to the Free Software\n"
4162
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4163
    );
4164
#endif
4165
    exit(1);
4166
}
4167

    
4168
static void show_help(void)
4169
{
4170
    show_banner();
4171
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4172
           "Hyper fast Audio and Video encoder\n");
4173
    printf("\n");
4174
    show_help_options(options, "Main options:\n",
4175
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4176
    show_help_options(options, "\nVideo options:\n",
4177
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4178
                      OPT_VIDEO);
4179
    show_help_options(options, "\nAdvanced Video options:\n",
4180
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4181
                      OPT_VIDEO | OPT_EXPERT);
4182
    show_help_options(options, "\nAudio options:\n",
4183
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4184
                      OPT_AUDIO);
4185
    show_help_options(options, "\nAdvanced Audio options:\n",
4186
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4187
                      OPT_AUDIO | OPT_EXPERT);
4188
    show_help_options(options, "\nAudio/Video grab options:\n",
4189
                      OPT_GRAB, 
4190
                      OPT_GRAB);
4191
    show_help_options(options, "\nAdvanced options:\n",
4192
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4193
                      OPT_EXPERT);
4194
    exit(1);
4195
}
4196

    
4197
void parse_arg_file(const char *filename)
4198
{
4199
    opt_output_file(filename);
4200
}
4201

    
4202
int main(int argc, char **argv)
4203
{
4204
    int i;
4205
    int64_t ti;
4206

    
4207
    av_register_all();
4208

    
4209
    if (argc <= 1)
4210
        show_help();
4211
    else
4212
        show_banner();
4213
    
4214
    /* parse options */
4215
    parse_options(argc, argv, options);
4216

    
4217
    /* file converter / grab */
4218
    if (nb_output_files <= 0) {
4219
        fprintf(stderr, "Must supply at least one output file\n");
4220
        exit(1);
4221
    }
4222
    
4223
    if (nb_input_files == 0) {
4224
        input_sync = 1;
4225
        prepare_grab();
4226
    }
4227

    
4228
    ti = getutime();
4229
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
4230
              stream_maps, nb_stream_maps);
4231
    ti = getutime() - ti;
4232
    if (do_benchmark) {
4233
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4234
    }
4235

    
4236
    /* close files */
4237
    for(i=0;i<nb_output_files;i++) {
4238
        /* maybe av_close_output_file ??? */
4239
        AVFormatContext *s = output_files[i];
4240
        int j;
4241
        if (!(s->oformat->flags & AVFMT_NOFILE))
4242
            url_fclose(&s->pb);
4243
        for(j=0;j<s->nb_streams;j++)
4244
            av_free(s->streams[j]);
4245
        av_free(s);
4246
    }
4247
    for(i=0;i<nb_input_files;i++)
4248
        av_close_input_file(input_files[i]);
4249

    
4250
    av_free_static();
4251

    
4252
    if(intra_matrix)
4253
        av_free(intra_matrix);
4254
    if(inter_matrix)
4255
        av_free(inter_matrix);
4256
    
4257
#ifdef POWERPC_PERFORMANCE_REPORT
4258
    extern void powerpc_display_perf_report(void);
4259
    powerpc_display_perf_report();
4260
#endif /* POWERPC_PERFORMANCE_REPORT */
4261

    
4262
#ifndef CONFIG_WIN32
4263
    if (received_sigterm) {
4264
        fprintf(stderr,
4265
            "Received signal %d: terminating.\n",
4266
            (int) received_sigterm);
4267
        exit (255);
4268
    }
4269
#endif
4270
    exit(0); /* not all OS-es handle main() return value */
4271
    return 0;
4272
}