Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ ff4905a5

History | View | Annotate | Download (134 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

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

    
41
#include "cmdutils.h"
42

    
43
#if !defined(INFINITY) && defined(HUGE_VAL)
44
#define INFINITY HUGE_VAL
45
#endif
46

    
47
/* select an input stream for an output stream */
48
typedef struct AVStreamMap {
49
    int file_index;
50
    int stream_index;
51
} AVStreamMap;
52

    
53
extern const OptionDef options[];
54

    
55
static void show_help(void);
56
static void show_license(void);
57

    
58
#define MAX_FILES 20
59

    
60
static AVFormatContext *input_files[MAX_FILES];
61
static int64_t input_files_ts_offset[MAX_FILES];
62
static int nb_input_files = 0;
63

    
64
static AVFormatContext *output_files[MAX_FILES];
65
static int nb_output_files = 0;
66

    
67
static AVStreamMap stream_maps[MAX_FILES];
68
static int nb_stream_maps;
69

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

    
177
static int gop_size = 12;
178
static int intra_only = 0;
179
static int audio_sample_rate = 44100;
180
static int audio_bit_rate = 64000;
181
static int audio_disable = 0;
182
static int audio_channels = 1;
183
static int audio_codec_id = CODEC_ID_NONE;
184

    
185
static int64_t recording_time = 0;
186
static int64_t start_time = 0;
187
static int64_t rec_timestamp = 0;
188
static int64_t input_ts_offset = 0;
189
static int file_overwrite = 0;
190
static char *str_title = NULL;
191
static char *str_author = NULL;
192
static char *str_copyright = NULL;
193
static char *str_comment = NULL;
194
static int do_benchmark = 0;
195
static int do_hex_dump = 0;
196
static int do_pkt_dump = 0;
197
static int do_psnr = 0;
198
static int do_vstats = 0;
199
static int do_pass = 0;
200
static int bitexact = 0;
201
static char *pass_logfilename = NULL;
202
static int audio_stream_copy = 0;
203
static int video_stream_copy = 0;
204
static int video_sync_method= 1;
205
static int audio_sync_method= 0;
206
static int copy_ts= 0;
207

    
208
static int rate_emu = 0;
209

    
210
static char *video_grab_format = "video4linux";
211
static char *video_device = NULL;
212
static int  video_channel = 0;
213
static char *video_standard = "ntsc";
214

    
215
static char *audio_grab_format = "audio_device";
216
static char *audio_device = NULL;
217

    
218
static int using_stdin = 0;
219
static int using_vhook = 0;
220
static int verbose = 1;
221
static int thread_count= 1;
222
static int q_pressed = 0;
223
static int me_range = 0;
224
static int64_t video_size = 0;
225
static int64_t audio_size = 0;
226
static int64_t extra_size = 0;
227
static int nb_frames_dup = 0;
228
static int nb_frames_drop = 0;
229
static int input_sync;
230

    
231
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
232

    
233
typedef struct AVOutputStream {
234
    int file_index;          /* file index */
235
    int index;               /* stream index in the output file */
236
    int source_index;        /* AVInputStream index */
237
    AVStream *st;            /* stream in the output file */
238
    int encoding_needed;     /* true if encoding needed for this stream */
239
    int frame_number;
240
    /* input pts and corresponding output pts
241
       for A/V sync */
242
    double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
243
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
244
    /* video only */
245
    int video_resample;      /* video_resample and video_crop are mutually exclusive */
246
    AVFrame pict_tmp;      /* temporary image for resampling */
247
    ImgReSampleContext *img_resample_ctx; /* for image resampling */
248

    
249
    int video_crop;          /* video_resample and video_crop are mutually exclusive */
250
    int topBand;             /* cropping area sizes */
251
    int leftBand;
252
    
253
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
254
    int padtop;              /* padding area sizes */
255
    int padbottom;
256
    int padleft;
257
    int padright;
258
    
259
    /* audio only */
260
    int audio_resample;
261
    ReSampleContext *resample; /* for audio resampling */
262
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
263
    FILE *logfile;
264
} AVOutputStream;
265

    
266
typedef struct AVInputStream {
267
    int file_index;
268
    int index;
269
    AVStream *st;
270
    int discard;             /* true if stream data should be discarded */
271
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
272
    int64_t sample_index;      /* current sample */
273

    
274
    int64_t       start;     /* time when read started */
275
    unsigned long frame;     /* current frame */
276
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
277
                                is not defined */
278
    int64_t       pts;       /* current pts */
279
    int is_start;            /* is 1 at the start and after a discontinuity */
280
} AVInputStream;
281

    
282
typedef struct AVInputFile {
283
    int eof_reached;      /* true if eof reached */
284
    int ist_index;        /* index of first stream in ist_table */
285
    int buffer_size;      /* current total buffer size */
286
    int buffer_size_max;  /* buffer size at which we consider we can stop
287
                             buffering */
288
    int nb_streams;       /* nb streams we are aware of */
289
} AVInputFile;
290

    
291
#ifndef CONFIG_WIN32
292

    
293
/* init terminal so that we can grab keys */
294
static struct termios oldtty;
295

    
296
static void term_exit(void)
297
{
298
    tcsetattr (0, TCSANOW, &oldtty);
299
}
300

    
301
static volatile sig_atomic_t received_sigterm = 0;
302

    
303
static void
304
sigterm_handler(int sig)
305
{
306
    received_sigterm = sig;
307
    term_exit();
308
}
309

    
310
static void term_init(void)
311
{
312
    struct termios tty;
313

    
314
    tcgetattr (0, &tty);
315
    oldtty = tty;
316

    
317
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
318
                          |INLCR|IGNCR|ICRNL|IXON);
319
    tty.c_oflag |= OPOST;
320
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
321
    tty.c_cflag &= ~(CSIZE|PARENB);
322
    tty.c_cflag |= CS8;
323
    tty.c_cc[VMIN] = 1;
324
    tty.c_cc[VTIME] = 0;
325
    
326
    tcsetattr (0, TCSANOW, &tty);
327

    
328
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
329
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
330
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
331
    /*
332
    register a function to be called at normal program termination
333
    */
334
    atexit(term_exit);
335
#ifdef CONFIG_BEOS_NETSERVER
336
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
337
#endif
338
}
339

    
340
/* read a key without blocking */
341
static int read_key(void)
342
{
343
    int n = 1;
344
    unsigned char ch;
345
#ifndef CONFIG_BEOS_NETSERVER
346
    struct timeval tv;
347
    fd_set rfds;
348

    
349
    FD_ZERO(&rfds);
350
    FD_SET(0, &rfds);
351
    tv.tv_sec = 0;
352
    tv.tv_usec = 0;
353
    n = select(1, &rfds, NULL, NULL, &tv);
354
#endif
355
    if (n > 0) {
356
        n = read(0, &ch, 1);
357
        if (n == 1)
358
            return ch;
359

    
360
        return n;
361
    }
362
    return -1;
363
}
364

    
365
static int decode_interrupt_cb(void)
366
{
367
    return q_pressed || (q_pressed = read_key() == 'q');
368
}
369

    
370
#else
371

    
372
static volatile int received_sigterm = 0;
373

    
374
/* no interactive support */
375
static void term_exit(void)
376
{
377
}
378

    
379
static void term_init(void)
380
{
381
}
382

    
383
static int read_key(void)
384
{
385
    return 0;
386
}
387

    
388
#endif
389

    
390
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
391
{
392
    int i, err;
393
    AVFormatContext *ic;
394

    
395
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
396
    if (err < 0)
397
        return err;
398
    /* copy stream format */
399
    s->nb_streams = ic->nb_streams;
400
    for(i=0;i<ic->nb_streams;i++) {
401
        AVStream *st;
402

    
403
        st = av_mallocz(sizeof(AVStream));
404
        memcpy(st, ic->streams[i], sizeof(AVStream));
405
        s->streams[i] = st;
406
    }
407

    
408
    av_close_input_file(ic);
409
    return 0;
410
}
411

    
412
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
413

    
414
static void do_audio_out(AVFormatContext *s, 
415
                         AVOutputStream *ost, 
416
                         AVInputStream *ist,
417
                         unsigned char *buf, int size)
418
{
419
    uint8_t *buftmp;
420
    static uint8_t *audio_buf = NULL;
421
    static uint8_t *audio_out = NULL;
422
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
423

    
424
    int size_out, frame_bytes, ret;
425
    AVCodecContext *enc= &ost->st->codec;
426

    
427
    /* SC: dynamic allocation of buffers */
428
    if (!audio_buf)
429
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
430
    if (!audio_out)
431
        audio_out = av_malloc(audio_out_size);
432
    if (!audio_buf || !audio_out)
433
        return;               /* Should signal an error ! */
434

    
435
    if(audio_sync_method){
436
        double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts 
437
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
438
        double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
439
        int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
440

    
441
        //FIXME resample delay
442
        if(fabs(delta) > 50){
443
            if(ist->is_start){
444
                if(byte_delta < 0){
445
                    byte_delta= FFMIN(byte_delta, size);
446
                    size += byte_delta;
447
                    buf  -= byte_delta;
448
                    if(verbose > 2)
449
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
450
                    if(!size)
451
                        return;
452
                    ist->is_start=0;
453
                }else{
454
                    static uint8_t *input_tmp= NULL;
455
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
456

    
457
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
458
                        ist->is_start=0;
459
                    else
460
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
461

    
462
                    memset(input_tmp, 0, byte_delta);
463
                    memcpy(input_tmp + byte_delta, buf, size);
464
                    buf= input_tmp;
465
                    size += byte_delta;
466
                    if(verbose > 2)
467
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
468
                }
469
            }else if(audio_sync_method>1){
470
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
471
                assert(ost->audio_resample);
472
                if(verbose > 2)
473
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
474
                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));
475
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
476
            }
477
        } 
478
    }else
479
        ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
480
                        - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
481

    
482
    if (ost->audio_resample) {
483
        buftmp = audio_buf;
484
        size_out = audio_resample(ost->resample, 
485
                                  (short *)buftmp, (short *)buf,
486
                                  size / (ist->st->codec.channels * 2));
487
        size_out = size_out * enc->channels * 2;
488
    } else {
489
        buftmp = buf;
490
        size_out = size;
491
    }
492

    
493
    /* now encode as many frames as possible */
494
    if (enc->frame_size > 1) {
495
        /* output resampled raw samples */
496
        fifo_write(&ost->fifo, buftmp, size_out, 
497
                   &ost->fifo.wptr);
498

    
499
        frame_bytes = enc->frame_size * 2 * enc->channels;
500
        
501
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
502
                     &ost->fifo.rptr) == 0) {
503
            AVPacket pkt;
504
            av_init_packet(&pkt);
505

    
506
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
507
                                       (short *)audio_buf);
508
            audio_size += ret;
509
            pkt.stream_index= ost->index;
510
            pkt.data= audio_out;
511
            pkt.size= ret;
512
            if(enc->coded_frame)
513
                pkt.pts= enc->coded_frame->pts;
514
            pkt.flags |= PKT_FLAG_KEY;
515
            av_interleaved_write_frame(s, &pkt);
516
            
517
            ost->sync_opts += enc->frame_size;
518
        }
519
    } else {
520
        AVPacket pkt;
521
        av_init_packet(&pkt);
522

    
523
        ost->sync_opts += size_out / enc->channels;
524

    
525
        /* output a pcm frame */
526
        /* XXX: change encoding codec API to avoid this ? */
527
        switch(enc->codec->id) {
528
        case CODEC_ID_PCM_S16LE:
529
        case CODEC_ID_PCM_S16BE:
530
        case CODEC_ID_PCM_U16LE:
531
        case CODEC_ID_PCM_U16BE:
532
            break;
533
        default:
534
            size_out = size_out >> 1;
535
            break;
536
        }
537
        ret = avcodec_encode_audio(enc, audio_out, size_out, 
538
                                   (short *)buftmp);
539
        audio_size += ret;
540
        pkt.stream_index= ost->index;
541
        pkt.data= audio_out;
542
        pkt.size= ret;
543
        if(enc->coded_frame)
544
            pkt.pts= enc->coded_frame->pts;
545
        pkt.flags |= PKT_FLAG_KEY;
546
        av_interleaved_write_frame(s, &pkt);
547
    }
548
}
549

    
550
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
551
{
552
    AVCodecContext *dec;
553
    AVPicture *picture2;
554
    AVPicture picture_tmp;
555
    uint8_t *buf = 0;
556

    
557
    dec = &ist->st->codec;
558

    
559
    /* deinterlace : must be done before any resize */
560
    if (do_deinterlace || using_vhook) {
561
        int size;
562

    
563
        /* create temporary picture */
564
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
565
        buf = av_malloc(size);
566
        if (!buf)
567
            return;
568
        
569
        picture2 = &picture_tmp;
570
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
571

    
572
        if (do_deinterlace){
573
            if(avpicture_deinterlace(picture2, picture, 
574
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
575
                /* if error, do not deinterlace */
576
                av_free(buf);
577
                buf = NULL;
578
                picture2 = picture;
579
            }
580
        } else {
581
            if (img_convert(picture2, dec->pix_fmt, picture, 
582
                            dec->pix_fmt, dec->width, dec->height) < 0) {
583
                /* if error, do not copy */
584
                av_free(buf);
585
                buf = NULL;
586
                picture2 = picture;
587
            }
588
        }
589
    } else {
590
        picture2 = picture;
591
    }
592

    
593
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
594

    
595
    if (picture != picture2)
596
        *picture = *picture2;
597
    *bufp = buf;
598
}
599

    
600
/* we begin to correct av delay at this threshold */
601
#define AV_DELAY_MAX 0.100
602

    
603

    
604
/* Expects img to be yuv420 */
605
static void fill_pad_region(AVPicture* img, int height, int width,
606
        int padtop, int padbottom, int padleft, int padright, int *color) {
607
  
608
    int i, y, shift;
609
    uint8_t *optr;
610
    
611
    for (i = 0; i < 3; i++) {
612
        shift = (i == 0) ? 0 : 1;
613
        
614
        if (padtop || padleft) {
615
            memset(img->data[i], color[i], (((img->linesize[i] * padtop) + 
616
                            padleft) >> shift));
617
        }
618

    
619
        if (padleft || padright) {
620
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
621
                (img->linesize[i] - (padright >> shift));
622

    
623
            for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
624
                memset(optr, color[i], (padleft + padright) >> shift);
625
                optr += img->linesize[i];
626
            }
627
        }
628
      
629
        if (padbottom) {
630
            optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
631
            memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
632
        }
633
    }
634
}
635

    
636
static uint8_t *bit_buffer= NULL;
637

    
638
static void do_video_out(AVFormatContext *s, 
639
                         AVOutputStream *ost, 
640
                         AVInputStream *ist,
641
                         AVFrame *in_picture,
642
                         int *frame_size)
643
{
644
    int nb_frames, i, ret;
645
    AVFrame *final_picture, *formatted_picture;
646
    AVFrame picture_format_temp, picture_crop_temp;
647
    uint8_t *buf = NULL, *buf1 = NULL;
648
    AVCodecContext *enc, *dec;
649
    enum PixelFormat target_pixfmt;
650
    
651
#define VIDEO_BUFFER_SIZE (1024*1024)
652

    
653
    avcodec_get_frame_defaults(&picture_format_temp);
654
    avcodec_get_frame_defaults(&picture_crop_temp);
655

    
656
    enc = &ost->st->codec;
657
    dec = &ist->st->codec;
658

    
659
    /* by default, we output a single frame */
660
    nb_frames = 1;
661

    
662
    *frame_size = 0;
663

    
664
    if(video_sync_method){
665
        double vdelta;
666
        vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
667
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
668
        if (vdelta < -1.1)
669
            nb_frames = 0;
670
        else if (vdelta > 1.1)
671
            nb_frames = 2;
672
//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);
673
        if (nb_frames == 0){
674
            ++nb_frames_drop;
675
            if (verbose>2)
676
                fprintf(stderr, "*** drop!\n");
677
        }else if (nb_frames == 2) {
678
            ++nb_frames_dup;
679
            if (verbose>2)
680
                fprintf(stderr, "*** dup!\n");
681
        }
682
    }else
683
        ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
684

    
685
    if (nb_frames <= 0) 
686
        return;
687

    
688
    /* convert pixel format if needed */
689
    target_pixfmt = ost->video_resample || ost->video_pad
690
        ? PIX_FMT_YUV420P : enc->pix_fmt;
691
    if (dec->pix_fmt != target_pixfmt) {
692
        int size;
693

    
694
        /* create temporary picture */
695
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
696
        buf = av_malloc(size);
697
        if (!buf)
698
            return;
699
        formatted_picture = &picture_format_temp;
700
        avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
701
        
702
        if (img_convert((AVPicture*)formatted_picture, target_pixfmt, 
703
                        (AVPicture *)in_picture, dec->pix_fmt, 
704
                        dec->width, dec->height) < 0) {
705

    
706
            if (verbose >= 0)
707
                fprintf(stderr, "pixel format conversion not handled\n");
708

    
709
            goto the_end;
710
        }
711
    } else {
712
        formatted_picture = in_picture;
713
    }
714

    
715
    /* XXX: resampling could be done before raw format conversion in
716
       some cases to go faster */
717
    /* XXX: only works for YUV420P */
718
    if (ost->video_resample) {
719
        final_picture = &ost->pict_tmp;
720
        img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
721
       
722
        if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
723
            fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
724
                    ost->padtop, ost->padbottom, ost->padleft, ost->padright,
725
                    padcolor);
726
        }
727
        
728
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
729
            int size;
730
            
731
            av_free(buf);
732
            /* create temporary picture */
733
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
734
            buf = av_malloc(size);
735
            if (!buf)
736
                return;
737
            final_picture = &picture_format_temp;
738
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
739
        
740
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
741
                            (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
742
                            enc->width, enc->height) < 0) {
743

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

    
747
                goto the_end;
748
            }
749
        }
750
    } else if (ost->video_crop) {
751
        picture_crop_temp.data[0] = formatted_picture->data[0] +
752
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
753

    
754
        picture_crop_temp.data[1] = formatted_picture->data[1] +
755
                ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
756
                (ost->leftBand >> 1);
757

    
758
        picture_crop_temp.data[2] = formatted_picture->data[2] +
759
                ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
760
                (ost->leftBand >> 1);
761

    
762
        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
763
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
764
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
765
        final_picture = &picture_crop_temp;
766
    } else if (ost->video_pad) {
767
        final_picture = &ost->pict_tmp;
768

    
769
        for (i = 0; i < 3; i++) {
770
            uint8_t *optr, *iptr;
771
            int shift = (i == 0) ? 0 : 1;
772
            int y, yheight;
773
            
774
            /* set offset to start writing image into */
775
            optr = final_picture->data[i] + (((final_picture->linesize[i] * 
776
                            ost->padtop) + ost->padleft) >> shift);
777
            iptr = formatted_picture->data[i];
778

    
779
            yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
780
            for (y = 0; y < yheight; y++) {
781
                /* copy unpadded image row into padded image row */
782
                memcpy(optr, iptr, formatted_picture->linesize[i]);
783
                optr += final_picture->linesize[i];
784
                iptr += formatted_picture->linesize[i];
785
            }
786
        }
787

    
788
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
789
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
790
                padcolor);
791
        
792
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
793
            int size;
794

    
795
            av_free(buf);
796
            /* create temporary picture */
797
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
798
            buf = av_malloc(size);
799
            if (!buf)
800
                return;
801
            final_picture = &picture_format_temp;
802
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
803

    
804
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
805
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
806
                        enc->width, enc->height) < 0) {
807

    
808
                if (verbose >= 0)
809
                    fprintf(stderr, "pixel format conversion not handled\n");
810

    
811
                goto the_end;
812
            }
813
        }
814
    } else {
815
        final_picture = formatted_picture;
816
    }
817
    /* duplicates frame if needed */
818
    /* XXX: pb because no interleaving */
819
    for(i=0;i<nb_frames;i++) {
820
        AVPacket pkt;
821
        av_init_packet(&pkt);
822
        pkt.stream_index= ost->index;
823

    
824
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
825
            /* raw pictures are written as AVPicture structure to
826
               avoid any copies. We support temorarily the older
827
               method. */
828
            AVFrame* old_frame = enc->coded_frame;
829
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
830
            pkt.data= (uint8_t *)final_picture;
831
            pkt.size=  sizeof(AVPicture);
832
            if(dec->coded_frame)
833
                pkt.pts= dec->coded_frame->pts;
834
            if(dec->coded_frame && dec->coded_frame->key_frame)
835
                pkt.flags |= PKT_FLAG_KEY;
836

    
837
            av_interleaved_write_frame(s, &pkt);
838
            enc->coded_frame = old_frame;
839
        } else {
840
            AVFrame big_picture;
841

    
842
            big_picture= *final_picture;
843
            /* better than nothing: use input picture interlaced
844
               settings */
845
            big_picture.interlaced_frame = in_picture->interlaced_frame;
846
            if(do_interlace_me || do_interlace_dct){
847
                if(top_field_first == -1)
848
                    big_picture.top_field_first = in_picture->top_field_first;
849
                else
850
                    big_picture.top_field_first = top_field_first;
851
            }
852

    
853
            /* handles sameq here. This is not correct because it may
854
               not be a global option */
855
            if (same_quality) {
856
                big_picture.quality = ist->st->quality;
857
            }else
858
                big_picture.quality = ost->st->quality;
859
            if(!me_threshold)
860
                big_picture.pict_type = 0;
861
//            big_picture.pts = AV_NOPTS_VALUE;
862
            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
863
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
864
            ret = avcodec_encode_video(enc, 
865
                                       bit_buffer, VIDEO_BUFFER_SIZE,
866
                                       &big_picture);
867
            //enc->frame_number = enc->real_pict_num;
868
            if(ret){
869
                pkt.data= bit_buffer;
870
                pkt.size= ret;
871
                if(enc->coded_frame)
872
                    pkt.pts= enc->coded_frame->pts;
873
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n", 
874
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
875
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
876

    
877
                if(enc->coded_frame && enc->coded_frame->key_frame)
878
                    pkt.flags |= PKT_FLAG_KEY;
879
                av_interleaved_write_frame(s, &pkt);
880
                *frame_size = ret;
881
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
882
                //        enc->frame_number-1, enc->real_pict_num, ret,
883
                //        enc->pict_type);
884
                /* if two pass, output log */
885
                if (ost->logfile && enc->stats_out) {
886
                    fprintf(ost->logfile, "%s", enc->stats_out);
887
                }
888
            }
889
        }
890
        ost->sync_opts++;
891
        ost->frame_number++;
892
    }
893
 the_end:
894
    av_free(buf);
895
    av_free(buf1);
896
}
897

    
898
static double psnr(double d){
899
    if(d==0) return INFINITY;
900
    return -10.0*log(d)/log(10.0);
901
}
902

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

    
950
static void print_report(AVFormatContext **output_files,
951
                         AVOutputStream **ost_table, int nb_ostreams,
952
                         int is_last_report)
953
{
954
    char buf[1024];
955
    AVOutputStream *ost;
956
    AVFormatContext *oc, *os;
957
    int64_t total_size;
958
    AVCodecContext *enc;
959
    int frame_number, vid, i;
960
    double bitrate, ti1, pts;
961
    static int64_t last_time = -1;
962
    
963
    if (!is_last_report) {
964
        int64_t cur_time;
965
        /* display the report every 0.5 seconds */
966
        cur_time = av_gettime();
967
        if (last_time == -1) {
968
            last_time = cur_time;
969
            return;
970
        } 
971
        if ((cur_time - last_time) < 500000)
972
            return;
973
        last_time = cur_time;
974
    }
975

    
976

    
977
    oc = output_files[0];
978

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

    
1036
        if (verbose > 1)
1037
          sprintf(buf + strlen(buf), " dup=%d drop=%d",
1038
                  nb_frames_dup, nb_frames_drop);
1039
        
1040
        if (verbose >= 0)
1041
            fprintf(stderr, "%s    \r", buf);
1042

    
1043
        fflush(stderr);
1044
    }
1045
        
1046
    if (is_last_report && verbose >= 0){
1047
        int64_t raw= audio_size + video_size + extra_size;
1048
        fprintf(stderr, "\n");
1049
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1050
                video_size/1024.0,
1051
                audio_size/1024.0,
1052
                extra_size/1024.0,
1053
                100.0*(total_size - raw)/raw
1054
        );
1055
    }
1056
}
1057

    
1058
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1059
static int output_packet(AVInputStream *ist, int ist_index,
1060
                         AVOutputStream **ost_table, int nb_ostreams,
1061
                         const AVPacket *pkt)
1062
{
1063
    AVFormatContext *os;
1064
    AVOutputStream *ost;
1065
    uint8_t *ptr;
1066
    int len, ret, i;
1067
    uint8_t *data_buf;
1068
    int data_size, got_picture;
1069
    AVFrame picture;
1070
    short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
1071
    void *buffer_to_free;
1072

    
1073
    if (pkt && pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1074
        ist->next_pts = ist->pts = pkt->dts;
1075
    } else {
1076
        assert(ist->pts == ist->next_pts);
1077
    }
1078

    
1079
    if (pkt == NULL) {
1080
        /* EOF handling */
1081
        ptr = NULL;
1082
        len = 0;
1083
        goto handle_eof;
1084
    }
1085

    
1086
    len = pkt->size;
1087
    ptr = pkt->data;
1088
    while (len > 0) {
1089
    handle_eof:
1090
        /* decode the packet if needed */
1091
        data_buf = NULL; /* fail safe */
1092
        data_size = 0;
1093
        if (ist->decoding_needed) {
1094
            switch(ist->st->codec.codec_type) {
1095
            case CODEC_TYPE_AUDIO:
1096
                    /* XXX: could avoid copy if PCM 16 bits with same
1097
                       endianness as CPU */
1098
                ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1099
                                           ptr, len);
1100
                if (ret < 0)
1101
                    goto fail_decode;
1102
                ptr += ret;
1103
                len -= ret;
1104
                /* Some bug in mpeg audio decoder gives */
1105
                /* data_size < 0, it seems they are overflows */
1106
                if (data_size <= 0) {
1107
                    /* no audio frame */
1108
                    continue;
1109
                }
1110
                data_buf = (uint8_t *)samples;
1111
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) / 
1112
                    (ist->st->codec.sample_rate * ist->st->codec.channels);
1113
                break;
1114
            case CODEC_TYPE_VIDEO:
1115
                    data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1116
                    /* XXX: allocate picture correctly */
1117
                    avcodec_get_frame_defaults(&picture);
1118

    
1119
                    ret = avcodec_decode_video(&ist->st->codec, 
1120
                                               &picture, &got_picture, ptr, len);
1121
                    ist->st->quality= picture.quality;
1122
                    if (ret < 0) 
1123
                        goto fail_decode;
1124
                    if (!got_picture) {
1125
                        /* no picture yet */
1126
                        goto discard_packet;
1127
                    }
1128
                    if (ist->st->codec.frame_rate_base != 0) {
1129
                        ist->next_pts += ((int64_t)AV_TIME_BASE * 
1130
                                          ist->st->codec.frame_rate_base) /
1131
                            ist->st->codec.frame_rate;
1132
                    }
1133
                    len = 0;
1134
                    break;
1135
                default:
1136
                    goto fail_decode;
1137
                }
1138
            } else {
1139
                data_buf = ptr;
1140
                data_size = len;
1141
                ret = len;
1142
                len = 0;
1143
            }
1144

    
1145
            buffer_to_free = NULL;
1146
            if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1147
                pre_process_video_frame(ist, (AVPicture *)&picture, 
1148
                                        &buffer_to_free);
1149
            }
1150

    
1151
            /* frame rate emulation */
1152
            if (ist->st->codec.rate_emu) {
1153
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1154
                int64_t now = av_gettime() - ist->start;
1155
                if (pts > now)
1156
                    usleep(pts - now);
1157

    
1158
                ist->frame++;
1159
            }
1160

    
1161
#if 0
1162
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1163
               is the one of the next displayed one */
1164
            /* XXX: add mpeg4 too ? */
1165
            if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1166
                if (ist->st->codec.pict_type != B_TYPE) {
1167
                    int64_t tmp;
1168
                    tmp = ist->last_ip_pts;
1169
                    ist->last_ip_pts  = ist->frac_pts.val;
1170
                    ist->frac_pts.val = tmp;
1171
                }
1172
            }
1173
#endif
1174
            /* if output time reached then transcode raw format, 
1175
               encode packets and output them */
1176
            if (start_time == 0 || ist->pts >= start_time)
1177
                for(i=0;i<nb_ostreams;i++) {
1178
                    int frame_size;
1179

    
1180
                    ost = ost_table[i];
1181
                    if (ost->source_index == ist_index) {
1182
                        os = output_files[ost->file_index];
1183

    
1184
#if 0
1185
                        printf("%d: got pts=%0.3f %0.3f\n", i, 
1186
                               (double)pkt->pts / AV_TIME_BASE, 
1187
                               ((double)ist->pts / AV_TIME_BASE) - 
1188
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1189
#endif
1190
                        /* set the input output pts pairs */
1191
                        ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1192

    
1193
                        if (ost->encoding_needed) {
1194
                            switch(ost->st->codec.codec_type) {
1195
                            case CODEC_TYPE_AUDIO:
1196
                                do_audio_out(os, ost, ist, data_buf, data_size);
1197
                                break;
1198
                            case CODEC_TYPE_VIDEO:
1199
                                /* find an audio stream for synchro */
1200
                                {
1201
                                    int i;
1202
                                    AVOutputStream *audio_sync, *ost1;
1203
                                    audio_sync = NULL;
1204
                                    for(i=0;i<nb_ostreams;i++) {
1205
                                        ost1 = ost_table[i];
1206
                                        if (ost1->file_index == ost->file_index &&
1207
                                            ost1->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1208
                                            audio_sync = ost1;
1209
                                            break;
1210
                                        }
1211
                                    }
1212

    
1213
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1214
                                    video_size += frame_size;
1215
                                    if (do_vstats && frame_size)
1216
                                        do_video_stats(os, ost, frame_size);
1217
                                }
1218
                                break;
1219
                            default:
1220
                                av_abort();
1221
                            }
1222
                        } else {
1223
                            AVFrame avframe; //FIXME/XXX remove this
1224
                            AVPacket opkt;
1225
                            av_init_packet(&opkt);
1226

    
1227
                            /* no reencoding needed : output the packet directly */
1228
                            /* force the input stream PTS */
1229
                        
1230
                            avcodec_get_frame_defaults(&avframe);
1231
                            ost->st->codec.coded_frame= &avframe;
1232
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1233

    
1234
                            if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1235
                                audio_size += data_size;
1236
                            else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1237
                                video_size += data_size;
1238

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

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

    
1312

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

    
1331
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1332
    if (!file_table)
1333
        goto fail;
1334

    
1335
    if (!bit_buffer)
1336
        bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
1337
    if (!bit_buffer)
1338
        goto fail;
1339
        
1340
    /* input stream init */
1341
    j = 0;
1342
    for(i=0;i<nb_input_files;i++) {
1343
        is = input_files[i];
1344
        file_table[i].ist_index = j;
1345
        file_table[i].nb_streams = is->nb_streams;
1346
        j += is->nb_streams;
1347
    }
1348
    nb_istreams = j;
1349

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

    
1371
            if (ist->st->codec.rate_emu) {
1372
                ist->start = av_gettime();
1373
                ist->frame = 0;
1374
            }
1375
        }
1376
    }
1377

    
1378
    /* output stream init */
1379
    nb_ostreams = 0;
1380
    for(i=0;i<nb_output_files;i++) {
1381
        os = output_files[i];
1382
        nb_ostreams += os->nb_streams;
1383
    }
1384
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1385
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1386
        exit(1);
1387
    }
1388

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

    
1465
    /* for each output stream, we compute the right encoding parameters */
1466
    for(i=0;i<nb_ostreams;i++) {
1467
        ost = ost_table[i];
1468
        ist = ist_table[ost->source_index];
1469

    
1470
        codec = &ost->st->codec;
1471
        icodec = &ist->st->codec;
1472

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

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

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

    
1642
    /* dump the file output parameters - cannot be done before in case
1643
       of stream copy */
1644
    for(i=0;i<nb_output_files;i++) {
1645
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1646
    }
1647

    
1648
    /* dump the stream mapping */
1649
    if (verbose >= 0) {
1650
        fprintf(stderr, "Stream mapping:\n");
1651
        for(i=0;i<nb_ostreams;i++) {
1652
            ost = ost_table[i];
1653
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d\n",
1654
                    ist_table[ost->source_index]->file_index,
1655
                    ist_table[ost->source_index]->index,
1656
                    ost->file_index, 
1657
                    ost->index);
1658
        }
1659
    }
1660

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

    
1681
    /* open each decoder */
1682
    for(i=0;i<nb_istreams;i++) {
1683
        ist = ist_table[i];
1684
        if (ist->decoding_needed) {
1685
            AVCodec *codec;
1686
            codec = avcodec_find_decoder(ist->st->codec.codec_id);
1687
            if (!codec) {
1688
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n", 
1689
                        ist->st->codec.codec_id, ist->file_index, ist->index);
1690
                exit(1);
1691
            }
1692
            if (avcodec_open(&ist->st->codec, codec) < 0) {
1693
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
1694
                        ist->file_index, ist->index);
1695
                exit(1);
1696
            }
1697
            //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1698
            //    ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1699
        }
1700
    }
1701

    
1702
    /* init pts */
1703
    for(i=0;i<nb_istreams;i++) {
1704
        ist = ist_table[i];
1705
        is = input_files[ist->file_index];
1706
        ist->pts = 0;
1707
        ist->next_pts = 0;
1708
        ist->is_start = 1;
1709
    }
1710
    
1711
    /* compute buffer size max (should use a complete heuristic) */
1712
    for(i=0;i<nb_input_files;i++) {
1713
        file_table[i].buffer_size_max = 2048;
1714
    }
1715

    
1716
    /* open files and write file headers */
1717
    for(i=0;i<nb_output_files;i++) {
1718
        os = output_files[i];
1719
        if (av_write_header(os) < 0) {
1720
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
1721
            ret = -EINVAL;
1722
            goto fail;
1723
        }
1724
    }
1725

    
1726
#ifndef CONFIG_WIN32
1727
    if ( !using_stdin && verbose >= 0) {
1728
        fprintf(stderr, "Press [q] to stop encoding\n");
1729
        url_set_interrupt_cb(decode_interrupt_cb);
1730
    }
1731
#endif
1732
    term_init();
1733

    
1734
    stream_no_data = 0;
1735
    key = -1;
1736

    
1737
    for(; received_sigterm == 0;) {
1738
        int file_index, ist_index;
1739
        AVPacket pkt;
1740
        double ipts_min= 1e100;
1741
        double opts_min= 1e100;
1742

    
1743
    redo:
1744
        /* if 'q' pressed, exits */
1745
        if (!using_stdin) {
1746
            if (q_pressed)
1747
                break;
1748
            /* read_key() returns 0 on EOF */
1749
            key = read_key();
1750
            if (key == 'q')
1751
                break;
1752
        }
1753

    
1754
        /* select the stream that we must read now by looking at the
1755
           smallest output pts */
1756
        file_index = -1;
1757
        for(i=0;i<nb_ostreams;i++) {
1758
            double ipts, opts;
1759
            ost = ost_table[i];
1760
            os = output_files[ost->file_index];
1761
            ist = ist_table[ost->source_index];
1762
            if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1763
                opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1764
            else
1765
                opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1766
            ipts = (double)ist->pts;
1767
            if (!file_table[ist->file_index].eof_reached){
1768
                if(ipts < ipts_min) {
1769
                    ipts_min = ipts;
1770
                    if(input_sync ) file_index = ist->file_index;
1771
                }
1772
                if(opts < opts_min) {
1773
                    opts_min = opts;
1774
                    if(!input_sync) file_index = ist->file_index;
1775
                }
1776
            }
1777
        }
1778
        /* if none, if is finished */
1779
        if (file_index < 0) {
1780
            break;
1781
        }
1782

    
1783
        /* finish if recording time exhausted */
1784
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1785
            break;
1786

    
1787
        /* read a frame from it and output it in the fifo */
1788
        is = input_files[file_index];
1789
        if (av_read_frame(is, &pkt) < 0) {
1790
            file_table[file_index].eof_reached = 1;
1791
            continue;
1792
        }
1793

    
1794
        if (!pkt.size) {
1795
            stream_no_data = is;
1796
        } else {
1797
            stream_no_data = 0;
1798
        }
1799
        if (do_pkt_dump) {
1800
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1801
        }
1802
        /* the following test is needed in case new streams appear
1803
           dynamically in stream : we ignore them */
1804
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1805
            goto discard_packet;
1806
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1807
        ist = ist_table[ist_index];
1808
        if (ist->discard)
1809
            goto discard_packet;
1810

    
1811
//        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);
1812
        if (pkt.dts != AV_NOPTS_VALUE) {
1813
            int64_t delta= pkt.dts - ist->next_pts;
1814
            if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1815
                input_files_ts_offset[ist->file_index]-= delta;
1816
                if (verbose > 2)
1817
                    fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1818
                for(i=0; i<file_table[file_index].nb_streams; i++){
1819
                    int index= file_table[file_index].ist_index + i;
1820
                    ist_table[index]->next_pts += delta;
1821
                    ist_table[index]->is_start=1;
1822
                }
1823
            }
1824
        }
1825

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

    
1829
            if (verbose >= 0)
1830
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1831
                        ist->file_index, ist->index);
1832

    
1833
            av_free_packet(&pkt);
1834
            goto redo;
1835
        }
1836
        
1837
    discard_packet:
1838
        av_free_packet(&pkt);
1839
        
1840
        /* dump report by using the output first video and audio streams */
1841
        print_report(output_files, ost_table, nb_ostreams, 0);
1842
    }
1843

    
1844
    /* at the end of stream, we must flush the decoder buffers */
1845
    for(i=0;i<nb_istreams;i++) {
1846
        ist = ist_table[i];
1847
        if (ist->decoding_needed) {
1848
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1849
        }
1850
    }
1851

    
1852
    term_exit();
1853

    
1854
    /* write the trailer if needed and close file */
1855
    for(i=0;i<nb_output_files;i++) {
1856
        os = output_files[i];
1857
        av_write_trailer(os);
1858
    }
1859

    
1860
    /* dump report by using the first video and audio streams */
1861
    print_report(output_files, ost_table, nb_ostreams, 1);
1862

    
1863
    /* close each encoder */
1864
    for(i=0;i<nb_ostreams;i++) {
1865
        ost = ost_table[i];
1866
        if (ost->encoding_needed) {
1867
            av_freep(&ost->st->codec.stats_in);
1868
            avcodec_close(&ost->st->codec);
1869
        }
1870
    }
1871
    
1872
    /* close each decoder */
1873
    for(i=0;i<nb_istreams;i++) {
1874
        ist = ist_table[i];
1875
        if (ist->decoding_needed) {
1876
            avcodec_close(&ist->st->codec);
1877
        }
1878
    }
1879

    
1880
    /* finished ! */
1881
    
1882
    ret = 0;
1883
 fail1:
1884
    av_free(file_table);
1885

    
1886
    if (ist_table) {
1887
        for(i=0;i<nb_istreams;i++) {
1888
            ist = ist_table[i];
1889
            av_free(ist);
1890
        }
1891
        av_free(ist_table);
1892
    }
1893
    if (ost_table) {
1894
        for(i=0;i<nb_ostreams;i++) {
1895
            ost = ost_table[i];
1896
            if (ost) {
1897
                if (ost->logfile) {
1898
                    fclose(ost->logfile);
1899
                    ost->logfile = NULL;
1900
                }
1901
                fifo_free(&ost->fifo); /* works even if fifo is not
1902
                                          initialized but set to zero */
1903
                av_free(ost->pict_tmp.data[0]);
1904
                if (ost->video_resample)
1905
                    img_resample_close(ost->img_resample_ctx);
1906
                if (ost->audio_resample)
1907
                    audio_resample_close(ost->resample);
1908
                av_free(ost);
1909
            }
1910
        }
1911
        av_free(ost_table);
1912
    }
1913
    return ret;
1914
 fail:
1915
    ret = -ENOMEM;
1916
    goto fail1;
1917
}
1918

    
1919
#if 0
1920
int file_read(const char *filename)
1921
{
1922
    URLContext *h;
1923
    unsigned char buffer[1024];
1924
    int len, i;
1925

1926
    if (url_open(&h, filename, O_RDONLY) < 0) {
1927
        printf("could not open '%s'\n", filename);
1928
        return -1;
1929
    }
1930
    for(;;) {
1931
        len = url_read(h, buffer, sizeof(buffer));
1932
        if (len <= 0)
1933
            break;
1934
        for(i=0;i<len;i++) putchar(buffer[i]);
1935
    }
1936
    url_close(h);
1937
    return 0;
1938
}
1939
#endif
1940

    
1941
static void opt_image_format(const char *arg)
1942
{
1943
    AVImageFormat *f;
1944
    
1945
    for(f = first_image_format; f != NULL; f = f->next) {
1946
        if (!strcmp(arg, f->name))
1947
            break;
1948
    }
1949
    if (!f) {
1950
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
1951
        exit(1);
1952
    }
1953
    image_format = f;
1954
}
1955

    
1956
static void opt_format(const char *arg)
1957
{
1958
    /* compatibility stuff for pgmyuv */
1959
    if (!strcmp(arg, "pgmyuv")) {
1960
        opt_image_format(arg);
1961
        arg = "image";
1962
    }
1963

    
1964
    file_iformat = av_find_input_format(arg);
1965
    file_oformat = guess_format(arg, NULL, NULL);
1966
    if (!file_iformat && !file_oformat) {
1967
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
1968
        exit(1);
1969
    }
1970
}
1971

    
1972
static void opt_video_bitrate(const char *arg)
1973
{
1974
    video_bit_rate = atoi(arg) * 1000;
1975
}
1976

    
1977
static void opt_video_bitrate_tolerance(const char *arg)
1978
{
1979
    video_bit_rate_tolerance = atoi(arg) * 1000;
1980
}
1981

    
1982
static void opt_video_bitrate_max(const char *arg)
1983
{
1984
    video_rc_max_rate = atoi(arg) * 1000;
1985
}
1986

    
1987
static void opt_video_bitrate_min(const char *arg)
1988
{
1989
    video_rc_min_rate = atoi(arg) * 1000;
1990
}
1991

    
1992
static void opt_video_buffer_size(const char *arg)
1993
{
1994
    video_rc_buffer_size = atoi(arg) * 8*1024;
1995
}
1996

    
1997
static void opt_video_rc_eq(char *arg)
1998
{
1999
    video_rc_eq = arg;
2000
}
2001

    
2002
static void opt_video_rc_override_string(char *arg)
2003
{
2004
    video_rc_override_string = arg;
2005
}
2006

    
2007

    
2008
static void opt_workaround_bugs(const char *arg)
2009
{
2010
    workaround_bugs = atoi(arg);
2011
}
2012

    
2013
static void opt_dct_algo(const char *arg)
2014
{
2015
    dct_algo = atoi(arg);
2016
}
2017

    
2018
static void opt_idct_algo(const char *arg)
2019
{
2020
    idct_algo = atoi(arg);
2021
}
2022

    
2023
static void opt_me_threshold(const char *arg)
2024
{
2025
    me_threshold = atoi(arg);
2026
}
2027

    
2028
static void opt_mb_threshold(const char *arg)
2029
{
2030
    mb_threshold = atoi(arg);
2031
}
2032

    
2033
static void opt_error_resilience(const char *arg)
2034
{
2035
    error_resilience = atoi(arg);
2036
}
2037

    
2038
static void opt_error_concealment(const char *arg)
2039
{
2040
    error_concealment = atoi(arg);
2041
}
2042

    
2043
static void opt_debug(const char *arg)
2044
{
2045
    debug = atoi(arg);
2046
}
2047

    
2048
static void opt_vismv(const char *arg)
2049
{
2050
    debug_mv = atoi(arg);
2051
}
2052
    
2053
static void opt_verbose(const char *arg)
2054
{
2055
    verbose = atoi(arg);
2056
    av_log_set_level(atoi(arg));
2057
}
2058

    
2059
static void opt_frame_rate(const char *arg)
2060
{
2061
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2062
        fprintf(stderr, "Incorrect frame rate\n");
2063
        exit(1);
2064
    }
2065
}
2066

    
2067
static void opt_frame_crop_top(const char *arg)
2068
{
2069
    frame_topBand = atoi(arg); 
2070
    if (frame_topBand < 0) {
2071
        fprintf(stderr, "Incorrect top crop size\n");
2072
        exit(1);
2073
    }
2074
    if ((frame_topBand % 2) != 0) {
2075
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2076
        exit(1);
2077
    }
2078
    if ((frame_topBand) >= frame_height){
2079
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2080
        exit(1);
2081
    }
2082
    frame_height -= frame_topBand;
2083
}
2084

    
2085
static void opt_frame_crop_bottom(const char *arg)
2086
{
2087
    frame_bottomBand = atoi(arg);
2088
    if (frame_bottomBand < 0) {
2089
        fprintf(stderr, "Incorrect bottom crop size\n");
2090
        exit(1);
2091
    }
2092
    if ((frame_bottomBand % 2) != 0) {
2093
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2094
        exit(1);        
2095
    }
2096
    if ((frame_bottomBand) >= frame_height){
2097
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2098
        exit(1);
2099
    }
2100
    frame_height -= frame_bottomBand;
2101
}
2102

    
2103
static void opt_frame_crop_left(const char *arg)
2104
{
2105
    frame_leftBand = atoi(arg);
2106
    if (frame_leftBand < 0) {
2107
        fprintf(stderr, "Incorrect left crop size\n");
2108
        exit(1);
2109
    }
2110
    if ((frame_leftBand % 2) != 0) {
2111
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2112
        exit(1);
2113
    }
2114
    if ((frame_leftBand) >= frame_width){
2115
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2116
        exit(1);
2117
    }
2118
    frame_width -= frame_leftBand;
2119
}
2120

    
2121
static void opt_frame_crop_right(const char *arg)
2122
{
2123
    frame_rightBand = atoi(arg);
2124
    if (frame_rightBand < 0) {
2125
        fprintf(stderr, "Incorrect right crop size\n");
2126
        exit(1);
2127
    }
2128
    if ((frame_rightBand % 2) != 0) {
2129
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2130
        exit(1);        
2131
    }
2132
    if ((frame_rightBand) >= frame_width){
2133
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2134
        exit(1);
2135
    }
2136
    frame_width -= frame_rightBand;
2137
}
2138

    
2139
static void opt_frame_size(const char *arg)
2140
{
2141
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2142
        fprintf(stderr, "Incorrect frame size\n");
2143
        exit(1);
2144
    }
2145
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2146
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2147
        exit(1);
2148
    }
2149
}
2150

    
2151

    
2152
#define SCALEBITS 10
2153
#define ONE_HALF  (1 << (SCALEBITS - 1))
2154
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
2155

    
2156
#define RGB_TO_Y(r, g, b) \
2157
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2158
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2159

    
2160
#define RGB_TO_U(r1, g1, b1, shift)\
2161
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2162
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2163

    
2164
#define RGB_TO_V(r1, g1, b1, shift)\
2165
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2166
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2167

    
2168
static void opt_pad_color(const char *arg) {
2169
    /* Input is expected to be six hex digits similar to
2170
       how colors are expressed in html tags (but without the #) */
2171
    int rgb = strtol(arg, NULL, 16);
2172
    int r,g,b;
2173
    
2174
    r = (rgb >> 16); 
2175
    g = ((rgb >> 8) & 255);
2176
    b = (rgb & 255);
2177

    
2178
    padcolor[0] = RGB_TO_Y(r,g,b);
2179
    padcolor[1] = RGB_TO_U(r,g,b,0);
2180
    padcolor[2] = RGB_TO_V(r,g,b,0);
2181
}
2182

    
2183
static void opt_frame_pad_top(const char *arg)
2184
{
2185
    frame_padtop = atoi(arg); 
2186
    if (frame_padtop < 0) {
2187
        fprintf(stderr, "Incorrect top pad size\n");
2188
        exit(1);
2189
    }
2190
    if ((frame_padtop % 2) != 0) {
2191
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2192
        exit(1);
2193
    }
2194
}
2195

    
2196
static void opt_frame_pad_bottom(const char *arg)
2197
{
2198
    frame_padbottom = atoi(arg); 
2199
    if (frame_padbottom < 0) {
2200
        fprintf(stderr, "Incorrect bottom pad size\n");
2201
        exit(1);
2202
    }
2203
    if ((frame_padbottom % 2) != 0) {
2204
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2205
        exit(1);
2206
    }
2207
}
2208

    
2209

    
2210
static void opt_frame_pad_left(const char *arg)
2211
{
2212
    frame_padleft = atoi(arg); 
2213
    if (frame_padleft < 0) {
2214
        fprintf(stderr, "Incorrect left pad size\n");
2215
        exit(1);
2216
    }
2217
    if ((frame_padleft % 2) != 0) {
2218
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2219
        exit(1);
2220
    }
2221
}
2222

    
2223

    
2224
static void opt_frame_pad_right(const char *arg)
2225
{
2226
    frame_padright = atoi(arg); 
2227
    if (frame_padright < 0) {
2228
        fprintf(stderr, "Incorrect right pad size\n");
2229
        exit(1);
2230
    }
2231
    if ((frame_padright % 2) != 0) {
2232
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2233
        exit(1);
2234
    }
2235
}
2236

    
2237

    
2238
static void opt_frame_pix_fmt(const char *arg)
2239
{
2240
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2241
}
2242

    
2243
static void opt_frame_aspect_ratio(const char *arg)
2244
{
2245
    int x = 0, y = 0;
2246
    double ar = 0;
2247
    const char *p;
2248
    
2249
    p = strchr(arg, ':');
2250
    if (p) {
2251
        x = strtol(arg, (char **)&arg, 10);
2252
        if (arg == p)
2253
            y = strtol(arg+1, (char **)&arg, 10);
2254
        if (x > 0 && y > 0)
2255
            ar = (double)x / (double)y;
2256
    } else
2257
        ar = strtod(arg, (char **)&arg);
2258

    
2259
    if (!ar) {
2260
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2261
        exit(1);
2262
    }
2263
    frame_aspect_ratio = ar;
2264
}
2265

    
2266
static void opt_gop_size(const char *arg)
2267
{
2268
    gop_size = atoi(arg);
2269
}
2270

    
2271
static void opt_b_frames(const char *arg)
2272
{
2273
    b_frames = atoi(arg);
2274
    if (b_frames > FF_MAX_B_FRAMES) {
2275
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2276
        exit(1);
2277
    } else if (b_frames < 1) {
2278
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2279
        exit(1);
2280
    }
2281
}
2282

    
2283
static void opt_mb_decision(const char *arg)
2284
{
2285
    mb_decision = atoi(arg);
2286
}
2287

    
2288
static void opt_mb_cmp(const char *arg)
2289
{
2290
    mb_cmp = atoi(arg);
2291
}
2292

    
2293
static void opt_ildct_cmp(const char *arg)
2294
{
2295
    ildct_cmp = atoi(arg);
2296
}
2297

    
2298
static void opt_sub_cmp(const char *arg)
2299
{
2300
    sub_cmp = atoi(arg);
2301
}
2302

    
2303
static void opt_cmp(const char *arg)
2304
{
2305
    cmp = atoi(arg);
2306
}
2307

    
2308
static void opt_pre_cmp(const char *arg)
2309
{
2310
    pre_cmp = atoi(arg);
2311
}
2312

    
2313
static void opt_pre_me(const char *arg)
2314
{
2315
    pre_me = atoi(arg);
2316
}
2317

    
2318
static void opt_lumi_mask(const char *arg)
2319
{
2320
    lumi_mask = atof(arg);
2321
}
2322

    
2323
static void opt_dark_mask(const char *arg)
2324
{
2325
    dark_mask = atof(arg);
2326
}
2327

    
2328
static void opt_scplx_mask(const char *arg)
2329
{
2330
    scplx_mask = atof(arg);
2331
}
2332

    
2333
static void opt_tcplx_mask(const char *arg)
2334
{
2335
    tcplx_mask = atof(arg);
2336
}
2337

    
2338
static void opt_p_mask(const char *arg)
2339
{
2340
    p_mask = atof(arg);
2341
}
2342

    
2343
static void opt_qscale(const char *arg)
2344
{
2345
    video_qscale = atof(arg);
2346
    if (video_qscale < 0.01 ||
2347
        video_qscale > 255) {
2348
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2349
        exit(1);
2350
    }
2351
}
2352

    
2353
static void opt_lmax(const char *arg)
2354
{
2355
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2356
}
2357

    
2358
static void opt_lmin(const char *arg)
2359
{
2360
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2361
}
2362

    
2363
static void opt_qmin(const char *arg)
2364
{
2365
    video_qmin = atoi(arg);
2366
    if (video_qmin < 0 ||
2367
        video_qmin > 31) {
2368
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2369
        exit(1);
2370
    }
2371
}
2372

    
2373
static void opt_qmax(const char *arg)
2374
{
2375
    video_qmax = atoi(arg);
2376
    if (video_qmax < 0 ||
2377
        video_qmax > 31) {
2378
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2379
        exit(1);
2380
    }
2381
}
2382

    
2383
static void opt_mb_qmin(const char *arg)
2384
{
2385
    video_mb_qmin = atoi(arg);
2386
    if (video_mb_qmin < 0 ||
2387
        video_mb_qmin > 31) {
2388
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2389
        exit(1);
2390
    }
2391
}
2392

    
2393
static void opt_mb_qmax(const char *arg)
2394
{
2395
    video_mb_qmax = atoi(arg);
2396
    if (video_mb_qmax < 0 ||
2397
        video_mb_qmax > 31) {
2398
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2399
        exit(1);
2400
    }
2401
}
2402

    
2403
static void opt_qdiff(const char *arg)
2404
{
2405
    video_qdiff = atoi(arg);
2406
    if (video_qdiff < 0 ||
2407
        video_qdiff > 31) {
2408
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2409
        exit(1);
2410
    }
2411
}
2412

    
2413
static void opt_qblur(const char *arg)
2414
{
2415
    video_qblur = atof(arg);
2416
}
2417

    
2418
static void opt_qcomp(const char *arg)
2419
{
2420
    video_qcomp = atof(arg);
2421
}
2422

    
2423
static void opt_rc_initial_cplx(const char *arg)
2424
{
2425
    video_rc_initial_cplx = atof(arg);
2426
}
2427
static void opt_b_qfactor(const char *arg)
2428
{
2429
    video_b_qfactor = atof(arg);
2430
}
2431
static void opt_i_qfactor(const char *arg)
2432
{
2433
    video_i_qfactor = atof(arg);
2434
}
2435
static void opt_b_qoffset(const char *arg)
2436
{
2437
    video_b_qoffset = atof(arg);
2438
}
2439
static void opt_i_qoffset(const char *arg)
2440
{
2441
    video_i_qoffset = atof(arg);
2442
}
2443

    
2444
static void opt_ibias(const char *arg)
2445
{
2446
    video_intra_quant_bias = atoi(arg);
2447
}
2448
static void opt_pbias(const char *arg)
2449
{
2450
    video_inter_quant_bias = atoi(arg);
2451
}
2452

    
2453
static void opt_packet_size(const char *arg)
2454
{
2455
    packet_size= atoi(arg);
2456
}
2457

    
2458
static void opt_error_rate(const char *arg)
2459
{
2460
    error_rate= atoi(arg);
2461
}
2462

    
2463
static void opt_strict(const char *arg)
2464
{
2465
    strict= atoi(arg);
2466
}
2467

    
2468
static void opt_top_field_first(const char *arg)
2469
{
2470
    top_field_first= atoi(arg);
2471
}
2472

    
2473
static void opt_noise_reduction(const char *arg)
2474
{
2475
    noise_reduction= atoi(arg);
2476
}
2477

    
2478
static void opt_qns(const char *arg)
2479
{
2480
    qns= atoi(arg);
2481
}
2482

    
2483
static void opt_sc_threshold(const char *arg)
2484
{
2485
    sc_threshold= atoi(arg);
2486
}
2487

    
2488
static void opt_me_range(const char *arg)
2489
{
2490
    me_range = atoi(arg);
2491
}
2492

    
2493
static void opt_thread_count(const char *arg)
2494
{
2495
    thread_count= atoi(arg);
2496
#if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2497
    if (verbose >= 0)
2498
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2499
#endif
2500
}
2501

    
2502
static void opt_audio_bitrate(const char *arg)
2503
{
2504
    audio_bit_rate = atoi(arg) * 1000;
2505
}
2506

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

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

    
2517
static void opt_video_device(const char *arg)
2518
{
2519
    video_device = av_strdup(arg);
2520
}
2521

    
2522
static void opt_video_channel(const char *arg)
2523
{
2524
    video_channel = strtol(arg, NULL, 0);
2525
}
2526

    
2527
static void opt_video_standard(const char *arg)
2528
{
2529
    video_standard = av_strdup(arg);
2530
}
2531

    
2532
static void opt_audio_device(const char *arg)
2533
{
2534
    audio_device = av_strdup(arg);
2535
}
2536

    
2537
static void opt_dv1394(const char *arg)
2538
{
2539
    video_grab_format = "dv1394";
2540
    audio_grab_format = NULL;
2541
}
2542

    
2543
static void opt_audio_codec(const char *arg)
2544
{
2545
    AVCodec *p;
2546

    
2547
    if (!strcmp(arg, "copy")) {
2548
        audio_stream_copy = 1;
2549
    } else {
2550
        p = first_avcodec;
2551
        while (p) {
2552
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2553
                break;
2554
            p = p->next;
2555
        }
2556
        if (p == NULL) {
2557
            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2558
            exit(1);
2559
        } else {
2560
            audio_codec_id = p->id;
2561
        }
2562
    }
2563
}
2564

    
2565
static void add_frame_hooker(const char *arg)
2566
{
2567
    int argc = 0;
2568
    char *argv[64];
2569
    int i;
2570
    char *args = av_strdup(arg);
2571

    
2572
    using_vhook = 1;
2573

    
2574
    argv[0] = strtok(args, " ");
2575
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2576
    }
2577

    
2578
    i = frame_hook_add(argc, argv);
2579

    
2580
    if (i != 0) {
2581
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2582
        exit(1);
2583
    }
2584
}
2585

    
2586
const char *motion_str[] = {
2587
    "zero",
2588
    "full",
2589
    "log",
2590
    "phods",
2591
    "epzs",
2592
    "x1",
2593
    NULL,
2594
};
2595

    
2596
static void opt_motion_estimation(const char *arg)
2597
{
2598
    const char **p;
2599
    p = motion_str;
2600
    for(;;) {
2601
        if (!*p) {
2602
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2603
            exit(1);
2604
        }
2605
        if (!strcmp(*p, arg))
2606
            break;
2607
        p++;
2608
    }
2609
    me_method = (p - motion_str) + 1;
2610
}
2611

    
2612
static void opt_video_codec(const char *arg)
2613
{
2614
    AVCodec *p;
2615

    
2616
    if (!strcmp(arg, "copy")) {
2617
        video_stream_copy = 1;
2618
    } else {
2619
        p = first_avcodec;
2620
        while (p) {
2621
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2622
                break;
2623
            p = p->next;
2624
        }
2625
        if (p == NULL) {
2626
            fprintf(stderr, "Unknown video codec '%s'\n", arg);
2627
            exit(1);
2628
        } else {
2629
            video_codec_id = p->id;
2630
        }
2631
    }
2632
}
2633

    
2634
static void opt_map(const char *arg)
2635
{
2636
    AVStreamMap *m;
2637
    const char *p;
2638

    
2639
    p = arg;
2640
    m = &stream_maps[nb_stream_maps++];
2641

    
2642
    m->file_index = strtol(arg, (char **)&p, 0);
2643
    if (*p)
2644
        p++;
2645

    
2646
    m->stream_index = strtol(p, (char **)&p, 0);
2647
}
2648

    
2649
static void opt_recording_time(const char *arg)
2650
{
2651
    recording_time = parse_date(arg, 1);
2652
}
2653

    
2654
static void opt_start_time(const char *arg)
2655
{
2656
    start_time = parse_date(arg, 1);
2657
}
2658

    
2659
static void opt_rec_timestamp(const char *arg)
2660
{
2661
    rec_timestamp = parse_date(arg, 0) / 1000000;
2662
}
2663

    
2664
static void opt_input_ts_offset(const char *arg)
2665
{
2666
    input_ts_offset = parse_date(arg, 1);
2667
}
2668

    
2669
static void opt_input_file(const char *filename)
2670
{
2671
    AVFormatContext *ic;
2672
    AVFormatParameters params, *ap = &params;
2673
    int err, i, ret, rfps, rfps_base;
2674

    
2675
    if (!strcmp(filename, "-"))
2676
        filename = "pipe:";
2677

    
2678
    using_stdin |= !strcmp(filename, "pipe:" ) || 
2679
                   !strcmp( filename, "/dev/stdin" );
2680

    
2681
    /* get default parameters from command line */
2682
    memset(ap, 0, sizeof(*ap));
2683
    ap->sample_rate = audio_sample_rate;
2684
    ap->channels = audio_channels;
2685
    ap->frame_rate = frame_rate;
2686
    ap->frame_rate_base = frame_rate_base;
2687
    ap->width = frame_width + frame_padleft + frame_padright;
2688
    ap->height = frame_height + frame_padtop + frame_padbottom;
2689
    ap->image_format = image_format;
2690
    ap->pix_fmt = frame_pix_fmt;
2691

    
2692
    /* open the input file with generic libav function */
2693
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2694
    if (err < 0) {
2695
        print_error(filename, err);
2696
        exit(1);
2697
    }
2698
    
2699
    /* If not enough info to get the stream parameters, we decode the
2700
       first frames to get it. (used in mpeg case for example) */
2701
    ret = av_find_stream_info(ic);
2702
    if (ret < 0 && verbose >= 0) {
2703
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2704
        exit(1);
2705
    }
2706

    
2707
    /* if seeking requested, we execute it */
2708
    if (start_time != 0) {
2709
        int64_t timestamp;
2710

    
2711
        timestamp = start_time;
2712
        /* add the stream start time */
2713
        if (ic->start_time != AV_NOPTS_VALUE)
2714
            timestamp += ic->start_time;
2715
        ret = av_seek_frame(ic, -1, timestamp);
2716
        if (ret < 0) {
2717
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
2718
                    filename, (double)timestamp / AV_TIME_BASE);
2719
        }
2720
        /* reset seek info */
2721
        start_time = 0;
2722
    }
2723

    
2724
    /* update the current parameters so that they match the one of the input stream */
2725
    for(i=0;i<ic->nb_streams;i++) {
2726
        AVCodecContext *enc = &ic->streams[i]->codec;
2727
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2728
        if(thread_count>1)
2729
            avcodec_thread_init(enc, thread_count);
2730
#endif
2731
        enc->thread_count= thread_count;
2732
        switch(enc->codec_type) {
2733
        case CODEC_TYPE_AUDIO:
2734
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2735
            audio_channels = enc->channels;
2736
            audio_sample_rate = enc->sample_rate;
2737
            break;
2738
        case CODEC_TYPE_VIDEO:
2739
            frame_height = enc->height;
2740
            frame_width = enc->width;
2741
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2742
            frame_pix_fmt = enc->pix_fmt;
2743
            rfps      = ic->streams[i]->r_frame_rate;
2744
            rfps_base = ic->streams[i]->r_frame_rate_base;
2745
            enc->workaround_bugs = workaround_bugs;
2746
            enc->error_resilience = error_resilience; 
2747
            enc->error_concealment = error_concealment; 
2748
            enc->idct_algo = idct_algo;
2749
            enc->debug = debug;
2750
            enc->debug_mv = debug_mv;            
2751
            if(bitexact)
2752
                enc->flags|= CODEC_FLAG_BITEXACT;
2753
            if(me_threshold)
2754
                enc->debug |= FF_DEBUG_MV;
2755

    
2756
            assert(enc->frame_rate_base == rfps_base); // should be true for now
2757
            if (enc->frame_rate != rfps) { 
2758

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

    
2763
                    (float)rfps / rfps_base);
2764
            }
2765
            /* update the current frame rate to match the stream frame rate */
2766
            frame_rate      = rfps;
2767
            frame_rate_base = rfps_base;
2768

    
2769
            enc->rate_emu = rate_emu;
2770
            break;
2771
        case CODEC_TYPE_DATA:
2772
            break;
2773
        default:
2774
            av_abort();
2775
        }
2776
    }
2777
    
2778
    input_files[nb_input_files] = ic;
2779
    input_files_ts_offset[nb_input_files] = input_ts_offset;
2780
    /* dump the file content */
2781
    if (verbose >= 0)
2782
        dump_format(ic, nb_input_files, filename, 0);
2783

    
2784
    nb_input_files++;
2785
    file_iformat = NULL;
2786
    file_oformat = NULL;
2787
    image_format = NULL;
2788

    
2789
    rate_emu = 0;
2790
}
2791

    
2792
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2793
{
2794
    int has_video, has_audio, i, j;
2795
    AVFormatContext *ic;
2796

    
2797
    has_video = 0;
2798
    has_audio = 0;
2799
    for(j=0;j<nb_input_files;j++) {
2800
        ic = input_files[j];
2801
        for(i=0;i<ic->nb_streams;i++) {
2802
            AVCodecContext *enc = &ic->streams[i]->codec;
2803
            switch(enc->codec_type) {
2804
            case CODEC_TYPE_AUDIO:
2805
                has_audio = 1;
2806
                break;
2807
            case CODEC_TYPE_VIDEO:
2808
                has_video = 1;
2809
                break;
2810
            case CODEC_TYPE_DATA:
2811
                break;
2812
            default:
2813
                av_abort();
2814
            }
2815
        }
2816
    }
2817
    *has_video_ptr = has_video;
2818
    *has_audio_ptr = has_audio;
2819
}
2820

    
2821
static void opt_output_file(const char *filename)
2822
{
2823
    AVStream *st;
2824
    AVFormatContext *oc;
2825
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2826
    int codec_id;
2827
    AVFormatParameters params, *ap = &params;
2828

    
2829
    if (!strcmp(filename, "-"))
2830
        filename = "pipe:";
2831

    
2832
    oc = av_alloc_format_context();
2833

    
2834
    if (!file_oformat) {
2835
        file_oformat = guess_format(NULL, filename, NULL);
2836
        if (!file_oformat) {
2837
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2838
                    filename);
2839
            exit(1);
2840
        }
2841
    }
2842
    
2843
    oc->oformat = file_oformat;
2844

    
2845
    if (!strcmp(file_oformat->name, "ffm") && 
2846
        strstart(filename, "http:", NULL)) {
2847
        /* special case for files sent to ffserver: we get the stream
2848
           parameters from ffserver */
2849
        if (read_ffserver_streams(oc, filename) < 0) {
2850
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2851
            exit(1);
2852
        }
2853
    } else {
2854
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2855
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2856

    
2857
        /* disable if no corresponding type found and at least one
2858
           input file */
2859
        if (nb_input_files > 0) {
2860
            check_audio_video_inputs(&input_has_video, &input_has_audio);
2861
            if (!input_has_video)
2862
                use_video = 0;
2863
            if (!input_has_audio)
2864
                use_audio = 0;
2865
        }
2866

    
2867
        /* manual disable */
2868
        if (audio_disable) {
2869
            use_audio = 0;
2870
        }
2871
        if (video_disable) {
2872
            use_video = 0;
2873
        }
2874
        
2875
        nb_streams = 0;
2876
        if (use_video) {
2877
            AVCodecContext *video_enc;
2878
            
2879
            st = av_new_stream(oc, nb_streams++);
2880
            if (!st) {
2881
                fprintf(stderr, "Could not alloc stream\n");
2882
                exit(1);
2883
            }
2884
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2885
            if(thread_count>1)
2886
                avcodec_thread_init(&st->codec, thread_count);
2887
#endif
2888

    
2889
            video_enc = &st->codec;
2890
            
2891
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2892
                video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2893
            if (video_stream_copy) {
2894
                st->stream_copy = 1;
2895
                video_enc->codec_type = CODEC_TYPE_VIDEO;
2896
            } else {
2897
                char *p;
2898
                int i;
2899
                AVCodec *codec;
2900
            
2901
                codec_id = file_oformat->video_codec;
2902
                if (video_codec_id != CODEC_ID_NONE)
2903
                    codec_id = video_codec_id;
2904
                
2905
                video_enc->codec_id = codec_id;
2906
                codec = avcodec_find_encoder(codec_id);
2907
                
2908
                video_enc->bit_rate = video_bit_rate;
2909
                video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2910
                video_enc->frame_rate = frame_rate; 
2911
                video_enc->frame_rate_base = frame_rate_base; 
2912
                if(codec && codec->supported_framerates){
2913
                    const AVRational *p= codec->supported_framerates;
2914
                    AVRational req= (AVRational){frame_rate, frame_rate_base};
2915
                    const AVRational *best=NULL;
2916
                    AVRational best_error= (AVRational){INT_MAX, 1};
2917
                    for(; p->den!=0; p++){
2918
                        AVRational error= av_sub_q(req, *p);
2919
                        if(error.num <0) error.num *= -1;
2920
                        if(av_cmp_q(error, best_error) < 0){
2921
                            best_error= error;
2922
                            best= p;
2923
                        }
2924
                    }
2925
                    video_enc->frame_rate     = best->num;
2926
                    video_enc->frame_rate_base= best->den;
2927
                }
2928
                
2929
                video_enc->width = frame_width + frame_padright + frame_padleft;
2930
                video_enc->height = frame_height + frame_padtop + frame_padbottom;
2931
                video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2932
                video_enc->pix_fmt = frame_pix_fmt;
2933

    
2934
                if(codec && codec->pix_fmts){
2935
                    const enum PixelFormat *p= codec->pix_fmts;
2936
                    for(; *p!=-1; p++){
2937
                        if(*p == video_enc->pix_fmt)
2938
                            break;
2939
                    }
2940
                    if(*p == -1)
2941
                        video_enc->pix_fmt = codec->pix_fmts[0];
2942
                }
2943

    
2944
                if (!intra_only)
2945
                    video_enc->gop_size = gop_size;
2946
                else
2947
                    video_enc->gop_size = 0;
2948
                if (video_qscale || same_quality) {
2949
                    video_enc->flags |= CODEC_FLAG_QSCALE;
2950
                    st->quality = FF_QP2LAMBDA * video_qscale;
2951
                }
2952

    
2953
                if(intra_matrix)
2954
                    video_enc->intra_matrix = intra_matrix;
2955
                if(inter_matrix)
2956
                    video_enc->inter_matrix = inter_matrix;
2957

    
2958
                if(bitexact)
2959
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
2960

    
2961
                video_enc->mb_decision = mb_decision;
2962
                video_enc->mb_cmp = mb_cmp;
2963
                video_enc->ildct_cmp = ildct_cmp;
2964
                video_enc->me_sub_cmp = sub_cmp;
2965
                video_enc->me_cmp = cmp;
2966
                video_enc->me_pre_cmp = pre_cmp;
2967
                video_enc->pre_me = pre_me;
2968
                video_enc->lumi_masking = lumi_mask;
2969
                video_enc->dark_masking = dark_mask;
2970
                video_enc->spatial_cplx_masking = scplx_mask;
2971
                video_enc->temporal_cplx_masking = tcplx_mask;
2972
                video_enc->p_masking = p_mask;
2973
                video_enc->quantizer_noise_shaping= qns;
2974
                
2975
                if (use_umv) {
2976
                    video_enc->flags |= CODEC_FLAG_H263P_UMV;
2977
                }
2978
                if (use_ss) {
2979
                    video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
2980
                }
2981
                   if (use_aic) {
2982
                    video_enc->flags |= CODEC_FLAG_H263P_AIC;
2983
                }
2984
                   if (use_aiv) {
2985
                    video_enc->flags |= CODEC_FLAG_H263P_AIV;
2986
                }
2987
                if (use_4mv) {
2988
                    video_enc->flags |= CODEC_FLAG_4MV;
2989
                }
2990
                if (use_obmc) {
2991
                    video_enc->flags |= CODEC_FLAG_OBMC;
2992
                }
2993
                if (use_loop) {
2994
                    video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
2995
                }
2996
            
2997
                if(use_part) {
2998
                    video_enc->flags |= CODEC_FLAG_PART;
2999
                }
3000
                   if (use_alt_scan) {
3001
                    video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3002
                }
3003
                   if (use_trell) {
3004
                    video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3005
                }
3006
                   if (use_scan_offset) {
3007
                    video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3008
                }
3009
                   if (closed_gop) {
3010
                    video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3011
                }
3012
                   if (use_qpel) {
3013
                    video_enc->flags |= CODEC_FLAG_QPEL;
3014
                }
3015
                   if (use_qprd) {
3016
                    video_enc->flags |= CODEC_FLAG_QP_RD;
3017
                }
3018
                   if (use_cbprd) {
3019
                    video_enc->flags |= CODEC_FLAG_CBP_RD;
3020
                }
3021
                if (b_frames) {
3022
                    video_enc->max_b_frames = b_frames;
3023
                    video_enc->b_frame_strategy = 0;
3024
                    video_enc->b_quant_factor = 2.0;
3025
                }
3026
                if (do_interlace_dct) {
3027
                    video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3028
                }
3029
                if (do_interlace_me) {
3030
                    video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3031
                }
3032
                video_enc->qmin = video_qmin;
3033
                video_enc->qmax = video_qmax;
3034
                video_enc->lmin = video_lmin;
3035
                video_enc->lmax = video_lmax;
3036
                video_enc->mb_qmin = video_mb_qmin;
3037
                video_enc->mb_qmax = video_mb_qmax;
3038
                video_enc->max_qdiff = video_qdiff;
3039
                video_enc->qblur = video_qblur;
3040
                video_enc->qcompress = video_qcomp;
3041
                video_enc->rc_eq = video_rc_eq;
3042
                video_enc->debug = debug;
3043
                video_enc->debug_mv = debug_mv;
3044
                video_enc->thread_count = thread_count;
3045
                p= video_rc_override_string;
3046
                for(i=0; p; i++){
3047
                    int start, end, q;
3048
                    int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3049
                    if(e!=3){
3050
                        fprintf(stderr, "error parsing rc_override\n");
3051
                        exit(1);
3052
                    }
3053
                    video_enc->rc_override= 
3054
                        av_realloc(video_enc->rc_override, 
3055
                                   sizeof(RcOverride)*(i+1));
3056
                    video_enc->rc_override[i].start_frame= start;
3057
                    video_enc->rc_override[i].end_frame  = end;
3058
                    if(q>0){
3059
                        video_enc->rc_override[i].qscale= q;
3060
                        video_enc->rc_override[i].quality_factor= 1.0;
3061
                    }
3062
                    else{
3063
                        video_enc->rc_override[i].qscale= 0;
3064
                        video_enc->rc_override[i].quality_factor= -q/100.0;
3065
                    }
3066
                    p= strchr(p, '/');
3067
                    if(p) p++;
3068
                }
3069
                video_enc->rc_override_count=i;
3070

    
3071
                video_enc->rc_max_rate = video_rc_max_rate;
3072
                video_enc->rc_min_rate = video_rc_min_rate;
3073
                video_enc->rc_buffer_size = video_rc_buffer_size;
3074
                video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3075
                video_enc->rc_initial_cplx= video_rc_initial_cplx;
3076
                video_enc->i_quant_factor = video_i_qfactor;
3077
                video_enc->b_quant_factor = video_b_qfactor;
3078
                video_enc->i_quant_offset = video_i_qoffset;
3079
                video_enc->b_quant_offset = video_b_qoffset;
3080
                video_enc->intra_quant_bias = video_intra_quant_bias;
3081
                video_enc->inter_quant_bias = video_inter_quant_bias;
3082
                video_enc->dct_algo = dct_algo;
3083
                video_enc->idct_algo = idct_algo;
3084
                video_enc->me_threshold= me_threshold;
3085
                video_enc->mb_threshold= mb_threshold;
3086
                video_enc->intra_dc_precision= intra_dc_precision - 8;
3087
                video_enc->strict_std_compliance = strict;
3088
                video_enc->error_rate = error_rate;
3089
                video_enc->noise_reduction= noise_reduction;
3090
                video_enc->scenechange_threshold= sc_threshold;
3091
                video_enc->me_range = me_range;
3092
                video_enc->coder_type= coder;
3093
                video_enc->context_model= context;
3094
                video_enc->prediction_method= predictor;
3095

    
3096
                if(packet_size){
3097
                    video_enc->rtp_mode= 1;
3098
                    video_enc->rtp_payload_size= packet_size;
3099
                }
3100
            
3101
                if (do_psnr)
3102
                    video_enc->flags|= CODEC_FLAG_PSNR;
3103
            
3104
                video_enc->me_method = me_method;
3105

    
3106
                /* two pass mode */
3107
                if (do_pass) {
3108
                    if (do_pass == 1) {
3109
                        video_enc->flags |= CODEC_FLAG_PASS1;
3110
                    } else {
3111
                        video_enc->flags |= CODEC_FLAG_PASS2;
3112
                    }
3113
                }
3114
            }
3115
        }
3116
    
3117
        if (use_audio) {
3118
            AVCodecContext *audio_enc;
3119

    
3120
            st = av_new_stream(oc, nb_streams++);
3121
            if (!st) {
3122
                fprintf(stderr, "Could not alloc stream\n");
3123
                exit(1);
3124
            }
3125
#if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
3126
            if(thread_count>1)
3127
                avcodec_thread_init(&st->codec, thread_count);
3128
#endif
3129

    
3130
            audio_enc = &st->codec;
3131
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3132

    
3133
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3134
                audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3135
            if (audio_stream_copy) {
3136
                st->stream_copy = 1;
3137
                audio_enc->channels = audio_channels;
3138
            } else {
3139
                codec_id = file_oformat->audio_codec;
3140
                if (audio_codec_id != CODEC_ID_NONE)
3141
                    codec_id = audio_codec_id;
3142
                audio_enc->codec_id = codec_id;
3143
                
3144
                audio_enc->bit_rate = audio_bit_rate;
3145
                audio_enc->strict_std_compliance = strict;
3146
                audio_enc->thread_count = thread_count;
3147
                /* For audio codecs other than AC3 we limit */
3148
                /* the number of coded channels to stereo   */
3149
                if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
3150
                    audio_enc->channels = 2;
3151
                } else
3152
                    audio_enc->channels = audio_channels;
3153
            }
3154
            audio_enc->sample_rate = audio_sample_rate;
3155
        }
3156

    
3157
        oc->nb_streams = nb_streams;
3158

    
3159
        if (!nb_streams) {
3160
            fprintf(stderr, "No audio or video streams available\n");
3161
            exit(1);
3162
        }
3163

    
3164
        oc->timestamp = rec_timestamp;
3165
            
3166
        if (str_title)
3167
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3168
        if (str_author)
3169
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3170
        if (str_copyright)
3171
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3172
        if (str_comment)
3173
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3174
    }
3175

    
3176
    output_files[nb_output_files++] = oc;
3177

    
3178
    strcpy(oc->filename, filename);
3179

    
3180
    /* check filename in case of an image number is expected */
3181
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3182
        if (filename_number_test(oc->filename) < 0) {
3183
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3184
            exit(1);
3185
        }
3186
    }
3187

    
3188
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3189
        /* test if it already exists to avoid loosing precious files */
3190
        if (!file_overwrite && 
3191
            (strchr(filename, ':') == NULL ||
3192
             strstart(filename, "file:", NULL))) {
3193
            if (url_exist(filename)) {
3194
                int c;
3195
                
3196
                if ( !using_stdin ) {
3197
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3198
                    fflush(stderr);
3199
                    c = getchar();
3200
                    if (toupper(c) != 'Y') {
3201
                        fprintf(stderr, "Not overwriting - exiting\n");
3202
                        exit(1);
3203
                    }
3204
                                }
3205
                                else {
3206
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3207
                    exit(1);
3208
                                }
3209
            }
3210
        }
3211
        
3212
        /* open the file */
3213
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3214
            fprintf(stderr, "Could not open '%s'\n", filename);
3215
            exit(1);
3216
        }
3217
    }
3218

    
3219
    memset(ap, 0, sizeof(*ap));
3220
    ap->image_format = image_format;
3221
    if (av_set_parameters(oc, ap) < 0) {
3222
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3223
                oc->filename);
3224
        exit(1);
3225
    }
3226

    
3227
    /* reset some options */
3228
    file_oformat = NULL;
3229
    file_iformat = NULL;
3230
    image_format = NULL;
3231
    audio_disable = 0;
3232
    video_disable = 0;
3233
    audio_codec_id = CODEC_ID_NONE;
3234
    video_codec_id = CODEC_ID_NONE;
3235
    audio_stream_copy = 0;
3236
    video_stream_copy = 0;
3237
}
3238

    
3239
/* prepare dummy protocols for grab */
3240
static void prepare_grab(void)
3241
{
3242
    int has_video, has_audio, i, j;
3243
    AVFormatContext *oc;
3244
    AVFormatContext *ic;
3245
    AVFormatParameters vp1, *vp = &vp1;
3246
    AVFormatParameters ap1, *ap = &ap1;
3247
    
3248
    /* see if audio/video inputs are needed */
3249
    has_video = 0;
3250
    has_audio = 0;
3251
    memset(ap, 0, sizeof(*ap));
3252
    memset(vp, 0, sizeof(*vp));
3253
    for(j=0;j<nb_output_files;j++) {
3254
        oc = output_files[j];
3255
        for(i=0;i<oc->nb_streams;i++) {
3256
            AVCodecContext *enc = &oc->streams[i]->codec;
3257
            switch(enc->codec_type) {
3258
            case CODEC_TYPE_AUDIO:
3259
                if (enc->sample_rate > ap->sample_rate)
3260
                    ap->sample_rate = enc->sample_rate;
3261
                if (enc->channels > ap->channels)
3262
                    ap->channels = enc->channels;
3263
                has_audio = 1;
3264
                break;
3265
            case CODEC_TYPE_VIDEO:
3266
                if (enc->width > vp->width)
3267
                    vp->width = enc->width;
3268
                if (enc->height > vp->height)
3269
                    vp->height = enc->height;
3270
                
3271
                assert(enc->frame_rate_base == DEFAULT_FRAME_RATE_BASE);
3272
                if (enc->frame_rate > vp->frame_rate){
3273
                    vp->frame_rate      = enc->frame_rate;
3274
                    vp->frame_rate_base = enc->frame_rate_base;
3275
                }
3276
                has_video = 1;
3277
                break;
3278
            default:
3279
                av_abort();
3280
            }
3281
        }
3282
    }
3283
    
3284
    if (has_video == 0 && has_audio == 0) {
3285
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3286
        exit(1);
3287
    }
3288
    
3289
    if (has_video) {
3290
        AVInputFormat *fmt1;
3291
        fmt1 = av_find_input_format(video_grab_format);
3292
        vp->device  = video_device;
3293
        vp->channel = video_channel;
3294
        vp->standard = video_standard;
3295
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3296
            fprintf(stderr, "Could not find video grab device\n");
3297
            exit(1);
3298
        }
3299
        /* If not enough info to get the stream parameters, we decode the
3300
           first frames to get it. */
3301
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3302
            fprintf(stderr, "Could not find video grab parameters\n");
3303
            exit(1);
3304
        }
3305
        /* by now video grab has one stream */
3306
        ic->streams[0]->r_frame_rate      = vp->frame_rate;
3307
        ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3308
        input_files[nb_input_files] = ic;
3309

    
3310
        if (verbose >= 0)
3311
            dump_format(ic, nb_input_files, "", 0);
3312

    
3313
        nb_input_files++;
3314
    }
3315
    if (has_audio && audio_grab_format) {
3316
        AVInputFormat *fmt1;
3317
        fmt1 = av_find_input_format(audio_grab_format);
3318
        ap->device = audio_device;
3319
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3320
            fprintf(stderr, "Could not find audio grab device\n");
3321
            exit(1);
3322
        }
3323
        input_files[nb_input_files] = ic;
3324

    
3325
        if (verbose >= 0)
3326
            dump_format(ic, nb_input_files, "", 0);
3327

    
3328
        nb_input_files++;
3329
    }
3330
}
3331

    
3332
/* same option as mencoder */
3333
static void opt_pass(const char *pass_str)
3334
{
3335
    int pass;
3336
    pass = atoi(pass_str);
3337
    if (pass != 1 && pass != 2) {
3338
        fprintf(stderr, "pass number can be only 1 or 2\n");
3339
        exit(1);
3340
    }
3341
    do_pass = pass;
3342
}
3343

    
3344
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3345
static int64_t getutime(void)
3346
{
3347
  return av_gettime();
3348
}
3349
#else
3350
static int64_t getutime(void)
3351
{
3352
    struct rusage rusage;
3353

    
3354
    getrusage(RUSAGE_SELF, &rusage);
3355
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3356
}
3357
#endif
3358

    
3359
extern int ffm_nopts;
3360

    
3361
static void opt_bitexact(void)
3362
{
3363
    bitexact=1;
3364
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3365
    ffm_nopts = 1;
3366
}
3367

    
3368
static void show_formats(void)
3369
{
3370
    AVInputFormat *ifmt;
3371
    AVOutputFormat *ofmt;
3372
    AVImageFormat *image_fmt;
3373
    URLProtocol *up;
3374
    AVCodec *p, *p2;
3375
    const char **pp, *last_name;
3376

    
3377
    printf("File formats:\n");
3378
    last_name= "000";
3379
    for(;;){
3380
        int decode=0;
3381
        int encode=0;
3382
        const char *name=NULL;
3383

    
3384
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3385
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3386
                strcmp(ofmt->name, last_name)>0){
3387
                name= ofmt->name;
3388
                encode=1;
3389
            }
3390
        }
3391
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3392
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3393
                strcmp(ifmt->name, last_name)>0){
3394
                name= ifmt->name;
3395
                encode=0;
3396
            }
3397
            if(name && strcmp(ifmt->name, name)==0)
3398
                decode=1;
3399
        }
3400
        if(name==NULL)
3401
            break;
3402
        last_name= name;
3403
        
3404
        printf(
3405
            " %s%s %s\n", 
3406
            decode ? "D":" ", 
3407
            encode ? "E":" ", 
3408
            name);
3409
    }
3410
    printf("\n");
3411

    
3412
    printf("Image formats:\n");
3413
    for(image_fmt = first_image_format; image_fmt != NULL; 
3414
        image_fmt = image_fmt->next) {
3415
        printf(
3416
            " %s%s %s\n",
3417
            image_fmt->img_read  ? "D":" ",
3418
            image_fmt->img_write ? "E":" ",
3419
            image_fmt->name);
3420
    }
3421
    printf("\n");
3422

    
3423
    printf("Codecs:\n");
3424
    last_name= "000";
3425
    for(;;){
3426
        int decode=0;
3427
        int encode=0;
3428
        int cap=0;
3429

    
3430
        p2=NULL;
3431
        for(p = first_avcodec; p != NULL; p = p->next) {
3432
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3433
                strcmp(p->name, last_name)>0){
3434
                p2= p;
3435
                decode= encode= cap=0;
3436
            }
3437
            if(p2 && strcmp(p->name, p2->name)==0){
3438
                if(p->decode) decode=1;
3439
                if(p->encode) encode=1;
3440
                cap |= p->capabilities;
3441
            }
3442
        }
3443
        if(p2==NULL)
3444
            break;
3445
        last_name= p2->name;
3446
        
3447
        printf(
3448
            " %s%s%s%s%s%s %s", 
3449
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
3450
            encode ? "E":" ", 
3451
            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3452
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3453
            cap & CODEC_CAP_DR1 ? "D":" ",
3454
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3455
            p2->name);
3456
       /* if(p2->decoder && decode==0)
3457
            printf(" use %s for decoding", p2->decoder->name);*/
3458
        printf("\n");
3459
    }
3460
    printf("\n");
3461

    
3462
    printf("Supported file protocols:\n");
3463
    for(up = first_protocol; up != NULL; up = up->next)
3464
        printf(" %s:", up->name);
3465
    printf("\n");
3466
    
3467
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3468
    printf("Motion estimation methods:\n");
3469
    pp = motion_str;
3470
    while (*pp) {
3471
        printf(" %s", *pp);
3472
        if ((pp - motion_str + 1) == ME_ZERO) 
3473
            printf("(fastest)");
3474
        else if ((pp - motion_str + 1) == ME_FULL) 
3475
            printf("(slowest)");
3476
        else if ((pp - motion_str + 1) == ME_EPZS) 
3477
            printf("(default)");
3478
        pp++;
3479
    }
3480
    printf("\n\n");
3481
    printf(
3482
"Note, the names of encoders and decoders dont always match, so there are\n"
3483
"several cases where the above table shows encoder only or decoder only entries\n"
3484
"even though both encoding and decoding are supported for example, the h263\n"
3485
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3486
"worse\n");
3487
    exit(1);
3488
}
3489

    
3490
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3491
{
3492
    int i;
3493
    const char *p = str;
3494
    for(i = 0;; i++) {
3495
        dest[i] = atoi(p);
3496
        if(i == 63)
3497
            break;
3498
        p = strchr(p, ',');
3499
        if(!p) {
3500
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3501
            exit(1);
3502
        }
3503
        p++;
3504
    }
3505
}
3506

    
3507
void opt_inter_matrix(const char *arg)
3508
{
3509
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3510
    parse_matrix_coeffs(inter_matrix, arg);
3511
}
3512

    
3513
void opt_intra_matrix(const char *arg)
3514
{
3515
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3516
    parse_matrix_coeffs(intra_matrix, arg);
3517
}
3518

    
3519
static void opt_target(const char *arg)
3520
{
3521
    int norm = -1;
3522

    
3523
    if(!strncmp(arg, "pal-", 4)) {
3524
        norm = 0;
3525
        arg += 4;
3526
    } else if(!strncmp(arg, "ntsc-", 5)) {
3527
        norm = 1;
3528
        arg += 5;
3529
    } else {
3530
        int fr;
3531
        /* Calculate FR via float to avoid int overflow */
3532
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3533
        if(fr == 25000) {
3534
            norm = 0;
3535
        } else if((fr == 29970) || (fr == 23976)) {
3536
            norm = 1;
3537
        } else {
3538
            /* Try to determine PAL/NTSC by peeking in the input files */
3539
            if(nb_input_files) {
3540
                int i, j;
3541
                for(j = 0; j < nb_input_files; j++) {
3542
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3543
                        AVCodecContext *c = &input_files[j]->streams[i]->codec;
3544
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3545
                            continue;
3546
                        fr = c->frame_rate * 1000 / c->frame_rate_base;
3547
                        if(fr == 25000) {
3548
                            norm = 0;
3549
                            break;
3550
                        } else if((fr == 29970) || (fr == 23976)) {
3551
                            norm = 1;
3552
                            break;
3553
                        }
3554
                    }
3555
                    if(norm >= 0)
3556
                        break;
3557
                }
3558
            }
3559
        }
3560
        if(verbose && norm >= 0)
3561
            printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3562
    }
3563

    
3564
    if(norm < 0) {
3565
        fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3566
        fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3567
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3568
        exit(1);
3569
    }
3570

    
3571
    if(!strcmp(arg, "vcd")) {
3572

    
3573
        opt_video_codec("mpeg1video");
3574
        opt_audio_codec("mp2");
3575
        opt_format("vcd");
3576

    
3577
        opt_frame_size(norm ? "352x240" : "352x288");
3578

    
3579
        video_bit_rate = 1150000;
3580
        video_rc_max_rate = 1150000;
3581
        video_rc_min_rate = 1150000;
3582
        video_rc_buffer_size = 40*1024*8;
3583

    
3584
        audio_bit_rate = 224000;
3585
        audio_sample_rate = 44100;
3586

    
3587
    } else if(!strcmp(arg, "svcd")) {
3588

    
3589
        opt_video_codec("mpeg2video");
3590
        opt_audio_codec("mp2");
3591
        opt_format("svcd");
3592

    
3593
        opt_frame_size(norm ? "480x480" : "480x576");
3594
        opt_gop_size(norm ? "18" : "15");
3595

    
3596
        video_bit_rate = 2040000;
3597
        video_rc_max_rate = 2516000;
3598
        video_rc_min_rate = 0; //1145000;
3599
        video_rc_buffer_size = 224*1024*8;
3600
        use_scan_offset = 1;
3601

    
3602
        audio_bit_rate = 224000;
3603
        audio_sample_rate = 44100;
3604

    
3605
    } else if(!strcmp(arg, "dvd")) {
3606

    
3607
        opt_video_codec("mpeg2video");
3608
        opt_audio_codec("ac3");
3609
        opt_format("vob");
3610

    
3611
        opt_frame_size(norm ? "720x480" : "720x576");
3612
        opt_gop_size(norm ? "18" : "15");
3613

    
3614
        video_bit_rate = 6000000;
3615
        video_rc_max_rate = 9000000;
3616
        video_rc_min_rate = 0; //1500000;
3617
        video_rc_buffer_size = 224*1024*8;
3618

    
3619
        audio_bit_rate = 448000;
3620
        audio_sample_rate = 48000;
3621

    
3622
    } else {
3623
        fprintf(stderr, "Unknown target: %s\n", arg);
3624
        exit(1);
3625
    }
3626
}
3627

    
3628
static void show_version(void)
3629
{
3630
    printf("ffmpeg      " FFMPEG_VERSION "\n"
3631
           "libavcodec  %d\n"
3632
           "libavformat %d\n", 
3633
           avcodec_build(), LIBAVFORMAT_BUILD);
3634
    exit(1);
3635
}
3636

    
3637
const OptionDef options[] = {
3638
    /* main options */
3639
    { "L", 0, {(void*)show_license}, "show license" },
3640
    { "h", 0, {(void*)show_help}, "show help" },
3641
    { "version", 0, {(void*)show_version}, "show version" },
3642
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3643
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3644
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3645
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3646
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3647
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3648
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3649
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3650
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3651
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3652
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3653
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3654
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3655
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3656
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3657
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3658
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
3659
      "add timings for benchmarking" },
3660
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
3661
      "dump each input packet" },
3662
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
3663
      "when dumping packets, also dump the payload" },
3664
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
3665
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3666
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3667
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3668
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
3669
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3670
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3671
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3672
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3673

    
3674
    /* video options */
3675
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3676
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3677
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3678
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3679
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3680
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3681
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3682
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3683
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3684
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3685
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3686
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3687
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3688
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3689
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3690
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3691
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3692
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3693
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3694
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3695
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3696
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3697
    { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3698
    { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3699
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3700
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3701
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3702
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3703
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3704
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3705
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3706
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3707
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3708
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3709
//    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3710
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3711
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3712
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3713
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3714
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3715
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kByte)", "size" },
3716
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3717
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
3718
      "method" },
3719
    { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3720
    { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3721
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3722
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3723
    { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3724
    { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3725
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3726
    { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3727
    { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3728
    { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3729
    { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3730
    { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3731
    { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3732
    { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3733
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3734
    { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3735
    { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3736
    { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3737
    { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "teporal complexity masking", "" },
3738
    { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3739
    { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3740
    { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3741
    { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3742
    { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3743
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3744
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3745
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3746
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3747
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
3748
      "use same video quality as source (implies VBR)" },
3749
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3750
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3751
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
3752
      "deinterlace pictures" },
3753
    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 
3754
      "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3755
    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 
3756
      "force interlaced me support in encoder (MPEG2/MPEG4)" },
3757
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3758
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
3759
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3760
    { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3761
    { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3762
    { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3763
    { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3764
    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3765
    { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3766
    { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3767
    { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3768
    { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3769
    { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3770
    { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3771
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3772
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3773
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3774
    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3775
    { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3776
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3777
    { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3778
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3779
    { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3780
    { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3781
    { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3782

    
3783
    /* audio options */
3784
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3785
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3786
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3787
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3788
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3789

    
3790
    /* grab options */
3791
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3792
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3793
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3794
    { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3795
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3796
    { NULL, },
3797
};
3798

    
3799
static void show_banner(void)
3800
{
3801
    printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
3802
        LIBAVCODEC_BUILD);
3803
    printf("  built on " __DATE__ " " __TIME__);
3804
#ifdef __GNUC__
3805
    printf(", using gcc %d.%d.%d\n",
3806
        __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
3807
#else
3808
    printf(", using a non-gcc compiler\n");
3809
#endif
3810
}
3811

    
3812
static void show_license(void)
3813
{
3814
    show_banner();
3815
#ifdef CONFIG_GPL
3816
    printf(
3817
    "This program is free software; you can redistribute it and/or modify\n"   
3818
    "it under the terms of the GNU General Public License as published by\n"
3819
    "the Free Software Foundation; either version 2 of the License, or\n"
3820
    "(at your option) any later version.\n"
3821
    "\n"
3822
    "This program is distributed in the hope that it will be useful,\n"
3823
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3824
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
3825
    "GNU General Public License for more details.\n"
3826
    "\n"
3827
    "You should have received a copy of the GNU General Public License\n"
3828
    "along with this program; if not, write to the Free Software\n"
3829
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3830
    );
3831
#else
3832
    printf(
3833
    "This library is free software; you can redistribute it and/or\n"
3834
    "modify it under the terms of the GNU Lesser General Public\n"
3835
    "License as published by the Free Software Foundation; either\n"
3836
    "version 2 of the License, or (at your option) any later version.\n"
3837
    "\n"
3838
    "This library is distributed in the hope that it will be useful,\n"
3839
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3840
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
3841
    "Lesser General Public License for more details.\n"
3842
    "\n"
3843
    "You should have received a copy of the GNU Lesser General Public\n"
3844
    "License along with this library; if not, write to the Free Software\n"
3845
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
3846
    );
3847
#endif
3848
    exit(1);
3849
}
3850

    
3851
static void show_help(void)
3852
{
3853
    show_banner();
3854
    printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
3855
           "Hyper fast Audio and Video encoder\n");
3856
    printf("\n");
3857
    show_help_options(options, "Main options:\n",
3858
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3859
    show_help_options(options, "\nVideo options:\n",
3860
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3861
                      OPT_VIDEO);
3862
    show_help_options(options, "\nAdvanced Video options:\n",
3863
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3864
                      OPT_VIDEO | OPT_EXPERT);
3865
    show_help_options(options, "\nAudio options:\n",
3866
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3867
                      OPT_AUDIO);
3868
    show_help_options(options, "\nAdvanced Audio options:\n",
3869
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3870
                      OPT_AUDIO | OPT_EXPERT);
3871
    show_help_options(options, "\nAudio/Video grab options:\n",
3872
                      OPT_GRAB, 
3873
                      OPT_GRAB);
3874
    show_help_options(options, "\nAdvanced options:\n",
3875
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
3876
                      OPT_EXPERT);
3877
    exit(1);
3878
}
3879

    
3880
void parse_arg_file(const char *filename)
3881
{
3882
    opt_output_file(filename);
3883
}
3884

    
3885
int main(int argc, char **argv)
3886
{
3887
    int i;
3888
    int64_t ti;
3889

    
3890
    av_register_all();
3891

    
3892
    if (argc <= 1)
3893
        show_help();
3894
    else
3895
        show_banner();
3896
    
3897
    /* parse options */
3898
    parse_options(argc, argv, options);
3899

    
3900
    /* file converter / grab */
3901
    if (nb_output_files <= 0) {
3902
        fprintf(stderr, "Must supply at least one output file\n");
3903
        exit(1);
3904
    }
3905
    
3906
    if (nb_input_files == 0) {
3907
        input_sync = 1;
3908
        prepare_grab();
3909
    }
3910

    
3911
    ti = getutime();
3912
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
3913
              stream_maps, nb_stream_maps);
3914
    ti = getutime() - ti;
3915
    if (do_benchmark) {
3916
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3917
    }
3918

    
3919
    /* close files */
3920
    for(i=0;i<nb_output_files;i++) {
3921
        /* maybe av_close_output_file ??? */
3922
        AVFormatContext *s = output_files[i];
3923
        int j;
3924
        if (!(s->oformat->flags & AVFMT_NOFILE))
3925
            url_fclose(&s->pb);
3926
        for(j=0;j<s->nb_streams;j++)
3927
            av_free(s->streams[j]);
3928
        av_free(s);
3929
    }
3930
    for(i=0;i<nb_input_files;i++)
3931
        av_close_input_file(input_files[i]);
3932

    
3933
    av_free_static();
3934

    
3935
    if(intra_matrix)
3936
        av_free(intra_matrix);
3937
    if(inter_matrix)
3938
        av_free(inter_matrix);
3939
    
3940
#ifdef POWERPC_PERFORMANCE_REPORT
3941
    extern void powerpc_display_perf_report(void);
3942
    powerpc_display_perf_report();
3943
#endif /* POWERPC_PERFORMANCE_REPORT */
3944

    
3945
#ifndef CONFIG_WIN32
3946
    if (received_sigterm) {
3947
        fprintf(stderr,
3948
            "Received signal %d: terminating.\n",
3949
            (int) received_sigterm);
3950
        exit (255);
3951
    }
3952
#endif
3953
    exit(0); /* not all OS-es handle main() return value */
3954
    return 0;
3955
}