Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b4aea108

History | View | Annotate | Download (146 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_qmin = 2;
110
static int video_mb_qmax = 31;
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 do_deinterlace = 0;
174
static int do_interlace_dct = 0;
175
static int do_interlace_me = 0;
176
static int workaround_bugs = FF_BUG_AUTODETECT;
177
static int error_resilience = 2;
178
static int error_concealment = 3;
179
static int dct_algo = 0;
180
static int idct_algo = 0;
181
static int use_part = 0;
182
static int packet_size = 0;
183
static int error_rate = 0;
184
static int strict = 0;
185
static int top_field_first = -1;
186
static int noise_reduction = 0;
187
static int sc_threshold = 0;
188
static int debug = 0;
189
static int debug_mv = 0;
190
static int me_threshold = 0;
191
static int mb_threshold = 0;
192
static int intra_dc_precision = 8;
193
static int coder = 0;
194
static int context = 0;
195
static int predictor = 0;
196
static int video_profile = FF_PROFILE_UNKNOWN;
197
static int video_level = FF_LEVEL_UNKNOWN;
198
static int nsse_weight = 8;
199
static int subpel_quality= 8;
200
static int lowres= 0;
201
static int frame_skip_threshold= 0;
202
static int frame_skip_factor= 0;
203
static int frame_skip_exp= 0;
204
static int frame_skip_cmp= FF_CMP_DCTMAX;
205
extern int loop_input; /* currently a hack */
206

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

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

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

    
244
static int rate_emu = 0;
245

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

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

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

    
268
static int pgmyuv_compatibility_hack=0;
269

    
270

    
271
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
272

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

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

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

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

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

    
331
#ifndef CONFIG_WIN32
332

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

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

    
341
static volatile sig_atomic_t received_sigterm = 0;
342

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

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

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

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

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

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

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

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

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

    
410
#else
411

    
412
static volatile int received_sigterm = 0;
413

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

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

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

    
428
#endif
429

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

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

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

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

    
452
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
453

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
643

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

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

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

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

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

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

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

    
701
    *frame_size = 0;
702

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1015

    
1016
    oc = output_files[0];
1017

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

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

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

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

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

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

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

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

    
1215
                ist->frame++;
1216
            }
1217

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

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

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

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

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

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

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

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

    
1359

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1947
    term_exit();
1948

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2104

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2248

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

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

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

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

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

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

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

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

    
2306

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

    
2320

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

    
2334

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2510
static void opt_mb_qmin(const char *arg)
2511
{
2512
    video_mb_qmin = atoi(arg);
2513
    if (video_mb_qmin < 0 ||
2514
        video_mb_qmin > 31) {
2515
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2516
        exit(1);
2517
    }
2518
}
2519

    
2520
static void opt_mb_qmax(const char *arg)
2521
{
2522
    video_mb_qmax = atoi(arg);
2523
    if (video_mb_qmax < 0 ||
2524
        video_mb_qmax > 31) {
2525
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2526
        exit(1);
2527
    }
2528
}
2529

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2716
    using_vhook = 1;
2717

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

    
2722
    i = frame_hook_add(argc, argv);
2723

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3011
    oc = av_alloc_format_context();
3012

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

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

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

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

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

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

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

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

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

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

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

    
3299
                if(packet_size){
3300
                    video_enc->rtp_mode= 1;
3301
                    video_enc->rtp_payload_size= packet_size;
3302
                }
3303
            
3304
                if (do_psnr)
3305
                    video_enc->flags|= CODEC_FLAG_PSNR;
3306
            
3307
                video_enc->me_method = me_method;
3308

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

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

    
3333
            audio_enc = &st->codec;
3334
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3335

    
3336
            if(audio_codec_tag)
3337
                audio_enc->codec_tag= audio_codec_tag;
3338

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

    
3364
        oc->nb_streams = nb_streams;
3365

    
3366
        if (!nb_streams) {
3367
            fprintf(stderr, "No audio or video streams available\n");
3368
            exit(1);
3369
        }
3370

    
3371
        oc->timestamp = rec_timestamp;
3372
            
3373
        if (str_title)
3374
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3375
        if (str_author)
3376
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3377
        if (str_copyright)
3378
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3379
        if (str_comment)
3380
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3381
    }
3382

    
3383
    output_files[nb_output_files++] = oc;
3384

    
3385
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3386

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

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

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

    
3434
    oc->packet_size= mux_packet_size;
3435
    oc->mux_rate= mux_rate;
3436
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3437
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3438

    
3439
    /* reset some options */
3440
    file_oformat = NULL;
3441
    file_iformat = NULL;
3442
    image_format = NULL;
3443
    audio_disable = 0;
3444
    video_disable = 0;
3445
    audio_codec_id = CODEC_ID_NONE;
3446
    video_codec_id = CODEC_ID_NONE;
3447
    audio_stream_copy = 0;
3448
    video_stream_copy = 0;
3449
}
3450

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

    
3522
        if (verbose >= 0)
3523
            dump_format(ic, nb_input_files, "", 0);
3524

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

    
3537
        if (verbose >= 0)
3538
            dump_format(ic, nb_input_files, "", 0);
3539

    
3540
        nb_input_files++;
3541
    }
3542
}
3543

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

    
3556
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3557
static int64_t getutime(void)
3558
{
3559
  return av_gettime();
3560
}
3561
#else
3562
static int64_t getutime(void)
3563
{
3564
    struct rusage rusage;
3565

    
3566
    getrusage(RUSAGE_SELF, &rusage);
3567
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3568
}
3569
#endif
3570

    
3571
extern int ffm_nopts;
3572

    
3573
static void opt_bitexact(void)
3574
{
3575
    bitexact=1;
3576
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3577
    ffm_nopts = 1;
3578
}
3579

    
3580
static void show_formats(void)
3581
{
3582
    AVInputFormat *ifmt;
3583
    AVOutputFormat *ofmt;
3584
    AVImageFormat *image_fmt;
3585
    URLProtocol *up;
3586
    AVCodec *p, *p2;
3587
    const char **pp, *last_name;
3588

    
3589
    printf("File formats:\n");
3590
    last_name= "000";
3591
    for(;;){
3592
        int decode=0;
3593
        int encode=0;
3594
        const char *name=NULL;
3595
        const char *long_name=NULL;
3596

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

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

    
3640
    printf("Codecs:\n");
3641
    last_name= "000";
3642
    for(;;){
3643
        int decode=0;
3644
        int encode=0;
3645
        int cap=0;
3646

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

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

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

    
3724
void opt_inter_matrix(const char *arg)
3725
{
3726
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3727
    parse_matrix_coeffs(inter_matrix, arg);
3728
}
3729

    
3730
void opt_intra_matrix(const char *arg)
3731
{
3732
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3733
    parse_matrix_coeffs(intra_matrix, arg);
3734
}
3735

    
3736
static void opt_target(const char *arg)
3737
{
3738
    int norm = -1;
3739
    static const char const *frame_rates[] = {"25", "30000/1001", "24000/1001"};
3740

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

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

    
3792
    if(!strcmp(arg, "vcd")) {
3793

    
3794
        opt_video_codec("mpeg1video");
3795
        opt_audio_codec("mp2");
3796
        opt_format("vcd");
3797

    
3798
        opt_frame_size(norm ? "352x240" : "352x288");
3799
        opt_frame_rate(frame_rates[norm]);
3800
        opt_gop_size(norm ? "18" : "15");
3801

    
3802
        video_bit_rate = 1150000;
3803
        video_rc_max_rate = 1150000;
3804
        video_rc_min_rate = 1150000;
3805
        video_rc_buffer_size = 40*1024*8;
3806

    
3807
        audio_bit_rate = 224000;
3808
        audio_sample_rate = 44100;
3809
        
3810
        mux_packet_size= 2324;
3811
        mux_rate= 2352 * 75 * 8;
3812

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

    
3821
        opt_video_codec("mpeg2video");
3822
        opt_audio_codec("mp2");
3823
        opt_format("svcd");
3824

    
3825
        opt_frame_size(norm ? "480x480" : "480x576");
3826
        opt_frame_rate(frame_rates[norm]);
3827
        opt_gop_size(norm ? "18" : "15");
3828

    
3829
        video_bit_rate = 2040000;
3830
        video_rc_max_rate = 2516000;
3831
        video_rc_min_rate = 0; //1145000;
3832
        video_rc_buffer_size = 224*1024*8;
3833
        use_scan_offset = 1;
3834

    
3835
        audio_bit_rate = 224000;
3836
        audio_sample_rate = 44100;
3837

    
3838
        mux_packet_size= 2324;
3839

    
3840
    } else if(!strcmp(arg, "dvd")) {
3841

    
3842
        opt_video_codec("mpeg2video");
3843
        opt_audio_codec("ac3");
3844
        opt_format("dvd");
3845

    
3846
        opt_frame_size(norm ? "720x480" : "720x576");
3847
        opt_frame_rate(frame_rates[norm]);
3848
        opt_gop_size(norm ? "18" : "15");
3849

    
3850
        video_bit_rate = 6000000;
3851
        video_rc_max_rate = 9000000;
3852
        video_rc_min_rate = 0; //1500000;
3853
        video_rc_buffer_size = 224*1024*8;
3854

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

    
3858
        audio_bit_rate = 448000;
3859
        audio_sample_rate = 48000;
3860

    
3861
    } else if(!strcmp(arg, "dv")) {
3862

    
3863
        opt_format("dv");
3864

    
3865
        opt_frame_size(norm ? "720x480" : "720x576");
3866
        opt_frame_rate(frame_rates[norm]);
3867

    
3868
        audio_sample_rate = 48000;
3869
        audio_channels = 2;
3870

    
3871
    } else {
3872
        fprintf(stderr, "Unknown target: %s\n", arg);
3873
        exit(1);
3874
    }
3875
}
3876

    
3877
static void show_version(void)
3878
{
3879
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3880
           "libavcodec  %d\n"
3881
           "libavformat %d\n", 
3882
           avcodec_build(), LIBAVFORMAT_BUILD);
3883
    exit(1);
3884
}
3885

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

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

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

    
4060
    /* grab options */
4061
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4062
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4063
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4064
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4065

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

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

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

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

    
4159
void parse_arg_file(const char *filename)
4160
{
4161
    opt_output_file(filename);
4162
}
4163

    
4164
int main(int argc, char **argv)
4165
{
4166
    int i;
4167
    int64_t ti;
4168

    
4169
    av_register_all();
4170

    
4171
    if (argc <= 1)
4172
        show_help();
4173
    else
4174
        show_banner();
4175
    
4176
    /* parse options */
4177
    parse_options(argc, argv, options);
4178

    
4179
    /* file converter / grab */
4180
    if (nb_output_files <= 0) {
4181
        fprintf(stderr, "Must supply at least one output file\n");
4182
        exit(1);
4183
    }
4184
    
4185
    if (nb_input_files == 0) {
4186
        input_sync = 1;
4187
        prepare_grab();
4188
    }
4189

    
4190
    ti = getutime();
4191
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
4192
              stream_maps, nb_stream_maps);
4193
    ti = getutime() - ti;
4194
    if (do_benchmark) {
4195
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4196
    }
4197

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

    
4212
    av_free_static();
4213

    
4214
    if(intra_matrix)
4215
        av_free(intra_matrix);
4216
    if(inter_matrix)
4217
        av_free(inter_matrix);
4218
    
4219
#ifdef POWERPC_PERFORMANCE_REPORT
4220
    extern void powerpc_display_perf_report(void);
4221
    powerpc_display_perf_report();
4222
#endif /* POWERPC_PERFORMANCE_REPORT */
4223

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