Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ f20ad553

History | View | Annotate | Download (137 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 int64_t recording_time = 0;
204
static int64_t start_time = 0;
205
static int64_t rec_timestamp = 0;
206
static int64_t input_ts_offset = 0;
207
static int file_overwrite = 0;
208
static char *str_title = NULL;
209
static char *str_author = NULL;
210
static char *str_copyright = NULL;
211
static char *str_comment = NULL;
212
static int do_benchmark = 0;
213
static int do_hex_dump = 0;
214
static int do_pkt_dump = 0;
215
static int do_psnr = 0;
216
static int do_vstats = 0;
217
static int do_pass = 0;
218
static int bitexact = 0;
219
static char *pass_logfilename = NULL;
220
static int audio_stream_copy = 0;
221
static int video_stream_copy = 0;
222
static int video_sync_method= 1;
223
static int audio_sync_method= 0;
224
static int copy_ts= 0;
225

    
226
static int rate_emu = 0;
227

    
228
static char *video_grab_format = "video4linux";
229
static char *video_device = NULL;
230
static int  video_channel = 0;
231
static char *video_standard = "ntsc";
232

    
233
static char *audio_grab_format = "audio_device";
234
static char *audio_device = NULL;
235

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

    
249
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
250

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

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

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

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

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

    
309
#ifndef CONFIG_WIN32
310

    
311
/* init terminal so that we can grab keys */
312
static struct termios oldtty;
313

    
314
static void term_exit(void)
315
{
316
    tcsetattr (0, TCSANOW, &oldtty);
317
}
318

    
319
static volatile sig_atomic_t received_sigterm = 0;
320

    
321
static void
322
sigterm_handler(int sig)
323
{
324
    received_sigterm = sig;
325
    term_exit();
326
}
327

    
328
static void term_init(void)
329
{
330
    struct termios tty;
331

    
332
    tcgetattr (0, &tty);
333
    oldtty = tty;
334

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

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

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

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

    
378
        return n;
379
    }
380
    return -1;
381
}
382

    
383
static int decode_interrupt_cb(void)
384
{
385
    return q_pressed || (q_pressed = read_key() == 'q');
386
}
387

    
388
#else
389

    
390
static volatile int received_sigterm = 0;
391

    
392
/* no interactive support */
393
static void term_exit(void)
394
{
395
}
396

    
397
static void term_init(void)
398
{
399
}
400

    
401
static int read_key(void)
402
{
403
    return 0;
404
}
405

    
406
#endif
407

    
408
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
409
{
410
    int i, err;
411
    AVFormatContext *ic;
412

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

    
421
        st = av_mallocz(sizeof(AVStream));
422
        memcpy(st, ic->streams[i], sizeof(AVStream));
423
        s->streams[i] = st;
424
    }
425

    
426
    av_close_input_file(ic);
427
    return 0;
428
}
429

    
430
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
431

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

    
442
    int size_out, frame_bytes, ret;
443
    AVCodecContext *enc= &ost->st->codec;
444

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

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

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

    
475
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
476
                        ist->is_start=0;
477
                    else
478
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
479

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

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

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

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

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

    
541
        ost->sync_opts += size_out / (2 * enc->channels);
542

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

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

    
575
    dec = &ist->st->codec;
576

    
577
    /* deinterlace : must be done before any resize */
578
    if (do_deinterlace || using_vhook) {
579
        int size;
580

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

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

    
611
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
612

    
613
    if (picture != picture2)
614
        *picture = *picture2;
615
    *bufp = buf;
616
}
617

    
618
/* we begin to correct av delay at this threshold */
619
#define AV_DELAY_MAX 0.100
620

    
621

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

    
637
        if (padleft || padright) {
638
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
639
                (img->linesize[i] - (padright >> shift));
640

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

    
654
static uint8_t *bit_buffer= NULL;
655

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

    
671
    avcodec_get_frame_defaults(&picture_format_temp);
672
    avcodec_get_frame_defaults(&picture_crop_temp);
673

    
674
    enc = &ost->st->codec;
675
    dec = &ist->st->codec;
676

    
677
    /* by default, we output a single frame */
678
    nb_frames = 1;
679

    
680
    *frame_size = 0;
681

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

    
703
    if (nb_frames <= 0) 
704
        return;
705

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

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

    
724
            if (verbose >= 0)
725
                fprintf(stderr, "pixel format conversion not handled\n");
726

    
727
            goto the_end;
728
        }
729
    } else {
730
        formatted_picture = in_picture;
731
    }
732

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

    
762
                if (verbose >= 0)
763
                    fprintf(stderr, "pixel format conversion not handled\n");
764

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

    
772
        picture_crop_temp.data[1] = formatted_picture->data[1] +
773
                ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
774
                (ost->leftBand >> 1);
775

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

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

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

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

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

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

    
822
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
823
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
824
                        enc->width, enc->height) < 0) {
825

    
826
                if (verbose >= 0)
827
                    fprintf(stderr, "pixel format conversion not handled\n");
828

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

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

    
854
            av_interleaved_write_frame(s, &pkt);
855
            enc->coded_frame = old_frame;
856
        } else {
857
            AVFrame big_picture;
858

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

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

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

    
915
static double psnr(double d){
916
    if(d==0) return INFINITY;
917
    return -10.0*log(d)/log(10.0);
918
}
919

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

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

    
993

    
994
    oc = output_files[0];
995

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

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

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

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

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

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

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

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

    
1180
                ist->frame++;
1181
            }
1182

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

    
1202
                    ost = ost_table[i];
1203
                    if (ost->source_index == ist_index) {
1204
                        os = output_files[ost->file_index];
1205

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

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

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

    
1241
                            if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1242
                                audio_size += data_size;
1243
                            else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1244
                                video_size += data_size;
1245

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

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

    
1319

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

    
1338
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1339
    if (!file_table)
1340
        goto fail;
1341

    
1342
    if (!bit_buffer)
1343
        bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
1344
    if (!bit_buffer)
1345
        goto fail;
1346
        
1347
    /* input stream init */
1348
    j = 0;
1349
    for(i=0;i<nb_input_files;i++) {
1350
        is = input_files[i];
1351
        file_table[i].ist_index = j;
1352
        file_table[i].nb_streams = is->nb_streams;
1353
        j += is->nb_streams;
1354
    }
1355
    nb_istreams = j;
1356

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

    
1378
            if (ist->st->codec.rate_emu) {
1379
                ist->start = av_gettime();
1380
                ist->frame = 0;
1381
            }
1382
        }
1383
    }
1384

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

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

    
1473
    /* for each output stream, we compute the right encoding parameters */
1474
    for(i=0;i<nb_ostreams;i++) {
1475
        ost = ost_table[i];
1476
        ist = ist_table[ost->source_index];
1477

    
1478
        codec = &ost->st->codec;
1479
        icodec = &ist->st->codec;
1480

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

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

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

    
1651
    /* dump the file output parameters - cannot be done before in case
1652
       of stream copy */
1653
    for(i=0;i<nb_output_files;i++) {
1654
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1655
    }
1656

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

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

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

    
1711
    /* init pts */
1712
    for(i=0;i<nb_istreams;i++) {
1713
        ist = ist_table[i];
1714
        is = input_files[ist->file_index];
1715
        ist->pts = 0;
1716
        ist->next_pts = ist->st->start_time;
1717
        if(ist->next_pts == AV_NOPTS_VALUE) 
1718
            ist->next_pts=0;
1719
        ist->is_start = 1;
1720
    }
1721

    
1722
    /* compute buffer size max (should use a complete heuristic) */
1723
    for(i=0;i<nb_input_files;i++) {
1724
        file_table[i].buffer_size_max = 2048;
1725
    }
1726

    
1727
    /* set meta data information from input file if required */
1728
    for (i=0;i<nb_meta_data_maps;i++) {
1729
        AVFormatContext *out_file;
1730
        AVFormatContext *in_file;
1731

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

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

    
1768
#ifndef CONFIG_WIN32
1769
    if ( !using_stdin && verbose >= 0) {
1770
        fprintf(stderr, "Press [q] to stop encoding\n");
1771
        url_set_interrupt_cb(decode_interrupt_cb);
1772
    }
1773
#endif
1774
    term_init();
1775

    
1776
    stream_no_data = 0;
1777
    key = -1;
1778

    
1779
    for(; received_sigterm == 0;) {
1780
        int file_index, ist_index;
1781
        AVPacket pkt;
1782
        double ipts_min;
1783
        double opts_min;
1784

    
1785
    redo:
1786
        ipts_min= 1e100;
1787
        opts_min= 1e100;
1788
        /* if 'q' pressed, exits */
1789
        if (!using_stdin) {
1790
            if (q_pressed)
1791
                break;
1792
            /* read_key() returns 0 on EOF */
1793
            key = read_key();
1794
            if (key == 'q')
1795
                break;
1796
        }
1797

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

    
1827
        /* finish if recording time exhausted */
1828
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1829
            break;
1830

    
1831
        /* read a frame from it and output it in the fifo */
1832
        is = input_files[file_index];
1833
        if (av_read_frame(is, &pkt) < 0) {
1834
            file_table[file_index].eof_reached = 1;
1835
            continue;
1836
        }
1837

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

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

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

    
1873
            if (verbose >= 0)
1874
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1875
                        ist->file_index, ist->index);
1876

    
1877
            av_free_packet(&pkt);
1878
            goto redo;
1879
        }
1880
        
1881
    discard_packet:
1882
        av_free_packet(&pkt);
1883
        
1884
        /* dump report by using the output first video and audio streams */
1885
        print_report(output_files, ost_table, nb_ostreams, 0);
1886
    }
1887

    
1888
    /* at the end of stream, we must flush the decoder buffers */
1889
    for(i=0;i<nb_istreams;i++) {
1890
        ist = ist_table[i];
1891
        if (ist->decoding_needed) {
1892
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1893
        }
1894
    }
1895

    
1896
    term_exit();
1897

    
1898
    /* write the trailer if needed and close file */
1899
    for(i=0;i<nb_output_files;i++) {
1900
        os = output_files[i];
1901
        av_write_trailer(os);
1902
    }
1903

    
1904
    /* dump report by using the first video and audio streams */
1905
    print_report(output_files, ost_table, nb_ostreams, 1);
1906

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

    
1924
    /* finished ! */
1925
    
1926
    ret = 0;
1927
 fail1:
1928
    av_free(file_table);
1929

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

    
1963
#if 0
1964
int file_read(const char *filename)
1965
{
1966
    URLContext *h;
1967
    unsigned char buffer[1024];
1968
    int len, i;
1969

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

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

    
2000
static void opt_format(const char *arg)
2001
{
2002
    /* compatibility stuff for pgmyuv */
2003
    if (!strcmp(arg, "pgmyuv")) {
2004
        opt_image_format(arg);
2005
        arg = "image";
2006
    }
2007

    
2008
    file_iformat = av_find_input_format(arg);
2009
    file_oformat = guess_format(arg, NULL, NULL);
2010
    if (!file_iformat && !file_oformat) {
2011
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2012
        exit(1);
2013
    }
2014
}
2015

    
2016
static void opt_video_bitrate(const char *arg)
2017
{
2018
    video_bit_rate = atoi(arg) * 1000;
2019
}
2020

    
2021
static void opt_video_bitrate_tolerance(const char *arg)
2022
{
2023
    video_bit_rate_tolerance = atoi(arg) * 1000;
2024
}
2025

    
2026
static void opt_video_bitrate_max(const char *arg)
2027
{
2028
    video_rc_max_rate = atoi(arg) * 1000;
2029
}
2030

    
2031
static void opt_video_bitrate_min(const char *arg)
2032
{
2033
    video_rc_min_rate = atoi(arg) * 1000;
2034
}
2035

    
2036
static void opt_video_buffer_size(const char *arg)
2037
{
2038
    video_rc_buffer_size = atoi(arg) * 8*1024;
2039
}
2040

    
2041
static void opt_video_rc_eq(char *arg)
2042
{
2043
    video_rc_eq = arg;
2044
}
2045

    
2046
static void opt_video_rc_override_string(char *arg)
2047
{
2048
    video_rc_override_string = arg;
2049
}
2050

    
2051

    
2052
static void opt_workaround_bugs(const char *arg)
2053
{
2054
    workaround_bugs = atoi(arg);
2055
}
2056

    
2057
static void opt_dct_algo(const char *arg)
2058
{
2059
    dct_algo = atoi(arg);
2060
}
2061

    
2062
static void opt_idct_algo(const char *arg)
2063
{
2064
    idct_algo = atoi(arg);
2065
}
2066

    
2067
static void opt_me_threshold(const char *arg)
2068
{
2069
    me_threshold = atoi(arg);
2070
}
2071

    
2072
static void opt_mb_threshold(const char *arg)
2073
{
2074
    mb_threshold = atoi(arg);
2075
}
2076

    
2077
static void opt_error_resilience(const char *arg)
2078
{
2079
    error_resilience = atoi(arg);
2080
}
2081

    
2082
static void opt_error_concealment(const char *arg)
2083
{
2084
    error_concealment = atoi(arg);
2085
}
2086

    
2087
static void opt_debug(const char *arg)
2088
{
2089
    debug = atoi(arg);
2090
}
2091

    
2092
static void opt_vismv(const char *arg)
2093
{
2094
    debug_mv = atoi(arg);
2095
}
2096
    
2097
static void opt_verbose(const char *arg)
2098
{
2099
    verbose = atoi(arg);
2100
    av_log_set_level(atoi(arg));
2101
}
2102

    
2103
static void opt_frame_rate(const char *arg)
2104
{
2105
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2106
        fprintf(stderr, "Incorrect frame rate\n");
2107
        exit(1);
2108
    }
2109
}
2110

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

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

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

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

    
2183
static void opt_frame_size(const char *arg)
2184
{
2185
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2186
        fprintf(stderr, "Incorrect frame size\n");
2187
        exit(1);
2188
    }
2189
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2190
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2191
        exit(1);
2192
    }
2193
}
2194

    
2195

    
2196
#define SCALEBITS 10
2197
#define ONE_HALF  (1 << (SCALEBITS - 1))
2198
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
2199

    
2200
#define RGB_TO_Y(r, g, b) \
2201
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2202
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2203

    
2204
#define RGB_TO_U(r1, g1, b1, shift)\
2205
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2206
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2207

    
2208
#define RGB_TO_V(r1, g1, b1, shift)\
2209
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2210
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2211

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

    
2222
    padcolor[0] = RGB_TO_Y(r,g,b);
2223
    padcolor[1] = RGB_TO_U(r,g,b,0);
2224
    padcolor[2] = RGB_TO_V(r,g,b,0);
2225
}
2226

    
2227
static void opt_frame_pad_top(const char *arg)
2228
{
2229
    frame_padtop = atoi(arg); 
2230
    if (frame_padtop < 0) {
2231
        fprintf(stderr, "Incorrect top pad size\n");
2232
        exit(1);
2233
    }
2234
    if ((frame_padtop % 2) != 0) {
2235
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2236
        exit(1);
2237
    }
2238
}
2239

    
2240
static void opt_frame_pad_bottom(const char *arg)
2241
{
2242
    frame_padbottom = atoi(arg); 
2243
    if (frame_padbottom < 0) {
2244
        fprintf(stderr, "Incorrect bottom pad size\n");
2245
        exit(1);
2246
    }
2247
    if ((frame_padbottom % 2) != 0) {
2248
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2249
        exit(1);
2250
    }
2251
}
2252

    
2253

    
2254
static void opt_frame_pad_left(const char *arg)
2255
{
2256
    frame_padleft = atoi(arg); 
2257
    if (frame_padleft < 0) {
2258
        fprintf(stderr, "Incorrect left pad size\n");
2259
        exit(1);
2260
    }
2261
    if ((frame_padleft % 2) != 0) {
2262
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2263
        exit(1);
2264
    }
2265
}
2266

    
2267

    
2268
static void opt_frame_pad_right(const char *arg)
2269
{
2270
    frame_padright = atoi(arg); 
2271
    if (frame_padright < 0) {
2272
        fprintf(stderr, "Incorrect right pad size\n");
2273
        exit(1);
2274
    }
2275
    if ((frame_padright % 2) != 0) {
2276
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2277
        exit(1);
2278
    }
2279
}
2280

    
2281

    
2282
static void opt_frame_pix_fmt(const char *arg)
2283
{
2284
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2285
}
2286

    
2287
static void opt_frame_aspect_ratio(const char *arg)
2288
{
2289
    int x = 0, y = 0;
2290
    double ar = 0;
2291
    const char *p;
2292
    
2293
    p = strchr(arg, ':');
2294
    if (p) {
2295
        x = strtol(arg, (char **)&arg, 10);
2296
        if (arg == p)
2297
            y = strtol(arg+1, (char **)&arg, 10);
2298
        if (x > 0 && y > 0)
2299
            ar = (double)x / (double)y;
2300
    } else
2301
        ar = strtod(arg, (char **)&arg);
2302

    
2303
    if (!ar) {
2304
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2305
        exit(1);
2306
    }
2307
    frame_aspect_ratio = ar;
2308
}
2309

    
2310
static void opt_gop_size(const char *arg)
2311
{
2312
    gop_size = atoi(arg);
2313
}
2314

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

    
2327
static void opt_mb_decision(const char *arg)
2328
{
2329
    mb_decision = atoi(arg);
2330
}
2331

    
2332
static void opt_mb_cmp(const char *arg)
2333
{
2334
    mb_cmp = atoi(arg);
2335
}
2336

    
2337
static void opt_ildct_cmp(const char *arg)
2338
{
2339
    ildct_cmp = atoi(arg);
2340
}
2341

    
2342
static void opt_sub_cmp(const char *arg)
2343
{
2344
    sub_cmp = atoi(arg);
2345
}
2346

    
2347
static void opt_cmp(const char *arg)
2348
{
2349
    cmp = atoi(arg);
2350
}
2351

    
2352
static void opt_pre_cmp(const char *arg)
2353
{
2354
    pre_cmp = atoi(arg);
2355
}
2356

    
2357
static void opt_pre_me(const char *arg)
2358
{
2359
    pre_me = atoi(arg);
2360
}
2361

    
2362
static void opt_lumi_mask(const char *arg)
2363
{
2364
    lumi_mask = atof(arg);
2365
}
2366

    
2367
static void opt_dark_mask(const char *arg)
2368
{
2369
    dark_mask = atof(arg);
2370
}
2371

    
2372
static void opt_scplx_mask(const char *arg)
2373
{
2374
    scplx_mask = atof(arg);
2375
}
2376

    
2377
static void opt_tcplx_mask(const char *arg)
2378
{
2379
    tcplx_mask = atof(arg);
2380
}
2381

    
2382
static void opt_p_mask(const char *arg)
2383
{
2384
    p_mask = atof(arg);
2385
}
2386

    
2387
static void opt_qscale(const char *arg)
2388
{
2389
    video_qscale = atof(arg);
2390
    if (video_qscale < 0.01 ||
2391
        video_qscale > 255) {
2392
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2393
        exit(1);
2394
    }
2395
}
2396

    
2397
static void opt_lmax(const char *arg)
2398
{
2399
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2400
}
2401

    
2402
static void opt_lmin(const char *arg)
2403
{
2404
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2405
}
2406

    
2407
static void opt_qmin(const char *arg)
2408
{
2409
    video_qmin = atoi(arg);
2410
    if (video_qmin < 0 ||
2411
        video_qmin > 31) {
2412
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2413
        exit(1);
2414
    }
2415
}
2416

    
2417
static void opt_qmax(const char *arg)
2418
{
2419
    video_qmax = atoi(arg);
2420
    if (video_qmax < 0 ||
2421
        video_qmax > 31) {
2422
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2423
        exit(1);
2424
    }
2425
}
2426

    
2427
static void opt_mb_qmin(const char *arg)
2428
{
2429
    video_mb_qmin = atoi(arg);
2430
    if (video_mb_qmin < 0 ||
2431
        video_mb_qmin > 31) {
2432
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2433
        exit(1);
2434
    }
2435
}
2436

    
2437
static void opt_mb_qmax(const char *arg)
2438
{
2439
    video_mb_qmax = atoi(arg);
2440
    if (video_mb_qmax < 0 ||
2441
        video_mb_qmax > 31) {
2442
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2443
        exit(1);
2444
    }
2445
}
2446

    
2447
static void opt_qdiff(const char *arg)
2448
{
2449
    video_qdiff = atoi(arg);
2450
    if (video_qdiff < 0 ||
2451
        video_qdiff > 31) {
2452
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2453
        exit(1);
2454
    }
2455
}
2456

    
2457
static void opt_qblur(const char *arg)
2458
{
2459
    video_qblur = atof(arg);
2460
}
2461

    
2462
static void opt_qcomp(const char *arg)
2463
{
2464
    video_qcomp = atof(arg);
2465
}
2466

    
2467
static void opt_rc_initial_cplx(const char *arg)
2468
{
2469
    video_rc_initial_cplx = atof(arg);
2470
}
2471
static void opt_b_qfactor(const char *arg)
2472
{
2473
    video_b_qfactor = atof(arg);
2474
}
2475
static void opt_i_qfactor(const char *arg)
2476
{
2477
    video_i_qfactor = atof(arg);
2478
}
2479
static void opt_b_qoffset(const char *arg)
2480
{
2481
    video_b_qoffset = atof(arg);
2482
}
2483
static void opt_i_qoffset(const char *arg)
2484
{
2485
    video_i_qoffset = atof(arg);
2486
}
2487

    
2488
static void opt_ibias(const char *arg)
2489
{
2490
    video_intra_quant_bias = atoi(arg);
2491
}
2492
static void opt_pbias(const char *arg)
2493
{
2494
    video_inter_quant_bias = atoi(arg);
2495
}
2496

    
2497
static void opt_packet_size(const char *arg)
2498
{
2499
    packet_size= atoi(arg);
2500
}
2501

    
2502
static void opt_error_rate(const char *arg)
2503
{
2504
    error_rate= atoi(arg);
2505
}
2506

    
2507
static void opt_strict(const char *arg)
2508
{
2509
    strict= atoi(arg);
2510
}
2511

    
2512
static void opt_top_field_first(const char *arg)
2513
{
2514
    top_field_first= atoi(arg);
2515
}
2516

    
2517
static void opt_noise_reduction(const char *arg)
2518
{
2519
    noise_reduction= atoi(arg);
2520
}
2521

    
2522
static void opt_qns(const char *arg)
2523
{
2524
    qns= atoi(arg);
2525
}
2526

    
2527
static void opt_sc_threshold(const char *arg)
2528
{
2529
    sc_threshold= atoi(arg);
2530
}
2531

    
2532
static void opt_me_range(const char *arg)
2533
{
2534
    me_range = atoi(arg);
2535
}
2536

    
2537
static void opt_thread_count(const char *arg)
2538
{
2539
    thread_count= atoi(arg);
2540
#if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2541
    if (verbose >= 0)
2542
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2543
#endif
2544
}
2545

    
2546
static void opt_audio_bitrate(const char *arg)
2547
{
2548
    audio_bit_rate = atoi(arg) * 1000;
2549
}
2550

    
2551
static void opt_audio_rate(const char *arg)
2552
{
2553
    audio_sample_rate = atoi(arg);
2554
}
2555

    
2556
static void opt_audio_channels(const char *arg)
2557
{
2558
    audio_channels = atoi(arg);
2559
}
2560

    
2561
static void opt_video_device(const char *arg)
2562
{
2563
    video_device = av_strdup(arg);
2564
}
2565

    
2566
static void opt_video_channel(const char *arg)
2567
{
2568
    video_channel = strtol(arg, NULL, 0);
2569
}
2570

    
2571
static void opt_video_standard(const char *arg)
2572
{
2573
    video_standard = av_strdup(arg);
2574
}
2575

    
2576
static void opt_audio_device(const char *arg)
2577
{
2578
    audio_device = av_strdup(arg);
2579
}
2580

    
2581
static void opt_dv1394(const char *arg)
2582
{
2583
    video_grab_format = "dv1394";
2584
    audio_grab_format = NULL;
2585
}
2586

    
2587
static void opt_audio_codec(const char *arg)
2588
{
2589
    AVCodec *p;
2590

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

    
2609
static void add_frame_hooker(const char *arg)
2610
{
2611
    int argc = 0;
2612
    char *argv[64];
2613
    int i;
2614
    char *args = av_strdup(arg);
2615

    
2616
    using_vhook = 1;
2617

    
2618
    argv[0] = strtok(args, " ");
2619
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2620
    }
2621

    
2622
    i = frame_hook_add(argc, argv);
2623

    
2624
    if (i != 0) {
2625
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2626
        exit(1);
2627
    }
2628
}
2629

    
2630
const char *motion_str[] = {
2631
    "zero",
2632
    "full",
2633
    "log",
2634
    "phods",
2635
    "epzs",
2636
    "x1",
2637
    NULL,
2638
};
2639

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

    
2656
static void opt_video_codec(const char *arg)
2657
{
2658
    AVCodec *p;
2659

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

    
2678
static void opt_map(const char *arg)
2679
{
2680
    AVStreamMap *m;
2681
    const char *p;
2682

    
2683
    p = arg;
2684
    m = &stream_maps[nb_stream_maps++];
2685

    
2686
    m->file_index = strtol(arg, (char **)&p, 0);
2687
    if (*p)
2688
        p++;
2689

    
2690
    m->stream_index = strtol(p, (char **)&p, 0);
2691
}
2692

    
2693
static void opt_map_meta_data(const char *arg)
2694
{
2695
    AVMetaDataMap *m;
2696
    const char *p;
2697
        
2698
    p = arg;
2699
    m = &meta_data_maps[nb_meta_data_maps++];
2700

    
2701
    m->out_file = strtol(arg, (char **)&p, 0);
2702
    if (*p)
2703
        p++;
2704

    
2705
    m->in_file = strtol(p, (char **)&p, 0);
2706
}
2707

    
2708
static void opt_recording_time(const char *arg)
2709
{
2710
    recording_time = parse_date(arg, 1);
2711
}
2712

    
2713
static void opt_start_time(const char *arg)
2714
{
2715
    start_time = parse_date(arg, 1);
2716
}
2717

    
2718
static void opt_rec_timestamp(const char *arg)
2719
{
2720
    rec_timestamp = parse_date(arg, 0) / 1000000;
2721
}
2722

    
2723
static void opt_input_ts_offset(const char *arg)
2724
{
2725
    input_ts_offset = parse_date(arg, 1);
2726
}
2727

    
2728
static void opt_input_file(const char *filename)
2729
{
2730
    AVFormatContext *ic;
2731
    AVFormatParameters params, *ap = &params;
2732
    int err, i, ret, rfps, rfps_base;
2733
    int64_t timestamp;
2734

    
2735
    if (!strcmp(filename, "-"))
2736
        filename = "pipe:";
2737

    
2738
    using_stdin |= !strcmp(filename, "pipe:" ) || 
2739
                   !strcmp( filename, "/dev/stdin" );
2740

    
2741
    /* get default parameters from command line */
2742
    memset(ap, 0, sizeof(*ap));
2743
    ap->sample_rate = audio_sample_rate;
2744
    ap->channels = audio_channels;
2745
    ap->frame_rate = frame_rate;
2746
    ap->frame_rate_base = frame_rate_base;
2747
    ap->width = frame_width + frame_padleft + frame_padright;
2748
    ap->height = frame_height + frame_padtop + frame_padbottom;
2749
    ap->image_format = image_format;
2750
    ap->pix_fmt = frame_pix_fmt;
2751

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

    
2767
    timestamp = start_time;
2768
    /* add the stream start time */
2769
    if (ic->start_time != AV_NOPTS_VALUE)
2770
        timestamp += ic->start_time;
2771

    
2772
    /* if seeking requested, we execute it */
2773
    if (start_time != 0) {
2774
        ret = av_seek_frame(ic, -1, timestamp);
2775
        if (ret < 0) {
2776
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
2777
                    filename, (double)timestamp / AV_TIME_BASE);
2778
        }
2779
        /* reset seek info */
2780
        start_time = 0;
2781
    }
2782

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

    
2816
            assert(enc->frame_rate_base == rfps_base); // should be true for now
2817
            if (enc->frame_rate != rfps) { 
2818

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

    
2823
                    (float)rfps / rfps_base);
2824
            }
2825
            /* update the current frame rate to match the stream frame rate */
2826
            frame_rate      = rfps;
2827
            frame_rate_base = rfps_base;
2828

    
2829
            enc->rate_emu = rate_emu;
2830
            break;
2831
        case CODEC_TYPE_DATA:
2832
            break;
2833
        default:
2834
            av_abort();
2835
        }
2836
    }
2837
    
2838
    input_files[nb_input_files] = ic;
2839
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2840
    /* dump the file content */
2841
    if (verbose >= 0)
2842
        dump_format(ic, nb_input_files, filename, 0);
2843

    
2844
    nb_input_files++;
2845
    file_iformat = NULL;
2846
    file_oformat = NULL;
2847
    image_format = NULL;
2848

    
2849
    rate_emu = 0;
2850
}
2851

    
2852
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2853
{
2854
    int has_video, has_audio, i, j;
2855
    AVFormatContext *ic;
2856

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

    
2881
static void opt_output_file(const char *filename)
2882
{
2883
    AVStream *st;
2884
    AVFormatContext *oc;
2885
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2886
    int codec_id;
2887
    AVFormatParameters params, *ap = &params;
2888

    
2889
    if (!strcmp(filename, "-"))
2890
        filename = "pipe:";
2891

    
2892
    oc = av_alloc_format_context();
2893

    
2894
    if (!file_oformat) {
2895
        file_oformat = guess_format(NULL, filename, NULL);
2896
        if (!file_oformat) {
2897
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2898
                    filename);
2899
            exit(1);
2900
        }
2901
    }
2902
    
2903
    oc->oformat = file_oformat;
2904

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

    
2917
        /* disable if no corresponding type found and at least one
2918
           input file */
2919
        if (nb_input_files > 0) {
2920
            check_audio_video_inputs(&input_has_video, &input_has_audio);
2921
            if (!input_has_video)
2922
                use_video = 0;
2923
            if (!input_has_audio)
2924
                use_audio = 0;
2925
        }
2926

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

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

    
2994
                if(codec && codec->pix_fmts){
2995
                    const enum PixelFormat *p= codec->pix_fmts;
2996
                    for(; *p!=-1; p++){
2997
                        if(*p == video_enc->pix_fmt)
2998
                            break;
2999
                    }
3000
                    if(*p == -1)
3001
                        video_enc->pix_fmt = codec->pix_fmts[0];
3002
                }
3003

    
3004
                if (!intra_only)
3005
                    video_enc->gop_size = gop_size;
3006
                else
3007
                    video_enc->gop_size = 0;
3008
                if (video_qscale || same_quality) {
3009
                    video_enc->flags |= CODEC_FLAG_QSCALE;
3010
                    st->quality = FF_QP2LAMBDA * video_qscale;
3011
                }
3012

    
3013
                if(intra_matrix)
3014
                    video_enc->intra_matrix = intra_matrix;
3015
                if(inter_matrix)
3016
                    video_enc->inter_matrix = inter_matrix;
3017

    
3018
                if(bitexact)
3019
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
3020

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

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

    
3161
                if(packet_size){
3162
                    video_enc->rtp_mode= 1;
3163
                    video_enc->rtp_payload_size= packet_size;
3164
                }
3165
            
3166
                if (do_psnr)
3167
                    video_enc->flags|= CODEC_FLAG_PSNR;
3168
            
3169
                video_enc->me_method = me_method;
3170

    
3171
                /* two pass mode */
3172
                if (do_pass) {
3173
                    if (do_pass == 1) {
3174
                        video_enc->flags |= CODEC_FLAG_PASS1;
3175
                    } else {
3176
                        video_enc->flags |= CODEC_FLAG_PASS2;
3177
                    }
3178
                }
3179
            }
3180
        }
3181
    
3182
        if (use_audio) {
3183
            AVCodecContext *audio_enc;
3184

    
3185
            st = av_new_stream(oc, nb_streams++);
3186
            if (!st) {
3187
                fprintf(stderr, "Could not alloc stream\n");
3188
                exit(1);
3189
            }
3190
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
3191
            if(thread_count>1)
3192
                avcodec_thread_init(&st->codec, thread_count);
3193
#endif
3194

    
3195
            audio_enc = &st->codec;
3196
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3197

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

    
3223
        oc->nb_streams = nb_streams;
3224

    
3225
        if (!nb_streams) {
3226
            fprintf(stderr, "No audio or video streams available\n");
3227
            exit(1);
3228
        }
3229

    
3230
        oc->timestamp = rec_timestamp;
3231
            
3232
        if (str_title)
3233
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3234
        if (str_author)
3235
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3236
        if (str_copyright)
3237
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3238
        if (str_comment)
3239
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3240
    }
3241

    
3242
    output_files[nb_output_files++] = oc;
3243

    
3244
    strcpy(oc->filename, filename);
3245

    
3246
    /* check filename in case of an image number is expected */
3247
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3248
        if (filename_number_test(oc->filename) < 0) {
3249
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3250
            exit(1);
3251
        }
3252
    }
3253

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

    
3285
    memset(ap, 0, sizeof(*ap));
3286
    ap->image_format = image_format;
3287
    if (av_set_parameters(oc, ap) < 0) {
3288
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3289
                oc->filename);
3290
        exit(1);
3291
    }
3292

    
3293
    /* reset some options */
3294
    file_oformat = NULL;
3295
    file_iformat = NULL;
3296
    image_format = NULL;
3297
    audio_disable = 0;
3298
    video_disable = 0;
3299
    audio_codec_id = CODEC_ID_NONE;
3300
    video_codec_id = CODEC_ID_NONE;
3301
    audio_stream_copy = 0;
3302
    video_stream_copy = 0;
3303
}
3304

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

    
3376
        if (verbose >= 0)
3377
            dump_format(ic, nb_input_files, "", 0);
3378

    
3379
        nb_input_files++;
3380
    }
3381
    if (has_audio && audio_grab_format) {
3382
        AVInputFormat *fmt1;
3383
        fmt1 = av_find_input_format(audio_grab_format);
3384
        ap->device = audio_device;
3385
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3386
            fprintf(stderr, "Could not find audio grab device\n");
3387
            exit(1);
3388
        }
3389
        input_files[nb_input_files] = ic;
3390

    
3391
        if (verbose >= 0)
3392
            dump_format(ic, nb_input_files, "", 0);
3393

    
3394
        nb_input_files++;
3395
    }
3396
}
3397

    
3398
/* same option as mencoder */
3399
static void opt_pass(const char *pass_str)
3400
{
3401
    int pass;
3402
    pass = atoi(pass_str);
3403
    if (pass != 1 && pass != 2) {
3404
        fprintf(stderr, "pass number can be only 1 or 2\n");
3405
        exit(1);
3406
    }
3407
    do_pass = pass;
3408
}
3409

    
3410
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3411
static int64_t getutime(void)
3412
{
3413
  return av_gettime();
3414
}
3415
#else
3416
static int64_t getutime(void)
3417
{
3418
    struct rusage rusage;
3419

    
3420
    getrusage(RUSAGE_SELF, &rusage);
3421
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3422
}
3423
#endif
3424

    
3425
extern int ffm_nopts;
3426

    
3427
static void opt_bitexact(void)
3428
{
3429
    bitexact=1;
3430
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3431
    ffm_nopts = 1;
3432
}
3433

    
3434
static void show_formats(void)
3435
{
3436
    AVInputFormat *ifmt;
3437
    AVOutputFormat *ofmt;
3438
    AVImageFormat *image_fmt;
3439
    URLProtocol *up;
3440
    AVCodec *p, *p2;
3441
    const char **pp, *last_name;
3442

    
3443
    printf("File formats:\n");
3444
    last_name= "000";
3445
    for(;;){
3446
        int decode=0;
3447
        int encode=0;
3448
        const char *name=NULL;
3449

    
3450
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3451
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3452
                strcmp(ofmt->name, last_name)>0){
3453
                name= ofmt->name;
3454
                encode=1;
3455
            }
3456
        }
3457
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3458
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3459
                strcmp(ifmt->name, last_name)>0){
3460
                name= ifmt->name;
3461
                encode=0;
3462
            }
3463
            if(name && strcmp(ifmt->name, name)==0)
3464
                decode=1;
3465
        }
3466
        if(name==NULL)
3467
            break;
3468
        last_name= name;
3469
        
3470
        printf(
3471
            " %s%s %s\n", 
3472
            decode ? "D":" ", 
3473
            encode ? "E":" ", 
3474
            name);
3475
    }
3476
    printf("\n");
3477

    
3478
    printf("Image formats:\n");
3479
    for(image_fmt = first_image_format; image_fmt != NULL; 
3480
        image_fmt = image_fmt->next) {
3481
        printf(
3482
            " %s%s %s\n",
3483
            image_fmt->img_read  ? "D":" ",
3484
            image_fmt->img_write ? "E":" ",
3485
            image_fmt->name);
3486
    }
3487
    printf("\n");
3488

    
3489
    printf("Codecs:\n");
3490
    last_name= "000";
3491
    for(;;){
3492
        int decode=0;
3493
        int encode=0;
3494
        int cap=0;
3495

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

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

    
3556
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3557
{
3558
    int i;
3559
    const char *p = str;
3560
    for(i = 0;; i++) {
3561
        dest[i] = atoi(p);
3562
        if(i == 63)
3563
            break;
3564
        p = strchr(p, ',');
3565
        if(!p) {
3566
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3567
            exit(1);
3568
        }
3569
        p++;
3570
    }
3571
}
3572

    
3573
void opt_inter_matrix(const char *arg)
3574
{
3575
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3576
    parse_matrix_coeffs(inter_matrix, arg);
3577
}
3578

    
3579
void opt_intra_matrix(const char *arg)
3580
{
3581
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3582
    parse_matrix_coeffs(intra_matrix, arg);
3583
}
3584

    
3585
static void opt_target(const char *arg)
3586
{
3587
    int norm = -1;
3588

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

    
3630
    if(norm < 0) {
3631
        fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3632
        fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3633
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3634
        exit(1);
3635
    }
3636

    
3637
    if(!strcmp(arg, "vcd")) {
3638

    
3639
        opt_video_codec("mpeg1video");
3640
        opt_audio_codec("mp2");
3641
        opt_format("vcd");
3642

    
3643
        opt_frame_size(norm ? "352x240" : "352x288");
3644

    
3645
        video_bit_rate = 1150000;
3646
        video_rc_max_rate = 1150000;
3647
        video_rc_min_rate = 1150000;
3648
        video_rc_buffer_size = 40*1024*8;
3649

    
3650
        audio_bit_rate = 224000;
3651
        audio_sample_rate = 44100;
3652

    
3653
    } else if(!strcmp(arg, "svcd")) {
3654

    
3655
        opt_video_codec("mpeg2video");
3656
        opt_audio_codec("mp2");
3657
        opt_format("svcd");
3658

    
3659
        opt_frame_size(norm ? "480x480" : "480x576");
3660
        opt_gop_size(norm ? "18" : "15");
3661

    
3662
        video_bit_rate = 2040000;
3663
        video_rc_max_rate = 2516000;
3664
        video_rc_min_rate = 0; //1145000;
3665
        video_rc_buffer_size = 224*1024*8;
3666
        use_scan_offset = 1;
3667

    
3668
        audio_bit_rate = 224000;
3669
        audio_sample_rate = 44100;
3670

    
3671
    } else if(!strcmp(arg, "dvd")) {
3672

    
3673
        opt_video_codec("mpeg2video");
3674
        opt_audio_codec("ac3");
3675
        opt_format("vob");
3676

    
3677
        opt_frame_size(norm ? "720x480" : "720x576");
3678
        opt_gop_size(norm ? "18" : "15");
3679

    
3680
        video_bit_rate = 6000000;
3681
        video_rc_max_rate = 9000000;
3682
        video_rc_min_rate = 0; //1500000;
3683
        video_rc_buffer_size = 224*1024*8;
3684

    
3685
        audio_bit_rate = 448000;
3686
        audio_sample_rate = 48000;
3687

    
3688
    } else {
3689
        fprintf(stderr, "Unknown target: %s\n", arg);
3690
        exit(1);
3691
    }
3692
}
3693

    
3694
static void show_version(void)
3695
{
3696
    printf("ffmpeg      " FFMPEG_VERSION "\n"
3697
           "libavcodec  %d\n"
3698
           "libavformat %d\n", 
3699
           avcodec_build(), LIBAVFORMAT_BUILD);
3700
    exit(1);
3701
}
3702

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

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

    
3855
    /* audio options */
3856
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3857
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3858
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3859
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3860
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3861

    
3862
    /* grab options */
3863
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3864
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3865
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3866
    { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3867
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3868
    { NULL, },
3869
};
3870

    
3871
static void show_banner(void)
3872
{
3873
    printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
3874
        LIBAVCODEC_BUILD);
3875
    printf("  built on " __DATE__ " " __TIME__);
3876
#ifdef __GNUC__
3877
    printf(", gcc: %s\n", __VERSION__);
3878
#else
3879
    printf(", using a non-gcc compiler\n");
3880
#endif
3881
}
3882

    
3883
static void show_license(void)
3884
{
3885
    show_banner();
3886
#ifdef CONFIG_GPL
3887
    printf(
3888
    "This program is free software; you can redistribute it and/or modify\n"   
3889
    "it under the terms of the GNU General Public License as published by\n"
3890
    "the Free Software Foundation; either version 2 of the License, or\n"
3891
    "(at your option) any later version.\n"
3892
    "\n"
3893
    "This program is distributed in the hope that it will be useful,\n"
3894
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3895
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3896
    "GNU General Public License for more details.\n"
3897
    "\n"
3898
    "You should have received a copy of the GNU General Public License\n"
3899
    "along with this program; if not, write to the Free Software\n"
3900
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3901
    );
3902
#else
3903
    printf(
3904
    "This library is free software; you can redistribute it and/or\n"
3905
    "modify it under the terms of the GNU Lesser General Public\n"
3906
    "License as published by the Free Software Foundation; either\n"
3907
    "version 2 of the License, or (at your option) any later version.\n"
3908
    "\n"
3909
    "This library is distributed in the hope that it will be useful,\n"
3910
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3911
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3912
    "Lesser General Public License for more details.\n"
3913
    "\n"
3914
    "You should have received a copy of the GNU Lesser General Public\n"
3915
    "License along with this library; if not, write to the Free Software\n"
3916
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3917
    );
3918
#endif
3919
    exit(1);
3920
}
3921

    
3922
static void show_help(void)
3923
{
3924
    show_banner();
3925
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3926
           "Hyper fast Audio and Video encoder\n");
3927
    printf("\n");
3928
    show_help_options(options, "Main options:\n",
3929
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3930
    show_help_options(options, "\nVideo options:\n",
3931
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3932
                      OPT_VIDEO);
3933
    show_help_options(options, "\nAdvanced Video options:\n",
3934
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3935
                      OPT_VIDEO | OPT_EXPERT);
3936
    show_help_options(options, "\nAudio options:\n",
3937
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3938
                      OPT_AUDIO);
3939
    show_help_options(options, "\nAdvanced Audio options:\n",
3940
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3941
                      OPT_AUDIO | OPT_EXPERT);
3942
    show_help_options(options, "\nAudio/Video grab options:\n",
3943
                      OPT_GRAB, 
3944
                      OPT_GRAB);
3945
    show_help_options(options, "\nAdvanced options:\n",
3946
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3947
                      OPT_EXPERT);
3948
    exit(1);
3949
}
3950

    
3951
void parse_arg_file(const char *filename)
3952
{
3953
    opt_output_file(filename);
3954
}
3955

    
3956
int main(int argc, char **argv)
3957
{
3958
    int i;
3959
    int64_t ti;
3960

    
3961
    av_register_all();
3962

    
3963
    if (argc <= 1)
3964
        show_help();
3965
    else
3966
        show_banner();
3967
    
3968
    /* parse options */
3969
    parse_options(argc, argv, options);
3970

    
3971
    /* file converter / grab */
3972
    if (nb_output_files <= 0) {
3973
        fprintf(stderr, "Must supply at least one output file\n");
3974
        exit(1);
3975
    }
3976
    
3977
    if (nb_input_files == 0) {
3978
        input_sync = 1;
3979
        prepare_grab();
3980
    }
3981

    
3982
    ti = getutime();
3983
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
3984
              stream_maps, nb_stream_maps);
3985
    ti = getutime() - ti;
3986
    if (do_benchmark) {
3987
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3988
    }
3989

    
3990
    /* close files */
3991
    for(i=0;i<nb_output_files;i++) {
3992
        /* maybe av_close_output_file ??? */
3993
        AVFormatContext *s = output_files[i];
3994
        int j;
3995
        if (!(s->oformat->flags & AVFMT_NOFILE))
3996
            url_fclose(&s->pb);
3997
        for(j=0;j<s->nb_streams;j++)
3998
            av_free(s->streams[j]);
3999
        av_free(s);
4000
    }
4001
    for(i=0;i<nb_input_files;i++)
4002
        av_close_input_file(input_files[i]);
4003

    
4004
    av_free_static();
4005

    
4006
    if(intra_matrix)
4007
        av_free(intra_matrix);
4008
    if(inter_matrix)
4009
        av_free(inter_matrix);
4010
    
4011
#ifdef POWERPC_PERFORMANCE_REPORT
4012
    extern void powerpc_display_perf_report(void);
4013
    powerpc_display_perf_report();
4014
#endif /* POWERPC_PERFORMANCE_REPORT */
4015

    
4016
#ifndef CONFIG_WIN32
4017
    if (received_sigterm) {
4018
        fprintf(stderr,
4019
            "Received signal %d: terminating.\n",
4020
            (int) received_sigterm);
4021
        exit (255);
4022
    }
4023
#endif
4024
    exit(0); /* not all OS-es handle main() return value */
4025
    return 0;
4026
}