Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 3ba1438d

History | View | Annotate | Download (138 KB)

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

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

    
42
#include "cmdutils.h"
43

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

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

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

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

    
63
extern const OptionDef options[];
64

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

    
68
#define MAX_FILES 20
69

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

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

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

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

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

    
195
static int gop_size = 12;
196
static int intra_only = 0;
197
static int audio_sample_rate = 44100;
198
static int audio_bit_rate = 64000;
199
static int audio_disable = 0;
200
static int audio_channels = 1;
201
static int audio_codec_id = CODEC_ID_NONE;
202

    
203
static int mux_rate= 0;
204
static int mux_packet_size= 0;
205

    
206
static int64_t recording_time = 0;
207
static int64_t start_time = 0;
208
static int64_t rec_timestamp = 0;
209
static int64_t input_ts_offset = 0;
210
static int file_overwrite = 0;
211
static char *str_title = NULL;
212
static char *str_author = NULL;
213
static char *str_copyright = NULL;
214
static char *str_comment = NULL;
215
static int do_benchmark = 0;
216
static int do_hex_dump = 0;
217
static int do_pkt_dump = 0;
218
static int do_psnr = 0;
219
static int do_vstats = 0;
220
static int do_pass = 0;
221
static int bitexact = 0;
222
static char *pass_logfilename = NULL;
223
static int audio_stream_copy = 0;
224
static int video_stream_copy = 0;
225
static int video_sync_method= 1;
226
static int audio_sync_method= 0;
227
static int copy_ts= 0;
228

    
229
static int rate_emu = 0;
230

    
231
static char *video_grab_format = "video4linux";
232
static char *video_device = NULL;
233
static int  video_channel = 0;
234
static char *video_standard = "ntsc";
235

    
236
static char *audio_grab_format = "audio_device";
237
static char *audio_device = NULL;
238

    
239
static int using_stdin = 0;
240
static int using_vhook = 0;
241
static int verbose = 1;
242
static int thread_count= 1;
243
static int q_pressed = 0;
244
static int me_range = 0;
245
static int64_t video_size = 0;
246
static int64_t audio_size = 0;
247
static int64_t extra_size = 0;
248
static int nb_frames_dup = 0;
249
static int nb_frames_drop = 0;
250
static int input_sync;
251

    
252
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
253

    
254
typedef struct AVOutputStream {
255
    int file_index;          /* file index */
256
    int index;               /* stream index in the output file */
257
    int source_index;        /* AVInputStream index */
258
    AVStream *st;            /* stream in the output file */
259
    int encoding_needed;     /* true if encoding needed for this stream */
260
    int frame_number;
261
    /* input pts and corresponding output pts
262
       for A/V sync */
263
    double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
264
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
265
    /* video only */
266
    int video_resample;      /* video_resample and video_crop are mutually exclusive */
267
    AVFrame pict_tmp;      /* temporary image for resampling */
268
    ImgReSampleContext *img_resample_ctx; /* for image resampling */
269

    
270
    int video_crop;          /* video_resample and video_crop are mutually exclusive */
271
    int topBand;             /* cropping area sizes */
272
    int leftBand;
273
    
274
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
275
    int padtop;              /* padding area sizes */
276
    int padbottom;
277
    int padleft;
278
    int padright;
279
    
280
    /* audio only */
281
    int audio_resample;
282
    ReSampleContext *resample; /* for audio resampling */
283
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
284
    FILE *logfile;
285
} AVOutputStream;
286

    
287
typedef struct AVInputStream {
288
    int file_index;
289
    int index;
290
    AVStream *st;
291
    int discard;             /* true if stream data should be discarded */
292
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
293
    int64_t sample_index;      /* current sample */
294

    
295
    int64_t       start;     /* time when read started */
296
    unsigned long frame;     /* current frame */
297
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
298
                                is not defined */
299
    int64_t       pts;       /* current pts */
300
    int is_start;            /* is 1 at the start and after a discontinuity */
301
} AVInputStream;
302

    
303
typedef struct AVInputFile {
304
    int eof_reached;      /* true if eof reached */
305
    int ist_index;        /* index of first stream in ist_table */
306
    int buffer_size;      /* current total buffer size */
307
    int buffer_size_max;  /* buffer size at which we consider we can stop
308
                             buffering */
309
    int nb_streams;       /* nb streams we are aware of */
310
} AVInputFile;
311

    
312
#ifndef CONFIG_WIN32
313

    
314
/* init terminal so that we can grab keys */
315
static struct termios oldtty;
316

    
317
static void term_exit(void)
318
{
319
    tcsetattr (0, TCSANOW, &oldtty);
320
}
321

    
322
static volatile sig_atomic_t received_sigterm = 0;
323

    
324
static void
325
sigterm_handler(int sig)
326
{
327
    received_sigterm = sig;
328
    term_exit();
329
}
330

    
331
static void term_init(void)
332
{
333
    struct termios tty;
334

    
335
    tcgetattr (0, &tty);
336
    oldtty = tty;
337

    
338
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
339
                          |INLCR|IGNCR|ICRNL|IXON);
340
    tty.c_oflag |= OPOST;
341
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
342
    tty.c_cflag &= ~(CSIZE|PARENB);
343
    tty.c_cflag |= CS8;
344
    tty.c_cc[VMIN] = 1;
345
    tty.c_cc[VTIME] = 0;
346
    
347
    tcsetattr (0, TCSANOW, &tty);
348

    
349
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
350
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
351
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
352
    /*
353
    register a function to be called at normal program termination
354
    */
355
    atexit(term_exit);
356
#ifdef CONFIG_BEOS_NETSERVER
357
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
358
#endif
359
}
360

    
361
/* read a key without blocking */
362
static int read_key(void)
363
{
364
    int n = 1;
365
    unsigned char ch;
366
#ifndef CONFIG_BEOS_NETSERVER
367
    struct timeval tv;
368
    fd_set rfds;
369

    
370
    FD_ZERO(&rfds);
371
    FD_SET(0, &rfds);
372
    tv.tv_sec = 0;
373
    tv.tv_usec = 0;
374
    n = select(1, &rfds, NULL, NULL, &tv);
375
#endif
376
    if (n > 0) {
377
        n = read(0, &ch, 1);
378
        if (n == 1)
379
            return ch;
380

    
381
        return n;
382
    }
383
    return -1;
384
}
385

    
386
static int decode_interrupt_cb(void)
387
{
388
    return q_pressed || (q_pressed = read_key() == 'q');
389
}
390

    
391
#else
392

    
393
static volatile int received_sigterm = 0;
394

    
395
/* no interactive support */
396
static void term_exit(void)
397
{
398
}
399

    
400
static void term_init(void)
401
{
402
}
403

    
404
static int read_key(void)
405
{
406
    return 0;
407
}
408

    
409
#endif
410

    
411
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
412
{
413
    int i, err;
414
    AVFormatContext *ic;
415

    
416
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
417
    if (err < 0)
418
        return err;
419
    /* copy stream format */
420
    s->nb_streams = ic->nb_streams;
421
    for(i=0;i<ic->nb_streams;i++) {
422
        AVStream *st;
423

    
424
        st = av_mallocz(sizeof(AVStream));
425
        memcpy(st, ic->streams[i], sizeof(AVStream));
426
        s->streams[i] = st;
427
    }
428

    
429
    av_close_input_file(ic);
430
    return 0;
431
}
432

    
433
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
434

    
435
static void do_audio_out(AVFormatContext *s, 
436
                         AVOutputStream *ost, 
437
                         AVInputStream *ist,
438
                         unsigned char *buf, int size)
439
{
440
    uint8_t *buftmp;
441
    static uint8_t *audio_buf = NULL;
442
    static uint8_t *audio_out = NULL;
443
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
444

    
445
    int size_out, frame_bytes, ret;
446
    AVCodecContext *enc= &ost->st->codec;
447

    
448
    /* SC: dynamic allocation of buffers */
449
    if (!audio_buf)
450
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
451
    if (!audio_out)
452
        audio_out = av_malloc(audio_out_size);
453
    if (!audio_buf || !audio_out)
454
        return;               /* Should signal an error ! */
455

    
456
    if(audio_sync_method){
457
        double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts 
458
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
459
        double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
460
        int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
461

    
462
        //FIXME resample delay
463
        if(fabs(delta) > 50){
464
            if(ist->is_start){
465
                if(byte_delta < 0){
466
                    byte_delta= FFMAX(byte_delta, -size);
467
                    size += byte_delta;
468
                    buf  -= byte_delta;
469
                    if(verbose > 2)
470
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
471
                    if(!size)
472
                        return;
473
                    ist->is_start=0;
474
                }else{
475
                    static uint8_t *input_tmp= NULL;
476
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
477

    
478
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
479
                        ist->is_start=0;
480
                    else
481
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
482

    
483
                    memset(input_tmp, 0, byte_delta);
484
                    memcpy(input_tmp + byte_delta, buf, size);
485
                    buf= input_tmp;
486
                    size += byte_delta;
487
                    if(verbose > 2)
488
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
489
                }
490
            }else if(audio_sync_method>1){
491
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
492
                assert(ost->audio_resample);
493
                if(verbose > 2)
494
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
495
//                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));
496
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
497
            }
498
        } 
499
    }else
500
        ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
501
                        - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
502

    
503
    if (ost->audio_resample) {
504
        buftmp = audio_buf;
505
        size_out = audio_resample(ost->resample, 
506
                                  (short *)buftmp, (short *)buf,
507
                                  size / (ist->st->codec.channels * 2));
508
        size_out = size_out * enc->channels * 2;
509
    } else {
510
        buftmp = buf;
511
        size_out = size;
512
    }
513

    
514
    /* now encode as many frames as possible */
515
    if (enc->frame_size > 1) {
516
        /* output resampled raw samples */
517
        fifo_write(&ost->fifo, buftmp, size_out, 
518
                   &ost->fifo.wptr);
519

    
520
        frame_bytes = enc->frame_size * 2 * enc->channels;
521
        
522
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
523
                     &ost->fifo.rptr) == 0) {
524
            AVPacket pkt;
525
            av_init_packet(&pkt);
526

    
527
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
528
                                       (short *)audio_buf);
529
            audio_size += ret;
530
            pkt.stream_index= ost->index;
531
            pkt.data= audio_out;
532
            pkt.size= ret;
533
            if(enc->coded_frame)
534
                pkt.pts= enc->coded_frame->pts;
535
            pkt.flags |= PKT_FLAG_KEY;
536
            av_interleaved_write_frame(s, &pkt);
537
            
538
            ost->sync_opts += enc->frame_size;
539
        }
540
    } else {
541
        AVPacket pkt;
542
        av_init_packet(&pkt);
543

    
544
        ost->sync_opts += size_out / (2 * enc->channels);
545

    
546
        /* output a pcm frame */
547
        /* XXX: change encoding codec API to avoid this ? */
548
        switch(enc->codec->id) {
549
        case CODEC_ID_PCM_S16LE:
550
        case CODEC_ID_PCM_S16BE:
551
        case CODEC_ID_PCM_U16LE:
552
        case CODEC_ID_PCM_U16BE:
553
            break;
554
        default:
555
            size_out = size_out >> 1;
556
            break;
557
        }
558
        ret = avcodec_encode_audio(enc, audio_out, size_out, 
559
                                   (short *)buftmp);
560
        audio_size += ret;
561
        pkt.stream_index= ost->index;
562
        pkt.data= audio_out;
563
        pkt.size= ret;
564
        if(enc->coded_frame)
565
            pkt.pts= enc->coded_frame->pts;
566
        pkt.flags |= PKT_FLAG_KEY;
567
        av_interleaved_write_frame(s, &pkt);
568
    }
569
}
570

    
571
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
572
{
573
    AVCodecContext *dec;
574
    AVPicture *picture2;
575
    AVPicture picture_tmp;
576
    uint8_t *buf = 0;
577

    
578
    dec = &ist->st->codec;
579

    
580
    /* deinterlace : must be done before any resize */
581
    if (do_deinterlace || using_vhook) {
582
        int size;
583

    
584
        /* create temporary picture */
585
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
586
        buf = av_malloc(size);
587
        if (!buf)
588
            return;
589
        
590
        picture2 = &picture_tmp;
591
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
592

    
593
        if (do_deinterlace){
594
            if(avpicture_deinterlace(picture2, picture, 
595
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
596
                /* if error, do not deinterlace */
597
                av_free(buf);
598
                buf = NULL;
599
                picture2 = picture;
600
            }
601
        } else {
602
            if (img_convert(picture2, dec->pix_fmt, picture, 
603
                            dec->pix_fmt, dec->width, dec->height) < 0) {
604
                /* if error, do not copy */
605
                av_free(buf);
606
                buf = NULL;
607
                picture2 = picture;
608
            }
609
        }
610
    } else {
611
        picture2 = picture;
612
    }
613

    
614
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
615

    
616
    if (picture != picture2)
617
        *picture = *picture2;
618
    *bufp = buf;
619
}
620

    
621
/* we begin to correct av delay at this threshold */
622
#define AV_DELAY_MAX 0.100
623

    
624

    
625
/* Expects img to be yuv420 */
626
static void fill_pad_region(AVPicture* img, int height, int width,
627
        int padtop, int padbottom, int padleft, int padright, int *color) {
628
  
629
    int i, y, shift;
630
    uint8_t *optr;
631
    
632
    for (i = 0; i < 3; i++) {
633
        shift = (i == 0) ? 0 : 1;
634
        
635
        if (padtop || padleft) {
636
            memset(img->data[i], color[i], (((img->linesize[i] * padtop) + 
637
                            padleft) >> shift));
638
        }
639

    
640
        if (padleft || padright) {
641
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
642
                (img->linesize[i] - (padright >> shift));
643

    
644
            for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
645
                memset(optr, color[i], (padleft + padright) >> shift);
646
                optr += img->linesize[i];
647
            }
648
        }
649
      
650
        if (padbottom) {
651
            optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
652
            memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
653
        }
654
    }
655
}
656

    
657
static uint8_t *bit_buffer= NULL;
658

    
659
static void do_video_out(AVFormatContext *s, 
660
                         AVOutputStream *ost, 
661
                         AVInputStream *ist,
662
                         AVFrame *in_picture,
663
                         int *frame_size)
664
{
665
    int nb_frames, i, ret;
666
    AVFrame *final_picture, *formatted_picture;
667
    AVFrame picture_format_temp, picture_crop_temp;
668
    uint8_t *buf = NULL, *buf1 = NULL;
669
    AVCodecContext *enc, *dec;
670
    enum PixelFormat target_pixfmt;
671
    
672
#define VIDEO_BUFFER_SIZE (1024*1024)
673

    
674
    avcodec_get_frame_defaults(&picture_format_temp);
675
    avcodec_get_frame_defaults(&picture_crop_temp);
676

    
677
    enc = &ost->st->codec;
678
    dec = &ist->st->codec;
679

    
680
    /* by default, we output a single frame */
681
    nb_frames = 1;
682

    
683
    *frame_size = 0;
684

    
685
    if(video_sync_method){
686
        double vdelta;
687
        vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
688
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
689
        if (vdelta < -1.1)
690
            nb_frames = 0;
691
        else if (vdelta > 1.1)
692
            nb_frames = lrintf(vdelta - 1.1 + 0.5);
693
//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);
694
        if (nb_frames == 0){
695
            ++nb_frames_drop;
696
            if (verbose>2)
697
                fprintf(stderr, "*** drop!\n");
698
        }else if (nb_frames > 1) {
699
            nb_frames_dup += nb_frames;
700
            if (verbose>2)
701
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
702
        }
703
    }else
704
        ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
705

    
706
    if (nb_frames <= 0) 
707
        return;
708

    
709
    /* convert pixel format if needed */
710
    target_pixfmt = ost->video_resample || ost->video_pad
711
        ? PIX_FMT_YUV420P : enc->pix_fmt;
712
    if (dec->pix_fmt != target_pixfmt) {
713
        int size;
714

    
715
        /* create temporary picture */
716
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
717
        buf = av_malloc(size);
718
        if (!buf)
719
            return;
720
        formatted_picture = &picture_format_temp;
721
        avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
722
        
723
        if (img_convert((AVPicture*)formatted_picture, target_pixfmt, 
724
                        (AVPicture *)in_picture, dec->pix_fmt, 
725
                        dec->width, dec->height) < 0) {
726

    
727
            if (verbose >= 0)
728
                fprintf(stderr, "pixel format conversion not handled\n");
729

    
730
            goto the_end;
731
        }
732
    } else {
733
        formatted_picture = in_picture;
734
    }
735

    
736
    /* XXX: resampling could be done before raw format conversion in
737
       some cases to go faster */
738
    /* XXX: only works for YUV420P */
739
    if (ost->video_resample) {
740
        final_picture = &ost->pict_tmp;
741
        img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
742
       
743
        if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
744
            fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
745
                    ost->padtop, ost->padbottom, ost->padleft, ost->padright,
746
                    padcolor);
747
        }
748
        
749
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
750
            int size;
751
            
752
            av_free(buf);
753
            /* create temporary picture */
754
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
755
            buf = av_malloc(size);
756
            if (!buf)
757
                return;
758
            final_picture = &picture_format_temp;
759
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
760
        
761
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
762
                            (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
763
                            enc->width, enc->height) < 0) {
764

    
765
                if (verbose >= 0)
766
                    fprintf(stderr, "pixel format conversion not handled\n");
767

    
768
                goto the_end;
769
            }
770
        }
771
    } else if (ost->video_crop) {
772
        picture_crop_temp.data[0] = formatted_picture->data[0] +
773
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
774

    
775
        picture_crop_temp.data[1] = formatted_picture->data[1] +
776
                ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
777
                (ost->leftBand >> 1);
778

    
779
        picture_crop_temp.data[2] = formatted_picture->data[2] +
780
                ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
781
                (ost->leftBand >> 1);
782

    
783
        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
784
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
785
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
786
        final_picture = &picture_crop_temp;
787
    } else if (ost->video_pad) {
788
        final_picture = &ost->pict_tmp;
789

    
790
        for (i = 0; i < 3; i++) {
791
            uint8_t *optr, *iptr;
792
            int shift = (i == 0) ? 0 : 1;
793
            int y, yheight;
794
            
795
            /* set offset to start writing image into */
796
            optr = final_picture->data[i] + (((final_picture->linesize[i] * 
797
                            ost->padtop) + ost->padleft) >> shift);
798
            iptr = formatted_picture->data[i];
799

    
800
            yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
801
            for (y = 0; y < yheight; y++) {
802
                /* copy unpadded image row into padded image row */
803
                memcpy(optr, iptr, formatted_picture->linesize[i]);
804
                optr += final_picture->linesize[i];
805
                iptr += formatted_picture->linesize[i];
806
            }
807
        }
808

    
809
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
810
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
811
                padcolor);
812
        
813
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
814
            int size;
815

    
816
            av_free(buf);
817
            /* create temporary picture */
818
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
819
            buf = av_malloc(size);
820
            if (!buf)
821
                return;
822
            final_picture = &picture_format_temp;
823
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
824

    
825
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
826
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
827
                        enc->width, enc->height) < 0) {
828

    
829
                if (verbose >= 0)
830
                    fprintf(stderr, "pixel format conversion not handled\n");
831

    
832
                goto the_end;
833
            }
834
        }
835
    } else {
836
        final_picture = formatted_picture;
837
    }
838
    /* duplicates frame if needed */
839
    for(i=0;i<nb_frames;i++) {
840
        AVPacket pkt;
841
        av_init_packet(&pkt);
842
        pkt.stream_index= ost->index;
843

    
844
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
845
            /* raw pictures are written as AVPicture structure to
846
               avoid any copies. We support temorarily the older
847
               method. */
848
            AVFrame* old_frame = enc->coded_frame;
849
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
850
            pkt.data= (uint8_t *)final_picture;
851
            pkt.size=  sizeof(AVPicture);
852
            if(dec->coded_frame)
853
                pkt.pts= dec->coded_frame->pts;
854
            if(dec->coded_frame && dec->coded_frame->key_frame)
855
                pkt.flags |= PKT_FLAG_KEY;
856

    
857
            av_interleaved_write_frame(s, &pkt);
858
            enc->coded_frame = old_frame;
859
        } else {
860
            AVFrame big_picture;
861

    
862
            big_picture= *final_picture;
863
            /* better than nothing: use input picture interlaced
864
               settings */
865
            big_picture.interlaced_frame = in_picture->interlaced_frame;
866
            if(do_interlace_me || do_interlace_dct){
867
                if(top_field_first == -1)
868
                    big_picture.top_field_first = in_picture->top_field_first;
869
                else
870
                    big_picture.top_field_first = top_field_first;
871
            }
872

    
873
            /* handles sameq here. This is not correct because it may
874
               not be a global option */
875
            if (same_quality) {
876
                big_picture.quality = ist->st->quality;
877
            }else
878
                big_picture.quality = ost->st->quality;
879
            if(!me_threshold)
880
                big_picture.pict_type = 0;
881
//            big_picture.pts = AV_NOPTS_VALUE;
882
            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
883
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
884
            ret = avcodec_encode_video(enc, 
885
                                       bit_buffer, VIDEO_BUFFER_SIZE,
886
                                       &big_picture);
887
            //enc->frame_number = enc->real_pict_num;
888
            if(ret){
889
                pkt.data= bit_buffer;
890
                pkt.size= ret;
891
                if(enc->coded_frame)
892
                    pkt.pts= enc->coded_frame->pts;
893
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n", 
894
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
895
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
896

    
897
                if(enc->coded_frame && enc->coded_frame->key_frame)
898
                    pkt.flags |= PKT_FLAG_KEY;
899
                av_interleaved_write_frame(s, &pkt);
900
                *frame_size = ret;
901
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
902
                //        enc->frame_number-1, enc->real_pict_num, ret,
903
                //        enc->pict_type);
904
                /* if two pass, output log */
905
                if (ost->logfile && enc->stats_out) {
906
                    fprintf(ost->logfile, "%s", enc->stats_out);
907
                }
908
            }
909
        }
910
        ost->sync_opts++;
911
        ost->frame_number++;
912
    }
913
 the_end:
914
    av_free(buf);
915
    av_free(buf1);
916
}
917

    
918
static double psnr(double d){
919
    if(d==0) return INFINITY;
920
    return -10.0*log(d)/log(10.0);
921
}
922

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

    
970
static void print_report(AVFormatContext **output_files,
971
                         AVOutputStream **ost_table, int nb_ostreams,
972
                         int is_last_report)
973
{
974
    char buf[1024];
975
    AVOutputStream *ost;
976
    AVFormatContext *oc, *os;
977
    int64_t total_size;
978
    AVCodecContext *enc;
979
    int frame_number, vid, i;
980
    double bitrate, ti1, pts;
981
    static int64_t last_time = -1;
982
    
983
    if (!is_last_report) {
984
        int64_t cur_time;
985
        /* display the report every 0.5 seconds */
986
        cur_time = av_gettime();
987
        if (last_time == -1) {
988
            last_time = cur_time;
989
            return;
990
        } 
991
        if ((cur_time - last_time) < 500000)
992
            return;
993
        last_time = cur_time;
994
    }
995

    
996

    
997
    oc = output_files[0];
998

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

    
1056
        if (verbose > 1)
1057
          sprintf(buf + strlen(buf), " dup=%d drop=%d",
1058
                  nb_frames_dup, nb_frames_drop);
1059
        
1060
        if (verbose >= 0)
1061
            fprintf(stderr, "%s    \r", buf);
1062

    
1063
        fflush(stderr);
1064
    }
1065
        
1066
    if (is_last_report && verbose >= 0){
1067
        int64_t raw= audio_size + video_size + extra_size;
1068
        fprintf(stderr, "\n");
1069
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1070
                video_size/1024.0,
1071
                audio_size/1024.0,
1072
                extra_size/1024.0,
1073
                100.0*(total_size - raw)/raw
1074
        );
1075
    }
1076
}
1077

    
1078
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1079
static int output_packet(AVInputStream *ist, int ist_index,
1080
                         AVOutputStream **ost_table, int nb_ostreams,
1081
                         const AVPacket *pkt)
1082
{
1083
    AVFormatContext *os;
1084
    AVOutputStream *ost;
1085
    uint8_t *ptr;
1086
    int len, ret, i;
1087
    uint8_t *data_buf;
1088
    int data_size, got_picture;
1089
    AVFrame picture;
1090
    void *buffer_to_free;
1091
    static int samples_size= 0;
1092
    static short *samples= NULL;
1093
    
1094
    if(!pkt){
1095
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1096
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1097
        ist->next_pts = ist->pts = pkt->dts;
1098
    } else {
1099
        assert(ist->pts == ist->next_pts);
1100
    }
1101
    
1102
    if (pkt == NULL) {
1103
        /* EOF handling */
1104
        ptr = NULL;
1105
        len = 0;
1106
        goto handle_eof;
1107
    }
1108

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

    
1144
                    ret = avcodec_decode_video(&ist->st->codec, 
1145
                                               &picture, &got_picture, ptr, len);
1146
                    ist->st->quality= picture.quality;
1147
                    if (ret < 0) 
1148
                        goto fail_decode;
1149
                    if (!got_picture) {
1150
                        /* no picture yet */
1151
                        goto discard_packet;
1152
                    }
1153
                    if (ist->st->codec.frame_rate_base != 0) {
1154
                        ist->next_pts += ((int64_t)AV_TIME_BASE * 
1155
                                          ist->st->codec.frame_rate_base) /
1156
                            ist->st->codec.frame_rate;
1157
                    }
1158
                    len = 0;
1159
                    break;
1160
                default:
1161
                    goto fail_decode;
1162
                }
1163
            } else {
1164
                data_buf = ptr;
1165
                data_size = len;
1166
                ret = len;
1167
                len = 0;
1168
            }
1169

    
1170
            buffer_to_free = NULL;
1171
            if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1172
                pre_process_video_frame(ist, (AVPicture *)&picture, 
1173
                                        &buffer_to_free);
1174
            }
1175

    
1176
            /* frame rate emulation */
1177
            if (ist->st->codec.rate_emu) {
1178
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1179
                int64_t now = av_gettime() - ist->start;
1180
                if (pts > now)
1181
                    usleep(pts - now);
1182

    
1183
                ist->frame++;
1184
            }
1185

    
1186
#if 0
1187
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1188
               is the one of the next displayed one */
1189
            /* XXX: add mpeg4 too ? */
1190
            if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1191
                if (ist->st->codec.pict_type != B_TYPE) {
1192
                    int64_t tmp;
1193
                    tmp = ist->last_ip_pts;
1194
                    ist->last_ip_pts  = ist->frac_pts.val;
1195
                    ist->frac_pts.val = tmp;
1196
                }
1197
            }
1198
#endif
1199
            /* if output time reached then transcode raw format, 
1200
               encode packets and output them */
1201
            if (start_time == 0 || ist->pts >= start_time)
1202
                for(i=0;i<nb_ostreams;i++) {
1203
                    int frame_size;
1204

    
1205
                    ost = ost_table[i];
1206
                    if (ost->source_index == ist_index) {
1207
                        os = output_files[ost->file_index];
1208

    
1209
#if 0
1210
                        printf("%d: got pts=%0.3f %0.3f\n", i, 
1211
                               (double)pkt->pts / AV_TIME_BASE, 
1212
                               ((double)ist->pts / AV_TIME_BASE) - 
1213
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1214
#endif
1215
                        /* set the input output pts pairs */
1216
                        ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1217

    
1218
                        if (ost->encoding_needed) {
1219
                            switch(ost->st->codec.codec_type) {
1220
                            case CODEC_TYPE_AUDIO:
1221
                                do_audio_out(os, ost, ist, data_buf, data_size);
1222
                                break;
1223
                            case CODEC_TYPE_VIDEO:
1224
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1225
                                    video_size += frame_size;
1226
                                    if (do_vstats && frame_size)
1227
                                        do_video_stats(os, ost, frame_size);
1228
                                break;
1229
                            default:
1230
                                av_abort();
1231
                            }
1232
                        } else {
1233
                            AVFrame avframe; //FIXME/XXX remove this
1234
                            AVPacket opkt;
1235
                            av_init_packet(&opkt);
1236

    
1237
                            /* no reencoding needed : output the packet directly */
1238
                            /* force the input stream PTS */
1239
                        
1240
                            avcodec_get_frame_defaults(&avframe);
1241
                            ost->st->codec.coded_frame= &avframe;
1242
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1243

    
1244
                            if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1245
                                audio_size += data_size;
1246
                            else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1247
                                video_size += data_size;
1248

    
1249
                            opkt.stream_index= ost->index;
1250
                            opkt.data= data_buf;
1251
                            opkt.size= data_size;
1252
                            if(pkt->pts != AV_NOPTS_VALUE)
1253
                                opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1254
                            else
1255
                                opkt.pts= AV_NOPTS_VALUE;
1256
                            opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1257
                            opkt.flags= pkt->flags;
1258
                            
1259
                            av_interleaved_write_frame(os, &opkt);
1260
                            ost->st->codec.frame_number++;
1261
                            ost->frame_number++;
1262
                        }
1263
                    }
1264
                }
1265
            av_free(buffer_to_free);
1266
        }
1267
 discard_packet:
1268
    if (pkt == NULL) {
1269
        /* EOF handling */
1270
  
1271
        for(i=0;i<nb_ostreams;i++) {
1272
            ost = ost_table[i];
1273
            if (ost->source_index == ist_index) {
1274
                AVCodecContext *enc= &ost->st->codec;
1275
                os = output_files[ost->file_index];
1276
                
1277
                if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1278
                    continue;
1279
                if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1280
                    continue;
1281

    
1282
                if (ost->encoding_needed) {
1283
                    for(;;) {
1284
                        AVPacket pkt;
1285
                        av_init_packet(&pkt);
1286
                        pkt.stream_index= ost->index;
1287
 
1288
                        switch(ost->st->codec.codec_type) {
1289
                        case CODEC_TYPE_AUDIO:        
1290
                            ret = avcodec_encode_audio(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1291
                            audio_size += ret;
1292
                            pkt.flags |= PKT_FLAG_KEY;
1293
                            break;
1294
                        case CODEC_TYPE_VIDEO:
1295
                            ret = avcodec_encode_video(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1296
                            video_size += ret;
1297
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1298
                                pkt.flags |= PKT_FLAG_KEY;
1299
                            if (ost->logfile && enc->stats_out) {
1300
                                fprintf(ost->logfile, "%s", enc->stats_out);
1301
                            }
1302
                            break;
1303
                        default:
1304
                            ret=-1;
1305
                        }
1306
                            
1307
                        if(ret<=0)
1308
                            break;
1309
                        pkt.data= bit_buffer;
1310
                        pkt.size= ret;
1311
                        if(enc->coded_frame)
1312
                            pkt.pts= enc->coded_frame->pts;
1313
                        av_interleaved_write_frame(os, &pkt);
1314
                    }
1315
                }
1316
            }
1317
        }
1318
    }
1319
 
1320
    return 0;
1321
 fail_decode:
1322
    return -1;
1323
}
1324

    
1325

    
1326
/*
1327
 * The following code is the main loop of the file converter
1328
 */
1329
static int av_encode(AVFormatContext **output_files,
1330
                     int nb_output_files,
1331
                     AVFormatContext **input_files,
1332
                     int nb_input_files,
1333
                     AVStreamMap *stream_maps, int nb_stream_maps)
1334
{
1335
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1336
    AVFormatContext *is, *os;
1337
    AVCodecContext *codec, *icodec;
1338
    AVOutputStream *ost, **ost_table = NULL;
1339
    AVInputStream *ist, **ist_table = NULL;
1340
    AVInputFile *file_table;
1341
    AVFormatContext *stream_no_data;
1342
    int key;
1343

    
1344
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1345
    if (!file_table)
1346
        goto fail;
1347

    
1348
    if (!bit_buffer)
1349
        bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
1350
    if (!bit_buffer)
1351
        goto fail;
1352
        
1353
    /* input stream init */
1354
    j = 0;
1355
    for(i=0;i<nb_input_files;i++) {
1356
        is = input_files[i];
1357
        file_table[i].ist_index = j;
1358
        file_table[i].nb_streams = is->nb_streams;
1359
        j += is->nb_streams;
1360
    }
1361
    nb_istreams = j;
1362

    
1363
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1364
    if (!ist_table)
1365
        goto fail;
1366
    
1367
    for(i=0;i<nb_istreams;i++) {
1368
        ist = av_mallocz(sizeof(AVInputStream));
1369
        if (!ist)
1370
            goto fail;
1371
        ist_table[i] = ist;
1372
    }
1373
    j = 0;
1374
    for(i=0;i<nb_input_files;i++) {
1375
        is = input_files[i];
1376
        for(k=0;k<is->nb_streams;k++) {
1377
            ist = ist_table[j++];
1378
            ist->st = is->streams[k];
1379
            ist->file_index = i;
1380
            ist->index = k;
1381
            ist->discard = 1; /* the stream is discarded by default
1382
                                 (changed later) */
1383

    
1384
            if (ist->st->codec.rate_emu) {
1385
                ist->start = av_gettime();
1386
                ist->frame = 0;
1387
            }
1388
        }
1389
    }
1390

    
1391
    /* output stream init */
1392
    nb_ostreams = 0;
1393
    for(i=0;i<nb_output_files;i++) {
1394
        os = output_files[i];
1395
        nb_ostreams += os->nb_streams;
1396
    }
1397
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1398
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1399
        exit(1);
1400
    }
1401

    
1402
    /* Sanity check the mapping args -- do the input files & streams exist? */
1403
    for(i=0;i<nb_stream_maps;i++) {
1404
        int fi = stream_maps[i].file_index;
1405
        int si = stream_maps[i].stream_index;
1406
        
1407
        if (fi < 0 || fi > nb_input_files - 1 ||
1408
            si < 0 || si > file_table[fi].nb_streams - 1) {
1409
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1410
            exit(1);
1411
        }
1412
    }
1413
    
1414
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1415
    if (!ost_table)
1416
        goto fail;
1417
    for(i=0;i<nb_ostreams;i++) {
1418
        ost = av_mallocz(sizeof(AVOutputStream));
1419
        if (!ost)
1420
            goto fail;
1421
        ost_table[i] = ost;
1422
    }
1423
    
1424
    n = 0;
1425
    for(k=0;k<nb_output_files;k++) {
1426
        os = output_files[k];
1427
        for(i=0;i<os->nb_streams;i++) {
1428
            int found;
1429
            ost = ost_table[n++];
1430
            ost->file_index = k;
1431
            ost->index = i;
1432
            ost->st = os->streams[i];
1433
            if (nb_stream_maps > 0) {
1434
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index + 
1435
                    stream_maps[n-1].stream_index;
1436
                    
1437
                /* Sanity check that the stream types match */
1438
                if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1439
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1440
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1441
                        ost->file_index, ost->index);
1442
                    exit(1);
1443
                }
1444
                
1445
            } else {
1446
                /* get corresponding input stream index : we select the first one with the right type */
1447
                found = 0;
1448
                for(j=0;j<nb_istreams;j++) {
1449
                    ist = ist_table[j];
1450
                    if (ist->discard && 
1451
                        ist->st->codec.codec_type == ost->st->codec.codec_type) {
1452
                        ost->source_index = j;
1453
                        found = 1;
1454
                        break;
1455
                    }
1456
                }
1457
                
1458
                if (!found) {
1459
                    /* try again and reuse existing stream */
1460
                    for(j=0;j<nb_istreams;j++) {
1461
                        ist = ist_table[j];
1462
                        if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1463
                            ost->source_index = j;
1464
                            found = 1;
1465
                        }
1466
                    }
1467
                    if (!found) {
1468
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1469
                                ost->file_index, ost->index);
1470
                        exit(1);
1471
                    }
1472
                }
1473
            }
1474
            ist = ist_table[ost->source_index];
1475
            ist->discard = 0;
1476
        }
1477
    }
1478

    
1479
    /* for each output stream, we compute the right encoding parameters */
1480
    for(i=0;i<nb_ostreams;i++) {
1481
        ost = ost_table[i];
1482
        ist = ist_table[ost->source_index];
1483

    
1484
        codec = &ost->st->codec;
1485
        icodec = &ist->st->codec;
1486

    
1487
        if (ost->st->stream_copy) {
1488
            /* if stream_copy is selected, no need to decode or encode */
1489
            codec->codec_id = icodec->codec_id;
1490
            codec->codec_type = icodec->codec_type;
1491
            codec->codec_tag = icodec->codec_tag;
1492
            codec->bit_rate = icodec->bit_rate;
1493
            switch(codec->codec_type) {
1494
            case CODEC_TYPE_AUDIO:
1495
                codec->sample_rate = icodec->sample_rate;
1496
                codec->channels = icodec->channels;
1497
                codec->frame_size = icodec->frame_size;
1498
                break;
1499
            case CODEC_TYPE_VIDEO:
1500
                codec->frame_rate = icodec->frame_rate;
1501
                codec->frame_rate_base = icodec->frame_rate_base;
1502
                codec->width = icodec->width;
1503
                codec->height = icodec->height;
1504
                break;
1505
            default:
1506
                av_abort();
1507
            }
1508
        } else {
1509
            switch(codec->codec_type) {
1510
            case CODEC_TYPE_AUDIO:
1511
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1512
                    goto fail;
1513
                
1514
                if (codec->channels == icodec->channels &&
1515
                    codec->sample_rate == icodec->sample_rate) {
1516
                    ost->audio_resample = 0;
1517
                } else {
1518
                    if (codec->channels != icodec->channels &&
1519
                        (icodec->codec_id == CODEC_ID_AC3 ||
1520
                         icodec->codec_id == CODEC_ID_DTS)) {
1521
                        /* Special case for 5:1 AC3 and DTS input */
1522
                        /* and mono or stereo output      */
1523
                        /* Request specific number of channels */
1524
                        icodec->channels = codec->channels;
1525
                        if (codec->sample_rate == icodec->sample_rate)
1526
                            ost->audio_resample = 0;
1527
                        else {
1528
                            ost->audio_resample = 1;
1529
                        }
1530
                    } else {
1531
                        ost->audio_resample = 1; 
1532
                    }
1533
                }
1534
                if(audio_sync_method>1)
1535
                    ost->audio_resample = 1;
1536

    
1537
                if(ost->audio_resample){
1538
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1539
                                                    codec->sample_rate, icodec->sample_rate);
1540
                    if(!ost->resample){
1541
                        printf("Can't resample.  Aborting.\n");
1542
                        av_abort();
1543
                    }
1544
                }
1545
                ist->decoding_needed = 1;
1546
                ost->encoding_needed = 1;
1547
                break;
1548
            case CODEC_TYPE_VIDEO:
1549
                if (codec->width == icodec->width &&
1550
                    codec->height == icodec->height &&
1551
                    frame_topBand == 0 &&
1552
                    frame_bottomBand == 0 &&
1553
                    frame_leftBand == 0 &&
1554
                    frame_rightBand == 0 && 
1555
                    frame_padtop == 0 &&
1556
                    frame_padbottom == 0 &&
1557
                    frame_padleft == 0 &&
1558
                    frame_padright == 0)
1559
                {
1560
                    ost->video_resample = 0;
1561
                    ost->video_crop = 0;
1562
                    ost->video_pad = 0;
1563
                } else if ((codec->width == icodec->width -
1564
                                (frame_leftBand + frame_rightBand)) &&
1565
                        (codec->height == icodec->height -
1566
                                (frame_topBand  + frame_bottomBand)))
1567
                {
1568
                    ost->video_resample = 0;
1569
                    ost->video_crop = 1;
1570
                    ost->topBand = frame_topBand;
1571
                    ost->leftBand = frame_leftBand;
1572
                } else if ((codec->width == icodec->width + 
1573
                                (frame_padleft + frame_padright)) &&
1574
                        (codec->height == icodec->height +
1575
                                (frame_padtop + frame_padbottom))) {
1576
                    ost->video_resample = 0;
1577
                    ost->video_crop = 0;
1578
                    ost->video_pad = 1;
1579
                    ost->padtop = frame_padtop;
1580
                    ost->padleft = frame_padleft;
1581
                    ost->padbottom = frame_padbottom;
1582
                    ost->padright = frame_padright;
1583
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1584
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1585
                                codec->width, codec->height ) )
1586
                        goto fail;
1587
                } else {
1588
                    ost->video_resample = 1;
1589
                    ost->video_crop = 0; // cropping is handled as part of resample
1590
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1591
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1592
                                         codec->width, codec->height ) )
1593
                        goto fail;
1594

    
1595
                    ost->img_resample_ctx = img_resample_full_init( 
1596
                                      ost->st->codec.width, ost->st->codec.height,
1597
                                      ist->st->codec.width, ist->st->codec.height,
1598
                                      frame_topBand, frame_bottomBand,
1599
                            frame_leftBand, frame_rightBand, 
1600
                            frame_padtop, frame_padbottom, 
1601
                            frame_padleft, frame_padright);
1602
                    
1603
                    ost->padtop = frame_padtop;
1604
                    ost->padleft = frame_padleft;
1605
                    ost->padbottom = frame_padbottom;
1606
                    ost->padright = frame_padright;
1607
                   
1608
                }
1609
                ost->encoding_needed = 1;
1610
                ist->decoding_needed = 1;
1611
                break;
1612
            default:
1613
                av_abort();
1614
            }
1615
            /* two pass mode */
1616
            if (ost->encoding_needed && 
1617
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1618
                char logfilename[1024];
1619
                FILE *f;
1620
                int size;
1621
                char *logbuffer;
1622
                
1623
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 
1624
                         pass_logfilename ? 
1625
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1626
                if (codec->flags & CODEC_FLAG_PASS1) {
1627
                    f = fopen(logfilename, "w");
1628
                    if (!f) {
1629
                        perror(logfilename);
1630
                        exit(1);
1631
                    }
1632
                    ost->logfile = f;
1633
                } else {
1634
                    /* read the log file */
1635
                    f = fopen(logfilename, "r");
1636
                    if (!f) {
1637
                        perror(logfilename);
1638
                        exit(1);
1639
                    }
1640
                    fseek(f, 0, SEEK_END);
1641
                    size = ftell(f);
1642
                    fseek(f, 0, SEEK_SET);
1643
                    logbuffer = av_malloc(size + 1);
1644
                    if (!logbuffer) {
1645
                        fprintf(stderr, "Could not allocate log buffer\n");
1646
                        exit(1);
1647
                    }
1648
                    size = fread(logbuffer, 1, size, f);
1649
                    fclose(f);
1650
                    logbuffer[size] = '\0';
1651
                    codec->stats_in = logbuffer;
1652
                }
1653
            }
1654
        }
1655
    }
1656

    
1657
    /* dump the file output parameters - cannot be done before in case
1658
       of stream copy */
1659
    for(i=0;i<nb_output_files;i++) {
1660
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1661
    }
1662

    
1663
    /* dump the stream mapping */
1664
    if (verbose >= 0) {
1665
        fprintf(stderr, "Stream mapping:\n");
1666
        for(i=0;i<nb_ostreams;i++) {
1667
            ost = ost_table[i];
1668
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1669
                    ist_table[ost->source_index]->file_index,
1670
                    ist_table[ost->source_index]->index,
1671
                    ost->file_index, 
1672
                    ost->index);
1673
        }
1674
    }
1675

    
1676
    /* open each encoder */
1677
    for(i=0;i<nb_ostreams;i++) {
1678
        ost = ost_table[i];
1679
        if (ost->encoding_needed) {
1680
            AVCodec *codec;
1681
            codec = avcodec_find_encoder(ost->st->codec.codec_id);
1682
            if (!codec) {
1683
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n", 
1684
                        ost->file_index, ost->index);
1685
                exit(1);
1686
            }
1687
            if (avcodec_open(&ost->st->codec, codec) < 0) {
1688
                fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n", 
1689
                        ost->file_index, ost->index);
1690
                exit(1);
1691
            }
1692
            extra_size += ost->st->codec.extradata_size;
1693
        }
1694
    }
1695

    
1696
    /* open each decoder */
1697
    for(i=0;i<nb_istreams;i++) {
1698
        ist = ist_table[i];
1699
        if (ist->decoding_needed) {
1700
            AVCodec *codec;
1701
            codec = avcodec_find_decoder(ist->st->codec.codec_id);
1702
            if (!codec) {
1703
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n", 
1704
                        ist->st->codec.codec_id, ist->file_index, ist->index);
1705
                exit(1);
1706
            }
1707
            if (avcodec_open(&ist->st->codec, codec) < 0) {
1708
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
1709
                        ist->file_index, ist->index);
1710
                exit(1);
1711
            }
1712
            //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1713
            //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1714
        }
1715
    }
1716

    
1717
    /* init pts */
1718
    for(i=0;i<nb_istreams;i++) {
1719
        ist = ist_table[i];
1720
        is = input_files[ist->file_index];
1721
        ist->pts = 0;
1722
        ist->next_pts = ist->st->start_time;
1723
        if(ist->next_pts == AV_NOPTS_VALUE) 
1724
            ist->next_pts=0;
1725
        ist->is_start = 1;
1726
    }
1727

    
1728
    /* compute buffer size max (should use a complete heuristic) */
1729
    for(i=0;i<nb_input_files;i++) {
1730
        file_table[i].buffer_size_max = 2048;
1731
    }
1732

    
1733
    /* set meta data information from input file if required */
1734
    for (i=0;i<nb_meta_data_maps;i++) {
1735
        AVFormatContext *out_file;
1736
        AVFormatContext *in_file;
1737

    
1738
        int out_file_index = meta_data_maps[i].out_file;
1739
        int in_file_index = meta_data_maps[i].in_file;
1740
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1741
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1742
            ret = -EINVAL;
1743
            goto fail;
1744
        }
1745
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1746
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1747
            ret = -EINVAL;
1748
            goto fail;
1749
        }                
1750
                 
1751
        out_file = output_files[out_file_index];
1752
        in_file = input_files[in_file_index];
1753

    
1754
        strcpy(out_file->title, in_file->title);
1755
        strcpy(out_file->author, in_file->author);
1756
        strcpy(out_file->copyright, in_file->copyright);
1757
        strcpy(out_file->comment, in_file->comment);
1758
        strcpy(out_file->album, in_file->album);
1759
        out_file->year = in_file->year;
1760
        out_file->track = in_file->track;
1761
        strcpy(out_file->genre, in_file->genre);
1762
    }
1763
        
1764
    /* open files and write file headers */
1765
    for(i=0;i<nb_output_files;i++) {
1766
        os = output_files[i];
1767
        if (av_write_header(os) < 0) {
1768
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1769
            ret = -EINVAL;
1770
            goto fail;
1771
        }
1772
    }
1773

    
1774
#ifndef CONFIG_WIN32
1775
    if ( !using_stdin && verbose >= 0) {
1776
        fprintf(stderr, "Press [q] to stop encoding\n");
1777
        url_set_interrupt_cb(decode_interrupt_cb);
1778
    }
1779
#endif
1780
    term_init();
1781

    
1782
    stream_no_data = 0;
1783
    key = -1;
1784

    
1785
    for(; received_sigterm == 0;) {
1786
        int file_index, ist_index;
1787
        AVPacket pkt;
1788
        double ipts_min;
1789
        double opts_min;
1790

    
1791
    redo:
1792
        ipts_min= 1e100;
1793
        opts_min= 1e100;
1794
        /* if 'q' pressed, exits */
1795
        if (!using_stdin) {
1796
            if (q_pressed)
1797
                break;
1798
            /* read_key() returns 0 on EOF */
1799
            key = read_key();
1800
            if (key == 'q')
1801
                break;
1802
        }
1803

    
1804
        /* select the stream that we must read now by looking at the
1805
           smallest output pts */
1806
        file_index = -1;
1807
        for(i=0;i<nb_ostreams;i++) {
1808
            double ipts, opts;
1809
            ost = ost_table[i];
1810
            os = output_files[ost->file_index];
1811
            ist = ist_table[ost->source_index];
1812
            if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1813
                opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1814
            else
1815
                opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1816
            ipts = (double)ist->pts;
1817
            if (!file_table[ist->file_index].eof_reached){
1818
                if(ipts < ipts_min) {
1819
                    ipts_min = ipts;
1820
                    if(input_sync ) file_index = ist->file_index;
1821
                }
1822
                if(opts < opts_min) {
1823
                    opts_min = opts;
1824
                    if(!input_sync) file_index = ist->file_index;
1825
                }
1826
            }
1827
        }
1828
        /* if none, if is finished */
1829
        if (file_index < 0) {
1830
            break;
1831
        }
1832

    
1833
        /* finish if recording time exhausted */
1834
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1835
            break;
1836

    
1837
        /* read a frame from it and output it in the fifo */
1838
        is = input_files[file_index];
1839
        if (av_read_frame(is, &pkt) < 0) {
1840
            file_table[file_index].eof_reached = 1;
1841
            continue;
1842
        }
1843

    
1844
        if (!pkt.size) {
1845
            stream_no_data = is;
1846
        } else {
1847
            stream_no_data = 0;
1848
        }
1849
        if (do_pkt_dump) {
1850
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1851
        }
1852
        /* the following test is needed in case new streams appear
1853
           dynamically in stream : we ignore them */
1854
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1855
            goto discard_packet;
1856
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1857
        ist = ist_table[ist_index];
1858
        if (ist->discard)
1859
            goto discard_packet;
1860

    
1861
//        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);
1862
        if (pkt.dts != AV_NOPTS_VALUE) {
1863
            int64_t delta= pkt.dts - ist->next_pts;
1864
            if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1865
                input_files_ts_offset[ist->file_index]-= delta;
1866
                if (verbose > 2)
1867
                    fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1868
                for(i=0; i<file_table[file_index].nb_streams; i++){
1869
                    int index= file_table[file_index].ist_index + i;
1870
                    ist_table[index]->next_pts += delta;
1871
                    ist_table[index]->is_start=1;
1872
                }
1873
            }
1874
        }
1875

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

    
1879
            if (verbose >= 0)
1880
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1881
                        ist->file_index, ist->index);
1882

    
1883
            av_free_packet(&pkt);
1884
            goto redo;
1885
        }
1886
        
1887
    discard_packet:
1888
        av_free_packet(&pkt);
1889
        
1890
        /* dump report by using the output first video and audio streams */
1891
        print_report(output_files, ost_table, nb_ostreams, 0);
1892
    }
1893

    
1894
    /* at the end of stream, we must flush the decoder buffers */
1895
    for(i=0;i<nb_istreams;i++) {
1896
        ist = ist_table[i];
1897
        if (ist->decoding_needed) {
1898
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1899
        }
1900
    }
1901

    
1902
    term_exit();
1903

    
1904
    /* write the trailer if needed and close file */
1905
    for(i=0;i<nb_output_files;i++) {
1906
        os = output_files[i];
1907
        av_write_trailer(os);
1908
    }
1909

    
1910
    /* dump report by using the first video and audio streams */
1911
    print_report(output_files, ost_table, nb_ostreams, 1);
1912

    
1913
    /* close each encoder */
1914
    for(i=0;i<nb_ostreams;i++) {
1915
        ost = ost_table[i];
1916
        if (ost->encoding_needed) {
1917
            av_freep(&ost->st->codec.stats_in);
1918
            avcodec_close(&ost->st->codec);
1919
        }
1920
    }
1921
    
1922
    /* close each decoder */
1923
    for(i=0;i<nb_istreams;i++) {
1924
        ist = ist_table[i];
1925
        if (ist->decoding_needed) {
1926
            avcodec_close(&ist->st->codec);
1927
        }
1928
    }
1929

    
1930
    /* finished ! */
1931
    
1932
    ret = 0;
1933
 fail1:
1934
    av_free(file_table);
1935

    
1936
    if (ist_table) {
1937
        for(i=0;i<nb_istreams;i++) {
1938
            ist = ist_table[i];
1939
            av_free(ist);
1940
        }
1941
        av_free(ist_table);
1942
    }
1943
    if (ost_table) {
1944
        for(i=0;i<nb_ostreams;i++) {
1945
            ost = ost_table[i];
1946
            if (ost) {
1947
                if (ost->logfile) {
1948
                    fclose(ost->logfile);
1949
                    ost->logfile = NULL;
1950
                }
1951
                fifo_free(&ost->fifo); /* works even if fifo is not
1952
                                          initialized but set to zero */
1953
                av_free(ost->pict_tmp.data[0]);
1954
                if (ost->video_resample)
1955
                    img_resample_close(ost->img_resample_ctx);
1956
                if (ost->audio_resample)
1957
                    audio_resample_close(ost->resample);
1958
                av_free(ost);
1959
            }
1960
        }
1961
        av_free(ost_table);
1962
    }
1963
    return ret;
1964
 fail:
1965
    ret = -ENOMEM;
1966
    goto fail1;
1967
}
1968

    
1969
#if 0
1970
int file_read(const char *filename)
1971
{
1972
    URLContext *h;
1973
    unsigned char buffer[1024];
1974
    int len, i;
1975

1976
    if (url_open(&h, filename, O_RDONLY) < 0) {
1977
        printf("could not open '%s'\n", filename);
1978
        return -1;
1979
    }
1980
    for(;;) {
1981
        len = url_read(h, buffer, sizeof(buffer));
1982
        if (len <= 0)
1983
            break;
1984
        for(i=0;i<len;i++) putchar(buffer[i]);
1985
    }
1986
    url_close(h);
1987
    return 0;
1988
}
1989
#endif
1990

    
1991
static void opt_image_format(const char *arg)
1992
{
1993
    AVImageFormat *f;
1994
    
1995
    for(f = first_image_format; f != NULL; f = f->next) {
1996
        if (!strcmp(arg, f->name))
1997
            break;
1998
    }
1999
    if (!f) {
2000
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2001
        exit(1);
2002
    }
2003
    image_format = f;
2004
}
2005

    
2006
static void opt_format(const char *arg)
2007
{
2008
    /* compatibility stuff for pgmyuv */
2009
    if (!strcmp(arg, "pgmyuv")) {
2010
        opt_image_format(arg);
2011
        arg = "image";
2012
    }
2013

    
2014
    file_iformat = av_find_input_format(arg);
2015
    file_oformat = guess_format(arg, NULL, NULL);
2016
    if (!file_iformat && !file_oformat) {
2017
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2018
        exit(1);
2019
    }
2020
}
2021

    
2022
static void opt_video_bitrate(const char *arg)
2023
{
2024
    video_bit_rate = atoi(arg) * 1000;
2025
}
2026

    
2027
static void opt_video_bitrate_tolerance(const char *arg)
2028
{
2029
    video_bit_rate_tolerance = atoi(arg) * 1000;
2030
}
2031

    
2032
static void opt_video_bitrate_max(const char *arg)
2033
{
2034
    video_rc_max_rate = atoi(arg) * 1000;
2035
}
2036

    
2037
static void opt_video_bitrate_min(const char *arg)
2038
{
2039
    video_rc_min_rate = atoi(arg) * 1000;
2040
}
2041

    
2042
static void opt_video_buffer_size(const char *arg)
2043
{
2044
    video_rc_buffer_size = atoi(arg) * 8*1024;
2045
}
2046

    
2047
static void opt_video_rc_eq(char *arg)
2048
{
2049
    video_rc_eq = arg;
2050
}
2051

    
2052
static void opt_video_rc_override_string(char *arg)
2053
{
2054
    video_rc_override_string = arg;
2055
}
2056

    
2057

    
2058
static void opt_workaround_bugs(const char *arg)
2059
{
2060
    workaround_bugs = atoi(arg);
2061
}
2062

    
2063
static void opt_dct_algo(const char *arg)
2064
{
2065
    dct_algo = atoi(arg);
2066
}
2067

    
2068
static void opt_idct_algo(const char *arg)
2069
{
2070
    idct_algo = atoi(arg);
2071
}
2072

    
2073
static void opt_me_threshold(const char *arg)
2074
{
2075
    me_threshold = atoi(arg);
2076
}
2077

    
2078
static void opt_mb_threshold(const char *arg)
2079
{
2080
    mb_threshold = atoi(arg);
2081
}
2082

    
2083
static void opt_error_resilience(const char *arg)
2084
{
2085
    error_resilience = atoi(arg);
2086
}
2087

    
2088
static void opt_error_concealment(const char *arg)
2089
{
2090
    error_concealment = atoi(arg);
2091
}
2092

    
2093
static void opt_debug(const char *arg)
2094
{
2095
    debug = atoi(arg);
2096
}
2097

    
2098
static void opt_vismv(const char *arg)
2099
{
2100
    debug_mv = atoi(arg);
2101
}
2102
    
2103
static void opt_verbose(const char *arg)
2104
{
2105
    verbose = atoi(arg);
2106
    av_log_set_level(atoi(arg));
2107
}
2108

    
2109
static void opt_frame_rate(const char *arg)
2110
{
2111
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2112
        fprintf(stderr, "Incorrect frame rate\n");
2113
        exit(1);
2114
    }
2115
}
2116

    
2117
static void opt_frame_crop_top(const char *arg)
2118
{
2119
    frame_topBand = atoi(arg); 
2120
    if (frame_topBand < 0) {
2121
        fprintf(stderr, "Incorrect top crop size\n");
2122
        exit(1);
2123
    }
2124
    if ((frame_topBand % 2) != 0) {
2125
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2126
        exit(1);
2127
    }
2128
    if ((frame_topBand) >= frame_height){
2129
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2130
        exit(1);
2131
    }
2132
    frame_height -= frame_topBand;
2133
}
2134

    
2135
static void opt_frame_crop_bottom(const char *arg)
2136
{
2137
    frame_bottomBand = atoi(arg);
2138
    if (frame_bottomBand < 0) {
2139
        fprintf(stderr, "Incorrect bottom crop size\n");
2140
        exit(1);
2141
    }
2142
    if ((frame_bottomBand % 2) != 0) {
2143
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2144
        exit(1);        
2145
    }
2146
    if ((frame_bottomBand) >= frame_height){
2147
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2148
        exit(1);
2149
    }
2150
    frame_height -= frame_bottomBand;
2151
}
2152

    
2153
static void opt_frame_crop_left(const char *arg)
2154
{
2155
    frame_leftBand = atoi(arg);
2156
    if (frame_leftBand < 0) {
2157
        fprintf(stderr, "Incorrect left crop size\n");
2158
        exit(1);
2159
    }
2160
    if ((frame_leftBand % 2) != 0) {
2161
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2162
        exit(1);
2163
    }
2164
    if ((frame_leftBand) >= frame_width){
2165
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2166
        exit(1);
2167
    }
2168
    frame_width -= frame_leftBand;
2169
}
2170

    
2171
static void opt_frame_crop_right(const char *arg)
2172
{
2173
    frame_rightBand = atoi(arg);
2174
    if (frame_rightBand < 0) {
2175
        fprintf(stderr, "Incorrect right crop size\n");
2176
        exit(1);
2177
    }
2178
    if ((frame_rightBand % 2) != 0) {
2179
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2180
        exit(1);        
2181
    }
2182
    if ((frame_rightBand) >= frame_width){
2183
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2184
        exit(1);
2185
    }
2186
    frame_width -= frame_rightBand;
2187
}
2188

    
2189
static void opt_frame_size(const char *arg)
2190
{
2191
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2192
        fprintf(stderr, "Incorrect frame size\n");
2193
        exit(1);
2194
    }
2195
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2196
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2197
        exit(1);
2198
    }
2199
}
2200

    
2201

    
2202
#define SCALEBITS 10
2203
#define ONE_HALF  (1 << (SCALEBITS - 1))
2204
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
2205

    
2206
#define RGB_TO_Y(r, g, b) \
2207
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2208
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2209

    
2210
#define RGB_TO_U(r1, g1, b1, shift)\
2211
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2212
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2213

    
2214
#define RGB_TO_V(r1, g1, b1, shift)\
2215
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2216
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2217

    
2218
static void opt_pad_color(const char *arg) {
2219
    /* Input is expected to be six hex digits similar to
2220
       how colors are expressed in html tags (but without the #) */
2221
    int rgb = strtol(arg, NULL, 16);
2222
    int r,g,b;
2223
    
2224
    r = (rgb >> 16); 
2225
    g = ((rgb >> 8) & 255);
2226
    b = (rgb & 255);
2227

    
2228
    padcolor[0] = RGB_TO_Y(r,g,b);
2229
    padcolor[1] = RGB_TO_U(r,g,b,0);
2230
    padcolor[2] = RGB_TO_V(r,g,b,0);
2231
}
2232

    
2233
static void opt_frame_pad_top(const char *arg)
2234
{
2235
    frame_padtop = atoi(arg); 
2236
    if (frame_padtop < 0) {
2237
        fprintf(stderr, "Incorrect top pad size\n");
2238
        exit(1);
2239
    }
2240
    if ((frame_padtop % 2) != 0) {
2241
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2242
        exit(1);
2243
    }
2244
}
2245

    
2246
static void opt_frame_pad_bottom(const char *arg)
2247
{
2248
    frame_padbottom = atoi(arg); 
2249
    if (frame_padbottom < 0) {
2250
        fprintf(stderr, "Incorrect bottom pad size\n");
2251
        exit(1);
2252
    }
2253
    if ((frame_padbottom % 2) != 0) {
2254
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2255
        exit(1);
2256
    }
2257
}
2258

    
2259

    
2260
static void opt_frame_pad_left(const char *arg)
2261
{
2262
    frame_padleft = atoi(arg); 
2263
    if (frame_padleft < 0) {
2264
        fprintf(stderr, "Incorrect left pad size\n");
2265
        exit(1);
2266
    }
2267
    if ((frame_padleft % 2) != 0) {
2268
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2269
        exit(1);
2270
    }
2271
}
2272

    
2273

    
2274
static void opt_frame_pad_right(const char *arg)
2275
{
2276
    frame_padright = atoi(arg); 
2277
    if (frame_padright < 0) {
2278
        fprintf(stderr, "Incorrect right pad size\n");
2279
        exit(1);
2280
    }
2281
    if ((frame_padright % 2) != 0) {
2282
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2283
        exit(1);
2284
    }
2285
}
2286

    
2287

    
2288
static void opt_frame_pix_fmt(const char *arg)
2289
{
2290
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2291
}
2292

    
2293
static void opt_frame_aspect_ratio(const char *arg)
2294
{
2295
    int x = 0, y = 0;
2296
    double ar = 0;
2297
    const char *p;
2298
    
2299
    p = strchr(arg, ':');
2300
    if (p) {
2301
        x = strtol(arg, (char **)&arg, 10);
2302
        if (arg == p)
2303
            y = strtol(arg+1, (char **)&arg, 10);
2304
        if (x > 0 && y > 0)
2305
            ar = (double)x / (double)y;
2306
    } else
2307
        ar = strtod(arg, (char **)&arg);
2308

    
2309
    if (!ar) {
2310
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2311
        exit(1);
2312
    }
2313
    frame_aspect_ratio = ar;
2314
}
2315

    
2316
static void opt_gop_size(const char *arg)
2317
{
2318
    gop_size = atoi(arg);
2319
}
2320

    
2321
static void opt_b_frames(const char *arg)
2322
{
2323
    b_frames = atoi(arg);
2324
    if (b_frames > FF_MAX_B_FRAMES) {
2325
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2326
        exit(1);
2327
    } else if (b_frames < 1) {
2328
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2329
        exit(1);
2330
    }
2331
}
2332

    
2333
static void opt_mb_decision(const char *arg)
2334
{
2335
    mb_decision = atoi(arg);
2336
}
2337

    
2338
static void opt_mb_cmp(const char *arg)
2339
{
2340
    mb_cmp = atoi(arg);
2341
}
2342

    
2343
static void opt_ildct_cmp(const char *arg)
2344
{
2345
    ildct_cmp = atoi(arg);
2346
}
2347

    
2348
static void opt_sub_cmp(const char *arg)
2349
{
2350
    sub_cmp = atoi(arg);
2351
}
2352

    
2353
static void opt_cmp(const char *arg)
2354
{
2355
    cmp = atoi(arg);
2356
}
2357

    
2358
static void opt_pre_cmp(const char *arg)
2359
{
2360
    pre_cmp = atoi(arg);
2361
}
2362

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

    
2368
static void opt_lumi_mask(const char *arg)
2369
{
2370
    lumi_mask = atof(arg);
2371
}
2372

    
2373
static void opt_dark_mask(const char *arg)
2374
{
2375
    dark_mask = atof(arg);
2376
}
2377

    
2378
static void opt_scplx_mask(const char *arg)
2379
{
2380
    scplx_mask = atof(arg);
2381
}
2382

    
2383
static void opt_tcplx_mask(const char *arg)
2384
{
2385
    tcplx_mask = atof(arg);
2386
}
2387

    
2388
static void opt_p_mask(const char *arg)
2389
{
2390
    p_mask = atof(arg);
2391
}
2392

    
2393
static void opt_qscale(const char *arg)
2394
{
2395
    video_qscale = atof(arg);
2396
    if (video_qscale < 0.01 ||
2397
        video_qscale > 255) {
2398
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2399
        exit(1);
2400
    }
2401
}
2402

    
2403
static void opt_lmax(const char *arg)
2404
{
2405
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2406
}
2407

    
2408
static void opt_lmin(const char *arg)
2409
{
2410
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2411
}
2412

    
2413
static void opt_qmin(const char *arg)
2414
{
2415
    video_qmin = atoi(arg);
2416
    if (video_qmin < 0 ||
2417
        video_qmin > 31) {
2418
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2419
        exit(1);
2420
    }
2421
}
2422

    
2423
static void opt_qmax(const char *arg)
2424
{
2425
    video_qmax = atoi(arg);
2426
    if (video_qmax < 0 ||
2427
        video_qmax > 31) {
2428
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2429
        exit(1);
2430
    }
2431
}
2432

    
2433
static void opt_mb_qmin(const char *arg)
2434
{
2435
    video_mb_qmin = atoi(arg);
2436
    if (video_mb_qmin < 0 ||
2437
        video_mb_qmin > 31) {
2438
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2439
        exit(1);
2440
    }
2441
}
2442

    
2443
static void opt_mb_qmax(const char *arg)
2444
{
2445
    video_mb_qmax = atoi(arg);
2446
    if (video_mb_qmax < 0 ||
2447
        video_mb_qmax > 31) {
2448
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2449
        exit(1);
2450
    }
2451
}
2452

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

    
2463
static void opt_qblur(const char *arg)
2464
{
2465
    video_qblur = atof(arg);
2466
}
2467

    
2468
static void opt_qcomp(const char *arg)
2469
{
2470
    video_qcomp = atof(arg);
2471
}
2472

    
2473
static void opt_rc_initial_cplx(const char *arg)
2474
{
2475
    video_rc_initial_cplx = atof(arg);
2476
}
2477
static void opt_b_qfactor(const char *arg)
2478
{
2479
    video_b_qfactor = atof(arg);
2480
}
2481
static void opt_i_qfactor(const char *arg)
2482
{
2483
    video_i_qfactor = atof(arg);
2484
}
2485
static void opt_b_qoffset(const char *arg)
2486
{
2487
    video_b_qoffset = atof(arg);
2488
}
2489
static void opt_i_qoffset(const char *arg)
2490
{
2491
    video_i_qoffset = atof(arg);
2492
}
2493

    
2494
static void opt_ibias(const char *arg)
2495
{
2496
    video_intra_quant_bias = atoi(arg);
2497
}
2498
static void opt_pbias(const char *arg)
2499
{
2500
    video_inter_quant_bias = atoi(arg);
2501
}
2502

    
2503
static void opt_packet_size(const char *arg)
2504
{
2505
    packet_size= atoi(arg);
2506
}
2507

    
2508
static void opt_error_rate(const char *arg)
2509
{
2510
    error_rate= atoi(arg);
2511
}
2512

    
2513
static void opt_strict(const char *arg)
2514
{
2515
    strict= atoi(arg);
2516
}
2517

    
2518
static void opt_top_field_first(const char *arg)
2519
{
2520
    top_field_first= atoi(arg);
2521
}
2522

    
2523
static void opt_noise_reduction(const char *arg)
2524
{
2525
    noise_reduction= atoi(arg);
2526
}
2527

    
2528
static void opt_qns(const char *arg)
2529
{
2530
    qns= atoi(arg);
2531
}
2532

    
2533
static void opt_sc_threshold(const char *arg)
2534
{
2535
    sc_threshold= atoi(arg);
2536
}
2537

    
2538
static void opt_me_range(const char *arg)
2539
{
2540
    me_range = atoi(arg);
2541
}
2542

    
2543
static void opt_thread_count(const char *arg)
2544
{
2545
    thread_count= atoi(arg);
2546
#if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2547
    if (verbose >= 0)
2548
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2549
#endif
2550
}
2551

    
2552
static void opt_audio_bitrate(const char *arg)
2553
{
2554
    audio_bit_rate = atoi(arg) * 1000;
2555
}
2556

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

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

    
2567
static void opt_video_device(const char *arg)
2568
{
2569
    video_device = av_strdup(arg);
2570
}
2571

    
2572
static void opt_video_channel(const char *arg)
2573
{
2574
    video_channel = strtol(arg, NULL, 0);
2575
}
2576

    
2577
static void opt_video_standard(const char *arg)
2578
{
2579
    video_standard = av_strdup(arg);
2580
}
2581

    
2582
static void opt_audio_device(const char *arg)
2583
{
2584
    audio_device = av_strdup(arg);
2585
}
2586

    
2587
static void opt_dv1394(const char *arg)
2588
{
2589
    video_grab_format = "dv1394";
2590
    audio_grab_format = NULL;
2591
}
2592

    
2593
static void opt_audio_codec(const char *arg)
2594
{
2595
    AVCodec *p;
2596

    
2597
    if (!strcmp(arg, "copy")) {
2598
        audio_stream_copy = 1;
2599
    } else {
2600
        p = first_avcodec;
2601
        while (p) {
2602
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2603
                break;
2604
            p = p->next;
2605
        }
2606
        if (p == NULL) {
2607
            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2608
            exit(1);
2609
        } else {
2610
            audio_codec_id = p->id;
2611
        }
2612
    }
2613
}
2614

    
2615
static void add_frame_hooker(const char *arg)
2616
{
2617
    int argc = 0;
2618
    char *argv[64];
2619
    int i;
2620
    char *args = av_strdup(arg);
2621

    
2622
    using_vhook = 1;
2623

    
2624
    argv[0] = strtok(args, " ");
2625
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2626
    }
2627

    
2628
    i = frame_hook_add(argc, argv);
2629

    
2630
    if (i != 0) {
2631
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2632
        exit(1);
2633
    }
2634
}
2635

    
2636
const char *motion_str[] = {
2637
    "zero",
2638
    "full",
2639
    "log",
2640
    "phods",
2641
    "epzs",
2642
    "x1",
2643
    NULL,
2644
};
2645

    
2646
static void opt_motion_estimation(const char *arg)
2647
{
2648
    const char **p;
2649
    p = motion_str;
2650
    for(;;) {
2651
        if (!*p) {
2652
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2653
            exit(1);
2654
        }
2655
        if (!strcmp(*p, arg))
2656
            break;
2657
        p++;
2658
    }
2659
    me_method = (p - motion_str) + 1;
2660
}
2661

    
2662
static void opt_video_codec(const char *arg)
2663
{
2664
    AVCodec *p;
2665

    
2666
    if (!strcmp(arg, "copy")) {
2667
        video_stream_copy = 1;
2668
    } else {
2669
        p = first_avcodec;
2670
        while (p) {
2671
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2672
                break;
2673
            p = p->next;
2674
        }
2675
        if (p == NULL) {
2676
            fprintf(stderr, "Unknown video codec '%s'\n", arg);
2677
            exit(1);
2678
        } else {
2679
            video_codec_id = p->id;
2680
        }
2681
    }
2682
}
2683

    
2684
static void opt_map(const char *arg)
2685
{
2686
    AVStreamMap *m;
2687
    const char *p;
2688

    
2689
    p = arg;
2690
    m = &stream_maps[nb_stream_maps++];
2691

    
2692
    m->file_index = strtol(arg, (char **)&p, 0);
2693
    if (*p)
2694
        p++;
2695

    
2696
    m->stream_index = strtol(p, (char **)&p, 0);
2697
}
2698

    
2699
static void opt_map_meta_data(const char *arg)
2700
{
2701
    AVMetaDataMap *m;
2702
    const char *p;
2703
        
2704
    p = arg;
2705
    m = &meta_data_maps[nb_meta_data_maps++];
2706

    
2707
    m->out_file = strtol(arg, (char **)&p, 0);
2708
    if (*p)
2709
        p++;
2710

    
2711
    m->in_file = strtol(p, (char **)&p, 0);
2712
}
2713

    
2714
static void opt_recording_time(const char *arg)
2715
{
2716
    recording_time = parse_date(arg, 1);
2717
}
2718

    
2719
static void opt_start_time(const char *arg)
2720
{
2721
    start_time = parse_date(arg, 1);
2722
}
2723

    
2724
static void opt_rec_timestamp(const char *arg)
2725
{
2726
    rec_timestamp = parse_date(arg, 0) / 1000000;
2727
}
2728

    
2729
static void opt_input_ts_offset(const char *arg)
2730
{
2731
    input_ts_offset = parse_date(arg, 1);
2732
}
2733

    
2734
static void opt_input_file(const char *filename)
2735
{
2736
    AVFormatContext *ic;
2737
    AVFormatParameters params, *ap = &params;
2738
    int err, i, ret, rfps, rfps_base;
2739
    int64_t timestamp;
2740

    
2741
    if (!strcmp(filename, "-"))
2742
        filename = "pipe:";
2743

    
2744
    using_stdin |= !strcmp(filename, "pipe:" ) || 
2745
                   !strcmp( filename, "/dev/stdin" );
2746

    
2747
    /* get default parameters from command line */
2748
    memset(ap, 0, sizeof(*ap));
2749
    ap->sample_rate = audio_sample_rate;
2750
    ap->channels = audio_channels;
2751
    ap->frame_rate = frame_rate;
2752
    ap->frame_rate_base = frame_rate_base;
2753
    ap->width = frame_width + frame_padleft + frame_padright;
2754
    ap->height = frame_height + frame_padtop + frame_padbottom;
2755
    ap->image_format = image_format;
2756
    ap->pix_fmt = frame_pix_fmt;
2757

    
2758
    /* open the input file with generic libav function */
2759
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2760
    if (err < 0) {
2761
        print_error(filename, err);
2762
        exit(1);
2763
    }
2764
    
2765
    /* If not enough info to get the stream parameters, we decode the
2766
       first frames to get it. (used in mpeg case for example) */
2767
    ret = av_find_stream_info(ic);
2768
    if (ret < 0 && verbose >= 0) {
2769
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2770
        exit(1);
2771
    }
2772

    
2773
    timestamp = start_time;
2774
    /* add the stream start time */
2775
    if (ic->start_time != AV_NOPTS_VALUE)
2776
        timestamp += ic->start_time;
2777

    
2778
    /* if seeking requested, we execute it */
2779
    if (start_time != 0) {
2780
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2781
        if (ret < 0) {
2782
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
2783
                    filename, (double)timestamp / AV_TIME_BASE);
2784
        }
2785
        /* reset seek info */
2786
        start_time = 0;
2787
    }
2788

    
2789
    /* update the current parameters so that they match the one of the input stream */
2790
    for(i=0;i<ic->nb_streams;i++) {
2791
        AVCodecContext *enc = &ic->streams[i]->codec;
2792
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2793
        if(thread_count>1)
2794
            avcodec_thread_init(enc, thread_count);
2795
#endif
2796
        enc->thread_count= thread_count;
2797
        switch(enc->codec_type) {
2798
        case CODEC_TYPE_AUDIO:
2799
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2800
            audio_channels = enc->channels;
2801
            audio_sample_rate = enc->sample_rate;
2802
            break;
2803
        case CODEC_TYPE_VIDEO:
2804
            frame_height = enc->height;
2805
            frame_width = enc->width;
2806
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2807
            frame_pix_fmt = enc->pix_fmt;
2808
            rfps      = ic->streams[i]->r_frame_rate;
2809
            rfps_base = ic->streams[i]->r_frame_rate_base;
2810
            enc->workaround_bugs = workaround_bugs;
2811
            enc->error_resilience = error_resilience; 
2812
            enc->error_concealment = error_concealment; 
2813
            enc->idct_algo = idct_algo;
2814
            enc->debug = debug;
2815
            enc->debug_mv = debug_mv;            
2816
            enc->lowres= lowres;
2817
            if(bitexact)
2818
                enc->flags|= CODEC_FLAG_BITEXACT;
2819
            if(me_threshold)
2820
                enc->debug |= FF_DEBUG_MV;
2821

    
2822
            assert(enc->frame_rate_base == rfps_base); // should be true for now
2823
            if (enc->frame_rate != rfps) { 
2824

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

    
2829
                    (float)rfps / rfps_base);
2830
            }
2831
            /* update the current frame rate to match the stream frame rate */
2832
            frame_rate      = rfps;
2833
            frame_rate_base = rfps_base;
2834

    
2835
            enc->rate_emu = rate_emu;
2836
            break;
2837
        case CODEC_TYPE_DATA:
2838
            break;
2839
        default:
2840
            av_abort();
2841
        }
2842
    }
2843
    
2844
    input_files[nb_input_files] = ic;
2845
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2846
    /* dump the file content */
2847
    if (verbose >= 0)
2848
        dump_format(ic, nb_input_files, filename, 0);
2849

    
2850
    nb_input_files++;
2851
    file_iformat = NULL;
2852
    file_oformat = NULL;
2853
    image_format = NULL;
2854

    
2855
    rate_emu = 0;
2856
}
2857

    
2858
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2859
{
2860
    int has_video, has_audio, i, j;
2861
    AVFormatContext *ic;
2862

    
2863
    has_video = 0;
2864
    has_audio = 0;
2865
    for(j=0;j<nb_input_files;j++) {
2866
        ic = input_files[j];
2867
        for(i=0;i<ic->nb_streams;i++) {
2868
            AVCodecContext *enc = &ic->streams[i]->codec;
2869
            switch(enc->codec_type) {
2870
            case CODEC_TYPE_AUDIO:
2871
                has_audio = 1;
2872
                break;
2873
            case CODEC_TYPE_VIDEO:
2874
                has_video = 1;
2875
                break;
2876
            case CODEC_TYPE_DATA:
2877
                break;
2878
            default:
2879
                av_abort();
2880
            }
2881
        }
2882
    }
2883
    *has_video_ptr = has_video;
2884
    *has_audio_ptr = has_audio;
2885
}
2886

    
2887
static void opt_output_file(const char *filename)
2888
{
2889
    AVStream *st;
2890
    AVFormatContext *oc;
2891
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2892
    int codec_id;
2893
    AVFormatParameters params, *ap = &params;
2894

    
2895
    if (!strcmp(filename, "-"))
2896
        filename = "pipe:";
2897

    
2898
    oc = av_alloc_format_context();
2899

    
2900
    if (!file_oformat) {
2901
        file_oformat = guess_format(NULL, filename, NULL);
2902
        if (!file_oformat) {
2903
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2904
                    filename);
2905
            exit(1);
2906
        }
2907
    }
2908
    
2909
    oc->oformat = file_oformat;
2910

    
2911
    if (!strcmp(file_oformat->name, "ffm") && 
2912
        strstart(filename, "http:", NULL)) {
2913
        /* special case for files sent to ffserver: we get the stream
2914
           parameters from ffserver */
2915
        if (read_ffserver_streams(oc, filename) < 0) {
2916
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2917
            exit(1);
2918
        }
2919
    } else {
2920
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2921
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2922

    
2923
        /* disable if no corresponding type found and at least one
2924
           input file */
2925
        if (nb_input_files > 0) {
2926
            check_audio_video_inputs(&input_has_video, &input_has_audio);
2927
            if (!input_has_video)
2928
                use_video = 0;
2929
            if (!input_has_audio)
2930
                use_audio = 0;
2931
        }
2932

    
2933
        /* manual disable */
2934
        if (audio_disable) {
2935
            use_audio = 0;
2936
        }
2937
        if (video_disable) {
2938
            use_video = 0;
2939
        }
2940
        
2941
        nb_streams = 0;
2942
        if (use_video) {
2943
            AVCodecContext *video_enc;
2944
            
2945
            st = av_new_stream(oc, nb_streams++);
2946
            if (!st) {
2947
                fprintf(stderr, "Could not alloc stream\n");
2948
                exit(1);
2949
            }
2950
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2951
            if(thread_count>1)
2952
                avcodec_thread_init(&st->codec, thread_count);
2953
#endif
2954

    
2955
            video_enc = &st->codec;
2956
            
2957
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2958
                video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2959
            if (video_stream_copy) {
2960
                st->stream_copy = 1;
2961
                video_enc->codec_type = CODEC_TYPE_VIDEO;
2962
            } else {
2963
                char *p;
2964
                int i;
2965
                AVCodec *codec;
2966
            
2967
                codec_id = file_oformat->video_codec;
2968
                if (video_codec_id != CODEC_ID_NONE)
2969
                    codec_id = video_codec_id;
2970
                
2971
                video_enc->codec_id = codec_id;
2972
                codec = avcodec_find_encoder(codec_id);
2973
                
2974
                video_enc->bit_rate = video_bit_rate;
2975
                video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2976
                video_enc->frame_rate = frame_rate; 
2977
                video_enc->frame_rate_base = frame_rate_base; 
2978
                if(codec && codec->supported_framerates){
2979
                    const AVRational *p= codec->supported_framerates;
2980
                    AVRational req= (AVRational){frame_rate, frame_rate_base};
2981
                    const AVRational *best=NULL;
2982
                    AVRational best_error= (AVRational){INT_MAX, 1};
2983
                    for(; p->den!=0; p++){
2984
                        AVRational error= av_sub_q(req, *p);
2985
                        if(error.num <0) error.num *= -1;
2986
                        if(av_cmp_q(error, best_error) < 0){
2987
                            best_error= error;
2988
                            best= p;
2989
                        }
2990
                    }
2991
                    video_enc->frame_rate     = best->num;
2992
                    video_enc->frame_rate_base= best->den;
2993
                }
2994
                
2995
                video_enc->width = frame_width + frame_padright + frame_padleft;
2996
                video_enc->height = frame_height + frame_padtop + frame_padbottom;
2997
                video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2998
                video_enc->pix_fmt = frame_pix_fmt;
2999

    
3000
                if(codec && codec->pix_fmts){
3001
                    const enum PixelFormat *p= codec->pix_fmts;
3002
                    for(; *p!=-1; p++){
3003
                        if(*p == video_enc->pix_fmt)
3004
                            break;
3005
                    }
3006
                    if(*p == -1)
3007
                        video_enc->pix_fmt = codec->pix_fmts[0];
3008
                }
3009

    
3010
                if (!intra_only)
3011
                    video_enc->gop_size = gop_size;
3012
                else
3013
                    video_enc->gop_size = 0;
3014
                if (video_qscale || same_quality) {
3015
                    video_enc->flags |= CODEC_FLAG_QSCALE;
3016
                    st->quality = FF_QP2LAMBDA * video_qscale;
3017
                }
3018

    
3019
                if(intra_matrix)
3020
                    video_enc->intra_matrix = intra_matrix;
3021
                if(inter_matrix)
3022
                    video_enc->inter_matrix = inter_matrix;
3023

    
3024
                if(bitexact)
3025
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
3026

    
3027
                video_enc->mb_decision = mb_decision;
3028
                video_enc->mb_cmp = mb_cmp;
3029
                video_enc->ildct_cmp = ildct_cmp;
3030
                video_enc->me_sub_cmp = sub_cmp;
3031
                video_enc->me_cmp = cmp;
3032
                video_enc->me_pre_cmp = pre_cmp;
3033
                video_enc->pre_me = pre_me;
3034
                video_enc->lumi_masking = lumi_mask;
3035
                video_enc->dark_masking = dark_mask;
3036
                video_enc->spatial_cplx_masking = scplx_mask;
3037
                video_enc->temporal_cplx_masking = tcplx_mask;
3038
                video_enc->p_masking = p_mask;
3039
                video_enc->quantizer_noise_shaping= qns;
3040
                
3041
                if (use_umv) {
3042
                    video_enc->flags |= CODEC_FLAG_H263P_UMV;
3043
                }
3044
                if (use_ss) {
3045
                    video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3046
                }
3047
                   if (use_aic) {
3048
                    video_enc->flags |= CODEC_FLAG_H263P_AIC;
3049
                }
3050
                   if (use_aiv) {
3051
                    video_enc->flags |= CODEC_FLAG_H263P_AIV;
3052
                }
3053
                if (use_4mv) {
3054
                    video_enc->flags |= CODEC_FLAG_4MV;
3055
                }
3056
                if (use_obmc) {
3057
                    video_enc->flags |= CODEC_FLAG_OBMC;
3058
                }
3059
                if (use_loop) {
3060
                    video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3061
                }
3062
            
3063
                if(use_part) {
3064
                    video_enc->flags |= CODEC_FLAG_PART;
3065
                }
3066
                   if (use_alt_scan) {
3067
                    video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3068
                }
3069
                   if (use_trell) {
3070
                    video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3071
                }
3072
                   if (use_scan_offset) {
3073
                    video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3074
                }
3075
                   if (closed_gop) {
3076
                    video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3077
                }
3078
                   if (use_qpel) {
3079
                    video_enc->flags |= CODEC_FLAG_QPEL;
3080
                }
3081
                   if (use_qprd) {
3082
                    video_enc->flags |= CODEC_FLAG_QP_RD;
3083
                }
3084
                   if (use_cbprd) {
3085
                    video_enc->flags |= CODEC_FLAG_CBP_RD;
3086
                }
3087
                if (b_frames) {
3088
                    video_enc->max_b_frames = b_frames;
3089
                    video_enc->b_frame_strategy = 0;
3090
                    video_enc->b_quant_factor = 2.0;
3091
                }
3092
                if (do_interlace_dct) {
3093
                    video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3094
                }
3095
                if (do_interlace_me) {
3096
                    video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3097
                }
3098
                video_enc->qmin = video_qmin;
3099
                video_enc->qmax = video_qmax;
3100
                video_enc->lmin = video_lmin;
3101
                video_enc->lmax = video_lmax;
3102
                video_enc->mb_qmin = video_mb_qmin;
3103
                video_enc->mb_qmax = video_mb_qmax;
3104
                video_enc->max_qdiff = video_qdiff;
3105
                video_enc->qblur = video_qblur;
3106
                video_enc->qcompress = video_qcomp;
3107
                video_enc->rc_eq = video_rc_eq;
3108
                video_enc->debug = debug;
3109
                video_enc->debug_mv = debug_mv;
3110
                video_enc->thread_count = thread_count;
3111
                p= video_rc_override_string;
3112
                for(i=0; p; i++){
3113
                    int start, end, q;
3114
                    int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3115
                    if(e!=3){
3116
                        fprintf(stderr, "error parsing rc_override\n");
3117
                        exit(1);
3118
                    }
3119
                    video_enc->rc_override= 
3120
                        av_realloc(video_enc->rc_override, 
3121
                                   sizeof(RcOverride)*(i+1));
3122
                    video_enc->rc_override[i].start_frame= start;
3123
                    video_enc->rc_override[i].end_frame  = end;
3124
                    if(q>0){
3125
                        video_enc->rc_override[i].qscale= q;
3126
                        video_enc->rc_override[i].quality_factor= 1.0;
3127
                    }
3128
                    else{
3129
                        video_enc->rc_override[i].qscale= 0;
3130
                        video_enc->rc_override[i].quality_factor= -q/100.0;
3131
                    }
3132
                    p= strchr(p, '/');
3133
                    if(p) p++;
3134
                }
3135
                video_enc->rc_override_count=i;
3136

    
3137
                video_enc->rc_max_rate = video_rc_max_rate;
3138
                video_enc->rc_min_rate = video_rc_min_rate;
3139
                video_enc->rc_buffer_size = video_rc_buffer_size;
3140
                video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3141
                video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3142
                video_enc->rc_initial_cplx= video_rc_initial_cplx;
3143
                video_enc->i_quant_factor = video_i_qfactor;
3144
                video_enc->b_quant_factor = video_b_qfactor;
3145
                video_enc->i_quant_offset = video_i_qoffset;
3146
                video_enc->b_quant_offset = video_b_qoffset;
3147
                video_enc->intra_quant_bias = video_intra_quant_bias;
3148
                video_enc->inter_quant_bias = video_inter_quant_bias;
3149
                video_enc->dct_algo = dct_algo;
3150
                video_enc->idct_algo = idct_algo;
3151
                video_enc->me_threshold= me_threshold;
3152
                video_enc->mb_threshold= mb_threshold;
3153
                video_enc->intra_dc_precision= intra_dc_precision - 8;
3154
                video_enc->strict_std_compliance = strict;
3155
                video_enc->error_rate = error_rate;
3156
                video_enc->noise_reduction= noise_reduction;
3157
                video_enc->scenechange_threshold= sc_threshold;
3158
                video_enc->me_range = me_range;
3159
                video_enc->coder_type= coder;
3160
                video_enc->context_model= context;
3161
                video_enc->prediction_method= predictor;
3162
                video_enc->profile= video_profile;
3163
                video_enc->level= video_level;
3164
                video_enc->nsse_weight= nsse_weight;
3165
                video_enc->me_subpel_quality= subpel_quality;
3166

    
3167
                if(packet_size){
3168
                    video_enc->rtp_mode= 1;
3169
                    video_enc->rtp_payload_size= packet_size;
3170
                }
3171
            
3172
                if (do_psnr)
3173
                    video_enc->flags|= CODEC_FLAG_PSNR;
3174
            
3175
                video_enc->me_method = me_method;
3176

    
3177
                /* two pass mode */
3178
                if (do_pass) {
3179
                    if (do_pass == 1) {
3180
                        video_enc->flags |= CODEC_FLAG_PASS1;
3181
                    } else {
3182
                        video_enc->flags |= CODEC_FLAG_PASS2;
3183
                    }
3184
                }
3185
            }
3186
        }
3187
    
3188
        if (use_audio) {
3189
            AVCodecContext *audio_enc;
3190

    
3191
            st = av_new_stream(oc, nb_streams++);
3192
            if (!st) {
3193
                fprintf(stderr, "Could not alloc stream\n");
3194
                exit(1);
3195
            }
3196
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
3197
            if(thread_count>1)
3198
                avcodec_thread_init(&st->codec, thread_count);
3199
#endif
3200

    
3201
            audio_enc = &st->codec;
3202
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3203

    
3204
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3205
                audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3206
            if (audio_stream_copy) {
3207
                st->stream_copy = 1;
3208
                audio_enc->channels = audio_channels;
3209
            } else {
3210
                codec_id = file_oformat->audio_codec;
3211
                if (audio_codec_id != CODEC_ID_NONE)
3212
                    codec_id = audio_codec_id;
3213
                audio_enc->codec_id = codec_id;
3214
                
3215
                audio_enc->bit_rate = audio_bit_rate;
3216
                audio_enc->strict_std_compliance = strict;
3217
                audio_enc->thread_count = thread_count;
3218
                /* For audio codecs other than AC3 or DTS we limit */
3219
                /* the number of coded channels to stereo   */
3220
                if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3221
                    && codec_id != CODEC_ID_DTS) {
3222
                    audio_enc->channels = 2;
3223
                } else
3224
                    audio_enc->channels = audio_channels;
3225
            }
3226
            audio_enc->sample_rate = audio_sample_rate;
3227
        }
3228

    
3229
        oc->nb_streams = nb_streams;
3230

    
3231
        if (!nb_streams) {
3232
            fprintf(stderr, "No audio or video streams available\n");
3233
            exit(1);
3234
        }
3235

    
3236
        oc->timestamp = rec_timestamp;
3237
            
3238
        if (str_title)
3239
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3240
        if (str_author)
3241
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3242
        if (str_copyright)
3243
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3244
        if (str_comment)
3245
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3246
    }
3247

    
3248
    output_files[nb_output_files++] = oc;
3249

    
3250
    strcpy(oc->filename, filename);
3251

    
3252
    /* check filename in case of an image number is expected */
3253
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3254
        if (filename_number_test(oc->filename) < 0) {
3255
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3256
            exit(1);
3257
        }
3258
    }
3259

    
3260
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3261
        /* test if it already exists to avoid loosing precious files */
3262
        if (!file_overwrite && 
3263
            (strchr(filename, ':') == NULL ||
3264
             strstart(filename, "file:", NULL))) {
3265
            if (url_exist(filename)) {
3266
                int c;
3267
                
3268
                if ( !using_stdin ) {
3269
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3270
                    fflush(stderr);
3271
                    c = getchar();
3272
                    if (toupper(c) != 'Y') {
3273
                        fprintf(stderr, "Not overwriting - exiting\n");
3274
                        exit(1);
3275
                    }
3276
                                }
3277
                                else {
3278
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3279
                    exit(1);
3280
                                }
3281
            }
3282
        }
3283
        
3284
        /* open the file */
3285
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3286
            fprintf(stderr, "Could not open '%s'\n", filename);
3287
            exit(1);
3288
        }
3289
    }
3290

    
3291
    memset(ap, 0, sizeof(*ap));
3292
    ap->image_format = image_format;
3293
    if (av_set_parameters(oc, ap) < 0) {
3294
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3295
                oc->filename);
3296
        exit(1);
3297
    }
3298

    
3299
    oc->packet_size= mux_packet_size;
3300
    oc->mux_rate= mux_rate;
3301

    
3302
    /* reset some options */
3303
    file_oformat = NULL;
3304
    file_iformat = NULL;
3305
    image_format = NULL;
3306
    audio_disable = 0;
3307
    video_disable = 0;
3308
    audio_codec_id = CODEC_ID_NONE;
3309
    video_codec_id = CODEC_ID_NONE;
3310
    audio_stream_copy = 0;
3311
    video_stream_copy = 0;
3312
}
3313

    
3314
/* prepare dummy protocols for grab */
3315
static void prepare_grab(void)
3316
{
3317
    int has_video, has_audio, i, j;
3318
    AVFormatContext *oc;
3319
    AVFormatContext *ic;
3320
    AVFormatParameters vp1, *vp = &vp1;
3321
    AVFormatParameters ap1, *ap = &ap1;
3322
    
3323
    /* see if audio/video inputs are needed */
3324
    has_video = 0;
3325
    has_audio = 0;
3326
    memset(ap, 0, sizeof(*ap));
3327
    memset(vp, 0, sizeof(*vp));
3328
    vp->frame_rate_base= 1;
3329
    for(j=0;j<nb_output_files;j++) {
3330
        oc = output_files[j];
3331
        for(i=0;i<oc->nb_streams;i++) {
3332
            AVCodecContext *enc = &oc->streams[i]->codec;
3333
            switch(enc->codec_type) {
3334
            case CODEC_TYPE_AUDIO:
3335
                if (enc->sample_rate > ap->sample_rate)
3336
                    ap->sample_rate = enc->sample_rate;
3337
                if (enc->channels > ap->channels)
3338
                    ap->channels = enc->channels;
3339
                has_audio = 1;
3340
                break;
3341
            case CODEC_TYPE_VIDEO:
3342
                if (enc->width > vp->width)
3343
                    vp->width = enc->width;
3344
                if (enc->height > vp->height)
3345
                    vp->height = enc->height;
3346
                
3347
                if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3348
                    vp->frame_rate      = enc->frame_rate;
3349
                    vp->frame_rate_base = enc->frame_rate_base;
3350
                }
3351
                has_video = 1;
3352
                break;
3353
            default:
3354
                av_abort();
3355
            }
3356
        }
3357
    }
3358
    
3359
    if (has_video == 0 && has_audio == 0) {
3360
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3361
        exit(1);
3362
    }
3363
    
3364
    if (has_video) {
3365
        AVInputFormat *fmt1;
3366
        fmt1 = av_find_input_format(video_grab_format);
3367
        vp->device  = video_device;
3368
        vp->channel = video_channel;
3369
        vp->standard = video_standard;
3370
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3371
            fprintf(stderr, "Could not find video grab device\n");
3372
            exit(1);
3373
        }
3374
        /* If not enough info to get the stream parameters, we decode the
3375
           first frames to get it. */
3376
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3377
            fprintf(stderr, "Could not find video grab parameters\n");
3378
            exit(1);
3379
        }
3380
        /* by now video grab has one stream */
3381
        ic->streams[0]->r_frame_rate      = vp->frame_rate;
3382
        ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3383
        input_files[nb_input_files] = ic;
3384

    
3385
        if (verbose >= 0)
3386
            dump_format(ic, nb_input_files, "", 0);
3387

    
3388
        nb_input_files++;
3389
    }
3390
    if (has_audio && audio_grab_format) {
3391
        AVInputFormat *fmt1;
3392
        fmt1 = av_find_input_format(audio_grab_format);
3393
        ap->device = audio_device;
3394
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3395
            fprintf(stderr, "Could not find audio grab device\n");
3396
            exit(1);
3397
        }
3398
        input_files[nb_input_files] = ic;
3399

    
3400
        if (verbose >= 0)
3401
            dump_format(ic, nb_input_files, "", 0);
3402

    
3403
        nb_input_files++;
3404
    }
3405
}
3406

    
3407
/* same option as mencoder */
3408
static void opt_pass(const char *pass_str)
3409
{
3410
    int pass;
3411
    pass = atoi(pass_str);
3412
    if (pass != 1 && pass != 2) {
3413
        fprintf(stderr, "pass number can be only 1 or 2\n");
3414
        exit(1);
3415
    }
3416
    do_pass = pass;
3417
}
3418

    
3419
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3420
static int64_t getutime(void)
3421
{
3422
  return av_gettime();
3423
}
3424
#else
3425
static int64_t getutime(void)
3426
{
3427
    struct rusage rusage;
3428

    
3429
    getrusage(RUSAGE_SELF, &rusage);
3430
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3431
}
3432
#endif
3433

    
3434
extern int ffm_nopts;
3435

    
3436
static void opt_bitexact(void)
3437
{
3438
    bitexact=1;
3439
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3440
    ffm_nopts = 1;
3441
}
3442

    
3443
static void show_formats(void)
3444
{
3445
    AVInputFormat *ifmt;
3446
    AVOutputFormat *ofmt;
3447
    AVImageFormat *image_fmt;
3448
    URLProtocol *up;
3449
    AVCodec *p, *p2;
3450
    const char **pp, *last_name;
3451

    
3452
    printf("File formats:\n");
3453
    last_name= "000";
3454
    for(;;){
3455
        int decode=0;
3456
        int encode=0;
3457
        const char *name=NULL;
3458

    
3459
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3460
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3461
                strcmp(ofmt->name, last_name)>0){
3462
                name= ofmt->name;
3463
                encode=1;
3464
            }
3465
        }
3466
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3467
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3468
                strcmp(ifmt->name, last_name)>0){
3469
                name= ifmt->name;
3470
                encode=0;
3471
            }
3472
            if(name && strcmp(ifmt->name, name)==0)
3473
                decode=1;
3474
        }
3475
        if(name==NULL)
3476
            break;
3477
        last_name= name;
3478
        
3479
        printf(
3480
            " %s%s %s\n", 
3481
            decode ? "D":" ", 
3482
            encode ? "E":" ", 
3483
            name);
3484
    }
3485
    printf("\n");
3486

    
3487
    printf("Image formats:\n");
3488
    for(image_fmt = first_image_format; image_fmt != NULL; 
3489
        image_fmt = image_fmt->next) {
3490
        printf(
3491
            " %s%s %s\n",
3492
            image_fmt->img_read  ? "D":" ",
3493
            image_fmt->img_write ? "E":" ",
3494
            image_fmt->name);
3495
    }
3496
    printf("\n");
3497

    
3498
    printf("Codecs:\n");
3499
    last_name= "000";
3500
    for(;;){
3501
        int decode=0;
3502
        int encode=0;
3503
        int cap=0;
3504

    
3505
        p2=NULL;
3506
        for(p = first_avcodec; p != NULL; p = p->next) {
3507
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3508
                strcmp(p->name, last_name)>0){
3509
                p2= p;
3510
                decode= encode= cap=0;
3511
            }
3512
            if(p2 && strcmp(p->name, p2->name)==0){
3513
                if(p->decode) decode=1;
3514
                if(p->encode) encode=1;
3515
                cap |= p->capabilities;
3516
            }
3517
        }
3518
        if(p2==NULL)
3519
            break;
3520
        last_name= p2->name;
3521
        
3522
        printf(
3523
            " %s%s%s%s%s%s %s", 
3524
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
3525
            encode ? "E":" ", 
3526
            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3527
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3528
            cap & CODEC_CAP_DR1 ? "D":" ",
3529
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3530
            p2->name);
3531
       /* if(p2->decoder && decode==0)
3532
            printf(" use %s for decoding", p2->decoder->name);*/
3533
        printf("\n");
3534
    }
3535
    printf("\n");
3536

    
3537
    printf("Supported file protocols:\n");
3538
    for(up = first_protocol; up != NULL; up = up->next)
3539
        printf(" %s:", up->name);
3540
    printf("\n");
3541
    
3542
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3543
    printf("Motion estimation methods:\n");
3544
    pp = motion_str;
3545
    while (*pp) {
3546
        printf(" %s", *pp);
3547
        if ((pp - motion_str + 1) == ME_ZERO) 
3548
            printf("(fastest)");
3549
        else if ((pp - motion_str + 1) == ME_FULL) 
3550
            printf("(slowest)");
3551
        else if ((pp - motion_str + 1) == ME_EPZS) 
3552
            printf("(default)");
3553
        pp++;
3554
    }
3555
    printf("\n\n");
3556
    printf(
3557
"Note, the names of encoders and decoders dont always match, so there are\n"
3558
"several cases where the above table shows encoder only or decoder only entries\n"
3559
"even though both encoding and decoding are supported for example, the h263\n"
3560
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3561
"worse\n");
3562
    exit(1);
3563
}
3564

    
3565
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3566
{
3567
    int i;
3568
    const char *p = str;
3569
    for(i = 0;; i++) {
3570
        dest[i] = atoi(p);
3571
        if(i == 63)
3572
            break;
3573
        p = strchr(p, ',');
3574
        if(!p) {
3575
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3576
            exit(1);
3577
        }
3578
        p++;
3579
    }
3580
}
3581

    
3582
void opt_inter_matrix(const char *arg)
3583
{
3584
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3585
    parse_matrix_coeffs(inter_matrix, arg);
3586
}
3587

    
3588
void opt_intra_matrix(const char *arg)
3589
{
3590
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3591
    parse_matrix_coeffs(intra_matrix, arg);
3592
}
3593

    
3594
static void opt_target(const char *arg)
3595
{
3596
    int norm = -1;
3597

    
3598
    if(!strncmp(arg, "pal-", 4)) {
3599
        norm = 0;
3600
        arg += 4;
3601
    } else if(!strncmp(arg, "ntsc-", 5)) {
3602
        norm = 1;
3603
        arg += 5;
3604
    } else {
3605
        int fr;
3606
        /* Calculate FR via float to avoid int overflow */
3607
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3608
        if(fr == 25000) {
3609
            norm = 0;
3610
        } else if((fr == 29970) || (fr == 23976)) {
3611
            norm = 1;
3612
        } else {
3613
            /* Try to determine PAL/NTSC by peeking in the input files */
3614
            if(nb_input_files) {
3615
                int i, j;
3616
                for(j = 0; j < nb_input_files; j++) {
3617
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3618
                        AVCodecContext *c = &input_files[j]->streams[i]->codec;
3619
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3620
                            continue;
3621
                        fr = c->frame_rate * 1000 / c->frame_rate_base;
3622
                        if(fr == 25000) {
3623
                            norm = 0;
3624
                            break;
3625
                        } else if((fr == 29970) || (fr == 23976)) {
3626
                            norm = 1;
3627
                            break;
3628
                        }
3629
                    }
3630
                    if(norm >= 0)
3631
                        break;
3632
                }
3633
            }
3634
        }
3635
        if(verbose && norm >= 0)
3636
            printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3637
    }
3638

    
3639
    if(norm < 0) {
3640
        fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3641
        fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3642
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3643
        exit(1);
3644
    }
3645

    
3646
    if(!strcmp(arg, "vcd")) {
3647

    
3648
        opt_video_codec("mpeg1video");
3649
        opt_audio_codec("mp2");
3650
        opt_format("vcd");
3651

    
3652
        opt_frame_size(norm ? "352x240" : "352x288");
3653

    
3654
        video_bit_rate = 1150000;
3655
        video_rc_max_rate = 1150000;
3656
        video_rc_min_rate = 1150000;
3657
        video_rc_buffer_size = 40*1024*8;
3658

    
3659
        audio_bit_rate = 224000;
3660
        audio_sample_rate = 44100;
3661
        
3662
        mux_packet_size= 2324;
3663
        mux_rate= 2352 * 75 * 8;
3664

    
3665
    } else if(!strcmp(arg, "svcd")) {
3666

    
3667
        opt_video_codec("mpeg2video");
3668
        opt_audio_codec("mp2");
3669
        opt_format("svcd");
3670

    
3671
        opt_frame_size(norm ? "480x480" : "480x576");
3672
        opt_gop_size(norm ? "18" : "15");
3673

    
3674
        video_bit_rate = 2040000;
3675
        video_rc_max_rate = 2516000;
3676
        video_rc_min_rate = 0; //1145000;
3677
        video_rc_buffer_size = 224*1024*8;
3678
        use_scan_offset = 1;
3679

    
3680
        audio_bit_rate = 224000;
3681
        audio_sample_rate = 44100;
3682

    
3683
        mux_packet_size= 2324;
3684

    
3685
    } else if(!strcmp(arg, "dvd")) {
3686

    
3687
        opt_video_codec("mpeg2video");
3688
        opt_audio_codec("ac3");
3689
        opt_format("dvd");
3690

    
3691
        opt_frame_size(norm ? "720x480" : "720x576");
3692
        opt_gop_size(norm ? "18" : "15");
3693

    
3694
        video_bit_rate = 6000000;
3695
        video_rc_max_rate = 9000000;
3696
        video_rc_min_rate = 0; //1500000;
3697
        video_rc_buffer_size = 224*1024*8;
3698

    
3699
        audio_bit_rate = 448000;
3700
        audio_sample_rate = 48000;
3701

    
3702
    } else {
3703
        fprintf(stderr, "Unknown target: %s\n", arg);
3704
        exit(1);
3705
    }
3706
}
3707

    
3708
static void show_version(void)
3709
{
3710
    printf("ffmpeg      " FFMPEG_VERSION "\n"
3711
           "libavcodec  %d\n"
3712
           "libavformat %d\n", 
3713
           avcodec_build(), LIBAVFORMAT_BUILD);
3714
    exit(1);
3715
}
3716

    
3717
const OptionDef options[] = {
3718
    /* main options */
3719
    { "L", 0, {(void*)show_license}, "show license" },
3720
    { "h", 0, {(void*)show_help}, "show help" },
3721
    { "version", 0, {(void*)show_version}, "show version" },
3722
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3723
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3724
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3725
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3726
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3727
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3728
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3729
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3730
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3731
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3732
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3733
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3734
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3735
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3736
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3737
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3738
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3739
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
3740
      "add timings for benchmarking" },
3741
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
3742
      "dump each input packet" },
3743
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
3744
      "when dumping packets, also dump the payload" },
3745
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
3746
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3747
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3748
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3749
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3750
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3751
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3752
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3753
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3754

    
3755
    /* video options */
3756
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3757
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3758
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3759
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3760
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3761
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3762
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3763
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3764
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3765
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3766
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3767
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3768
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3769
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3770
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3771
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3772
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3773
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3774
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3775
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3776
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3777
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3778
    { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3779
    { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3780
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3781
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3782
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3783
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3784
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3785
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3786
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3787
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3788
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3789
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3790
//    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3791
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3792
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3793
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3794
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3795
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3796
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3797
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3798
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
3799
      "method" },
3800
    { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3801
    { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3802
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3803
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3804
    { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3805
    { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3806
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3807
    { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3808
    { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3809
    { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3810
    { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3811
    { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3812
    { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3813
    { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3814
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3815
    { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3816
    { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3817
    { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3818
    { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3819
    { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3820
    { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3821
    { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3822
    { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3823
    { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3824
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3825
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3826
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3827
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3828
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
3829
      "use same video quality as source (implies VBR)" },
3830
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3831
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3832
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
3833
      "deinterlace pictures" },
3834
    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 
3835
      "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3836
    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 
3837
      "force interlaced me support in encoder (MPEG2/MPEG4)" },
3838
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3839
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
3840
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3841
    { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3842
    { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3843
    { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3844
    { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3845
    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3846
    { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3847
    { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3848
    { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3849
    { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3850
    { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3851
    { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3852
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3853
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3854
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3855
    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3856
    { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3857
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3858
    { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3859
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3860
    { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3861
    { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3862
    { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3863
    { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
3864
    { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
3865
    { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
3866
    { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
3867
    { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
3868

    
3869
    /* audio options */
3870
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3871
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3872
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3873
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3874
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3875

    
3876
    /* grab options */
3877
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3878
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3879
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3880
    { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3881
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3882
 
3883
    /* muxer options */   
3884
    { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
3885
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
3886
    { NULL, },
3887
};
3888

    
3889
static void show_banner(void)
3890
{
3891
    printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
3892
        LIBAVCODEC_BUILD);
3893
    printf("  built on " __DATE__ " " __TIME__);
3894
#ifdef __GNUC__
3895
    printf(", gcc: %s\n", __VERSION__);
3896
#else
3897
    printf(", using a non-gcc compiler\n");
3898
#endif
3899
}
3900

    
3901
static void show_license(void)
3902
{
3903
    show_banner();
3904
#ifdef CONFIG_GPL
3905
    printf(
3906
    "This program is free software; you can redistribute it and/or modify\n"   
3907
    "it under the terms of the GNU General Public License as published by\n"
3908
    "the Free Software Foundation; either version 2 of the License, or\n"
3909
    "(at your option) any later version.\n"
3910
    "\n"
3911
    "This program is distributed in the hope that it will be useful,\n"
3912
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3913
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3914
    "GNU General Public License for more details.\n"
3915
    "\n"
3916
    "You should have received a copy of the GNU General Public License\n"
3917
    "along with this program; if not, write to the Free Software\n"
3918
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3919
    );
3920
#else
3921
    printf(
3922
    "This library is free software; you can redistribute it and/or\n"
3923
    "modify it under the terms of the GNU Lesser General Public\n"
3924
    "License as published by the Free Software Foundation; either\n"
3925
    "version 2 of the License, or (at your option) any later version.\n"
3926
    "\n"
3927
    "This library is distributed in the hope that it will be useful,\n"
3928
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3929
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3930
    "Lesser General Public License for more details.\n"
3931
    "\n"
3932
    "You should have received a copy of the GNU Lesser General Public\n"
3933
    "License along with this library; if not, write to the Free Software\n"
3934
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3935
    );
3936
#endif
3937
    exit(1);
3938
}
3939

    
3940
static void show_help(void)
3941
{
3942
    show_banner();
3943
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3944
           "Hyper fast Audio and Video encoder\n");
3945
    printf("\n");
3946
    show_help_options(options, "Main options:\n",
3947
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3948
    show_help_options(options, "\nVideo options:\n",
3949
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3950
                      OPT_VIDEO);
3951
    show_help_options(options, "\nAdvanced Video options:\n",
3952
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3953
                      OPT_VIDEO | OPT_EXPERT);
3954
    show_help_options(options, "\nAudio options:\n",
3955
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3956
                      OPT_AUDIO);
3957
    show_help_options(options, "\nAdvanced Audio options:\n",
3958
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3959
                      OPT_AUDIO | OPT_EXPERT);
3960
    show_help_options(options, "\nAudio/Video grab options:\n",
3961
                      OPT_GRAB, 
3962
                      OPT_GRAB);
3963
    show_help_options(options, "\nAdvanced options:\n",
3964
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3965
                      OPT_EXPERT);
3966
    exit(1);
3967
}
3968

    
3969
void parse_arg_file(const char *filename)
3970
{
3971
    opt_output_file(filename);
3972
}
3973

    
3974
int main(int argc, char **argv)
3975
{
3976
    int i;
3977
    int64_t ti;
3978

    
3979
    av_register_all();
3980

    
3981
    if (argc <= 1)
3982
        show_help();
3983
    else
3984
        show_banner();
3985
    
3986
    /* parse options */
3987
    parse_options(argc, argv, options);
3988

    
3989
    /* file converter / grab */
3990
    if (nb_output_files <= 0) {
3991
        fprintf(stderr, "Must supply at least one output file\n");
3992
        exit(1);
3993
    }
3994
    
3995
    if (nb_input_files == 0) {
3996
        input_sync = 1;
3997
        prepare_grab();
3998
    }
3999

    
4000
    ti = getutime();
4001
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
4002
              stream_maps, nb_stream_maps);
4003
    ti = getutime() - ti;
4004
    if (do_benchmark) {
4005
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4006
    }
4007

    
4008
    /* close files */
4009
    for(i=0;i<nb_output_files;i++) {
4010
        /* maybe av_close_output_file ??? */
4011
        AVFormatContext *s = output_files[i];
4012
        int j;
4013
        if (!(s->oformat->flags & AVFMT_NOFILE))
4014
            url_fclose(&s->pb);
4015
        for(j=0;j<s->nb_streams;j++)
4016
            av_free(s->streams[j]);
4017
        av_free(s);
4018
    }
4019
    for(i=0;i<nb_input_files;i++)
4020
        av_close_input_file(input_files[i]);
4021

    
4022
    av_free_static();
4023

    
4024
    if(intra_matrix)
4025
        av_free(intra_matrix);
4026
    if(inter_matrix)
4027
        av_free(inter_matrix);
4028
    
4029
#ifdef POWERPC_PERFORMANCE_REPORT
4030
    extern void powerpc_display_perf_report(void);
4031
    powerpc_display_perf_report();
4032
#endif /* POWERPC_PERFORMANCE_REPORT */
4033

    
4034
#ifndef CONFIG_WIN32
4035
    if (received_sigterm) {
4036
        fprintf(stderr,
4037
            "Received signal %d: terminating.\n",
4038
            (int) received_sigterm);
4039
        exit (255);
4040
    }
4041
#endif
4042
    exit(0); /* not all OS-es handle main() return value */
4043
    return 0;
4044
}