Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 09b0499f

History | View | Annotate | Download (147 KB)

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

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

    
42
#include "cmdutils.h"
43

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

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

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

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

    
63
extern const OptionDef options[];
64

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

    
68
#define MAX_FILES 20
69

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

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

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

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

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

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

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

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

    
245
static int rate_emu = 0;
246

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

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

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

    
269
static int pgmyuv_compatibility_hack=0;
270

    
271

    
272
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
273

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

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

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

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

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

    
332
#ifndef CONFIG_WIN32
333

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

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

    
342
static volatile sig_atomic_t received_sigterm = 0;
343

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

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

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

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

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

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

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

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

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

    
411
#else
412

    
413
static volatile int received_sigterm = 0;
414

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

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

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

    
429
#endif
430

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

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

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

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

    
453
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
454

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
644

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

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

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

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

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

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

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

    
702
    *frame_size = 0;
703

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1016

    
1017
    oc = output_files[0];
1018

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

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

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

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

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

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

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

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

    
1216
                ist->frame++;
1217
            }
1218

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

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

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

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

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

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

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

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

    
1360

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1948
    term_exit();
1949

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2105

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2249

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

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

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

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

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

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

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

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

    
2307

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

    
2321

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

    
2335

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2717
    using_vhook = 1;
2718

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

    
2723
    i = frame_hook_add(argc, argv);
2724

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2955
    nb_input_files++;
2956
    file_iformat = NULL;
2957
    file_oformat = NULL;
2958
    image_format = NULL;
2959

    
2960
    grab_device = NULL;
2961
    video_channel = 0;
2962
    
2963
    rate_emu = 0;
2964
}
2965

    
2966
static void opt_grab(const char *arg)
2967
{
2968
    file_iformat = av_find_input_format(arg);
2969
    opt_input_file("");
2970
}
2971

    
2972
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2973
{
2974
    int has_video, has_audio, i, j;
2975
    AVFormatContext *ic;
2976

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

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

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

    
3012
    oc = av_alloc_format_context();
3013

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

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

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

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

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

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

    
3127
                if (!intra_only)
3128
                    video_enc->gop_size = gop_size;
3129
                else
3130
                    video_enc->gop_size = 0;
3131
                if (video_qscale || same_quality) {
3132
                    video_enc->flags |= CODEC_FLAG_QSCALE;
3133
                    st->quality = FF_QP2LAMBDA * video_qscale;
3134
                }
3135

    
3136
                if(intra_matrix)
3137
                    video_enc->intra_matrix = intra_matrix;
3138
                if(inter_matrix)
3139
                    video_enc->inter_matrix = inter_matrix;
3140

    
3141
                if(bitexact)
3142
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
3143

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

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

    
3303
                if(packet_size){
3304
                    video_enc->rtp_mode= 1;
3305
                    video_enc->rtp_payload_size= packet_size;
3306
                }
3307
            
3308
                if (do_psnr)
3309
                    video_enc->flags|= CODEC_FLAG_PSNR;
3310
            
3311
                video_enc->me_method = me_method;
3312

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

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

    
3337
            audio_enc = &st->codec;
3338
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3339

    
3340
            if(audio_codec_tag)
3341
                audio_enc->codec_tag= audio_codec_tag;
3342

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

    
3368
        oc->nb_streams = nb_streams;
3369

    
3370
        if (!nb_streams) {
3371
            fprintf(stderr, "No audio or video streams available\n");
3372
            exit(1);
3373
        }
3374

    
3375
        oc->timestamp = rec_timestamp;
3376
            
3377
        if (str_title)
3378
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3379
        if (str_author)
3380
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3381
        if (str_copyright)
3382
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3383
        if (str_comment)
3384
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3385
    }
3386

    
3387
    output_files[nb_output_files++] = oc;
3388

    
3389
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3390

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

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

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

    
3438
    oc->packet_size= mux_packet_size;
3439
    oc->mux_rate= mux_rate;
3440
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3441
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3442

    
3443
    /* reset some options */
3444
    file_oformat = NULL;
3445
    file_iformat = NULL;
3446
    image_format = NULL;
3447
    audio_disable = 0;
3448
    video_disable = 0;
3449
    audio_codec_id = CODEC_ID_NONE;
3450
    video_codec_id = CODEC_ID_NONE;
3451
    audio_stream_copy = 0;
3452
    video_stream_copy = 0;
3453
}
3454

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

    
3526
        if (verbose >= 0)
3527
            dump_format(ic, nb_input_files, "", 0);
3528

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

    
3541
        if (verbose >= 0)
3542
            dump_format(ic, nb_input_files, "", 0);
3543

    
3544
        nb_input_files++;
3545
    }
3546
}
3547

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

    
3560
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3561
static int64_t getutime(void)
3562
{
3563
  return av_gettime();
3564
}
3565
#else
3566
static int64_t getutime(void)
3567
{
3568
    struct rusage rusage;
3569

    
3570
    getrusage(RUSAGE_SELF, &rusage);
3571
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3572
}
3573
#endif
3574

    
3575
extern int ffm_nopts;
3576

    
3577
static void opt_bitexact(void)
3578
{
3579
    bitexact=1;
3580
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3581
    ffm_nopts = 1;
3582
}
3583

    
3584
static void show_formats(void)
3585
{
3586
    AVInputFormat *ifmt;
3587
    AVOutputFormat *ofmt;
3588
    AVImageFormat *image_fmt;
3589
    URLProtocol *up;
3590
    AVCodec *p, *p2;
3591
    const char **pp, *last_name;
3592

    
3593
    printf("File formats:\n");
3594
    last_name= "000";
3595
    for(;;){
3596
        int decode=0;
3597
        int encode=0;
3598
        const char *name=NULL;
3599
        const char *long_name=NULL;
3600

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

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

    
3644
    printf("Codecs:\n");
3645
    last_name= "000";
3646
    for(;;){
3647
        int decode=0;
3648
        int encode=0;
3649
        int cap=0;
3650

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

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

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

    
3728
void opt_inter_matrix(const char *arg)
3729
{
3730
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3731
    parse_matrix_coeffs(inter_matrix, arg);
3732
}
3733

    
3734
void opt_intra_matrix(const char *arg)
3735
{
3736
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3737
    parse_matrix_coeffs(intra_matrix, arg);
3738
}
3739

    
3740
static void opt_target(const char *arg)
3741
{
3742
    int norm = -1;
3743
    static const char const *frame_rates[] = {"25", "30000/1001", "24000/1001"};
3744

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

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

    
3796
    if(!strcmp(arg, "vcd")) {
3797

    
3798
        opt_video_codec("mpeg1video");
3799
        opt_audio_codec("mp2");
3800
        opt_format("vcd");
3801

    
3802
        opt_frame_size(norm ? "352x240" : "352x288");
3803
        opt_frame_rate(frame_rates[norm]);
3804
        opt_gop_size(norm ? "18" : "15");
3805

    
3806
        video_bit_rate = 1150000;
3807
        video_rc_max_rate = 1150000;
3808
        video_rc_min_rate = 1150000;
3809
        video_rc_buffer_size = 40*1024*8;
3810

    
3811
        audio_bit_rate = 224000;
3812
        audio_sample_rate = 44100;
3813
        
3814
        mux_packet_size= 2324;
3815
        mux_rate= 2352 * 75 * 8;
3816

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

    
3825
        opt_video_codec("mpeg2video");
3826
        opt_audio_codec("mp2");
3827
        opt_format("svcd");
3828

    
3829
        opt_frame_size(norm ? "480x480" : "480x576");
3830
        opt_frame_rate(frame_rates[norm]);
3831
        opt_gop_size(norm ? "18" : "15");
3832

    
3833
        video_bit_rate = 2040000;
3834
        video_rc_max_rate = 2516000;
3835
        video_rc_min_rate = 0; //1145000;
3836
        video_rc_buffer_size = 224*1024*8;
3837
        use_scan_offset = 1;
3838

    
3839
        audio_bit_rate = 224000;
3840
        audio_sample_rate = 44100;
3841

    
3842
        mux_packet_size= 2324;
3843

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

    
3846
        opt_video_codec("mpeg2video");
3847
        opt_audio_codec("ac3");
3848
        opt_format("dvd");
3849

    
3850
        opt_frame_size(norm ? "720x480" : "720x576");
3851
        opt_frame_rate(frame_rates[norm]);
3852
        opt_gop_size(norm ? "18" : "15");
3853

    
3854
        video_bit_rate = 6000000;
3855
        video_rc_max_rate = 9000000;
3856
        video_rc_min_rate = 0; //1500000;
3857
        video_rc_buffer_size = 224*1024*8;
3858

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

    
3862
        audio_bit_rate = 448000;
3863
        audio_sample_rate = 48000;
3864

    
3865
    } else if(!strcmp(arg, "dv")) {
3866

    
3867
        opt_format("dv");
3868

    
3869
        opt_frame_size(norm ? "720x480" : "720x576");
3870
        opt_frame_rate(frame_rates[norm]);
3871

    
3872
        audio_sample_rate = 48000;
3873
        audio_channels = 2;
3874

    
3875
    } else {
3876
        fprintf(stderr, "Unknown target: %s\n", arg);
3877
        exit(1);
3878
    }
3879
}
3880

    
3881
static void show_version(void)
3882
{
3883
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3884
           "libavcodec  %d\n"
3885
           "libavformat %d\n", 
3886
           avcodec_build(), LIBAVFORMAT_BUILD);
3887
    exit(1);
3888
}
3889

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

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

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

    
4065
    /* grab options */
4066
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4067
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4068
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4069
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4070

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

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

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

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

    
4164
void parse_arg_file(const char *filename)
4165
{
4166
    opt_output_file(filename);
4167
}
4168

    
4169
int main(int argc, char **argv)
4170
{
4171
    int i;
4172
    int64_t ti;
4173

    
4174
    av_register_all();
4175

    
4176
    if (argc <= 1)
4177
        show_help();
4178
    else
4179
        show_banner();
4180
    
4181
    /* parse options */
4182
    parse_options(argc, argv, options);
4183

    
4184
    /* file converter / grab */
4185
    if (nb_output_files <= 0) {
4186
        fprintf(stderr, "Must supply at least one output file\n");
4187
        exit(1);
4188
    }
4189
    
4190
    if (nb_input_files == 0) {
4191
        input_sync = 1;
4192
        prepare_grab();
4193
    }
4194

    
4195
    ti = getutime();
4196
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
4197
              stream_maps, nb_stream_maps);
4198
    ti = getutime() - ti;
4199
    if (do_benchmark) {
4200
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4201
    }
4202

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

    
4217
    av_free_static();
4218

    
4219
    if(intra_matrix)
4220
        av_free(intra_matrix);
4221
    if(inter_matrix)
4222
        av_free(inter_matrix);
4223
    
4224
#ifdef POWERPC_PERFORMANCE_REPORT
4225
    extern void powerpc_display_perf_report(void);
4226
    powerpc_display_perf_report();
4227
#endif /* POWERPC_PERFORMANCE_REPORT */
4228

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