Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 15bc38e5

History | View | Annotate | Download (143 KB)

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

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

    
42
#include "cmdutils.h"
43

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

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

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

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

    
63
extern const OptionDef options[];
64

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

    
68
#define MAX_FILES 20
69

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

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

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

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

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

    
202
static int gop_size = 12;
203
static int intra_only = 0;
204
static int audio_sample_rate = 44100;
205
static int audio_bit_rate = 64000;
206
static int audio_disable = 0;
207
static int audio_channels = 1;
208
static int audio_codec_id = CODEC_ID_NONE;
209
static int audio_codec_tag = 0;
210

    
211
static int mux_rate= 0;
212
static int mux_packet_size= 0;
213
static float mux_preload= 0.5;
214
static float mux_max_delay= 0.7;
215

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

    
239
static int rate_emu = 0;
240

    
241
static char *video_grab_format = "video4linux";
242
static char *video_device = NULL;
243
static char *grab_device = NULL;
244
static int  video_channel = 0;
245
static char *video_standard = "ntsc";
246

    
247
static char *audio_grab_format = "audio_device";
248
static char *audio_device = NULL;
249

    
250
static int using_stdin = 0;
251
static int using_vhook = 0;
252
static int verbose = 1;
253
static int thread_count= 1;
254
static int q_pressed = 0;
255
static int me_range = 0;
256
static int64_t video_size = 0;
257
static int64_t audio_size = 0;
258
static int64_t extra_size = 0;
259
static int nb_frames_dup = 0;
260
static int nb_frames_drop = 0;
261
static int input_sync;
262

    
263
static int pgmyuv_compatibility_hack=0;
264

    
265

    
266
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
267

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

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

    
301
typedef struct AVInputStream {
302
    int file_index;
303
    int index;
304
    AVStream *st;
305
    int discard;             /* true if stream data should be discarded */
306
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
307
    int64_t sample_index;      /* current sample */
308

    
309
    int64_t       start;     /* time when read started */
310
    unsigned long frame;     /* current frame */
311
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
312
                                is not defined */
313
    int64_t       pts;       /* current pts */
314
    int is_start;            /* is 1 at the start and after a discontinuity */
315
} AVInputStream;
316

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

    
326
#ifndef CONFIG_WIN32
327

    
328
/* init terminal so that we can grab keys */
329
static struct termios oldtty;
330

    
331
static void term_exit(void)
332
{
333
    tcsetattr (0, TCSANOW, &oldtty);
334
}
335

    
336
static volatile sig_atomic_t received_sigterm = 0;
337

    
338
static void
339
sigterm_handler(int sig)
340
{
341
    received_sigterm = sig;
342
    term_exit();
343
}
344

    
345
static void term_init(void)
346
{
347
    struct termios tty;
348

    
349
    tcgetattr (0, &tty);
350
    oldtty = tty;
351

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

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

    
375
/* read a key without blocking */
376
static int read_key(void)
377
{
378
    int n = 1;
379
    unsigned char ch;
380
#ifndef CONFIG_BEOS_NETSERVER
381
    struct timeval tv;
382
    fd_set rfds;
383

    
384
    FD_ZERO(&rfds);
385
    FD_SET(0, &rfds);
386
    tv.tv_sec = 0;
387
    tv.tv_usec = 0;
388
    n = select(1, &rfds, NULL, NULL, &tv);
389
#endif
390
    if (n > 0) {
391
        n = read(0, &ch, 1);
392
        if (n == 1)
393
            return ch;
394

    
395
        return n;
396
    }
397
    return -1;
398
}
399

    
400
static int decode_interrupt_cb(void)
401
{
402
    return q_pressed || (q_pressed = read_key() == 'q');
403
}
404

    
405
#else
406

    
407
static volatile int received_sigterm = 0;
408

    
409
/* no interactive support */
410
static void term_exit(void)
411
{
412
}
413

    
414
static void term_init(void)
415
{
416
}
417

    
418
static int read_key(void)
419
{
420
    return 0;
421
}
422

    
423
#endif
424

    
425
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
426
{
427
    int i, err;
428
    AVFormatContext *ic;
429

    
430
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
431
    if (err < 0)
432
        return err;
433
    /* copy stream format */
434
    s->nb_streams = ic->nb_streams;
435
    for(i=0;i<ic->nb_streams;i++) {
436
        AVStream *st;
437

    
438
        st = av_mallocz(sizeof(AVStream));
439
        memcpy(st, ic->streams[i], sizeof(AVStream));
440
        s->streams[i] = st;
441
    }
442

    
443
    av_close_input_file(ic);
444
    return 0;
445
}
446

    
447
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
448

    
449
static void do_audio_out(AVFormatContext *s, 
450
                         AVOutputStream *ost, 
451
                         AVInputStream *ist,
452
                         unsigned char *buf, int size)
453
{
454
    uint8_t *buftmp;
455
    static uint8_t *audio_buf = NULL;
456
    static uint8_t *audio_out = NULL;
457
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
458

    
459
    int size_out, frame_bytes, ret;
460
    AVCodecContext *enc= &ost->st->codec;
461

    
462
    /* SC: dynamic allocation of buffers */
463
    if (!audio_buf)
464
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
465
    if (!audio_out)
466
        audio_out = av_malloc(audio_out_size);
467
    if (!audio_buf || !audio_out)
468
        return;               /* Should signal an error ! */
469

    
470
    if(audio_sync_method){
471
        double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts 
472
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
473
        double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
474
        int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
475

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

    
492
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
493
                        ist->is_start=0;
494
                    else
495
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
496

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

    
517
    if (ost->audio_resample) {
518
        buftmp = audio_buf;
519
        size_out = audio_resample(ost->resample, 
520
                                  (short *)buftmp, (short *)buf,
521
                                  size / (ist->st->codec.channels * 2));
522
        size_out = size_out * enc->channels * 2;
523
    } else {
524
        buftmp = buf;
525
        size_out = size;
526
    }
527

    
528
    /* now encode as many frames as possible */
529
    if (enc->frame_size > 1) {
530
        /* output resampled raw samples */
531
        fifo_write(&ost->fifo, buftmp, size_out, 
532
                   &ost->fifo.wptr);
533

    
534
        frame_bytes = enc->frame_size * 2 * enc->channels;
535
        
536
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
537
                     &ost->fifo.rptr) == 0) {
538
            AVPacket pkt;
539
            av_init_packet(&pkt);
540

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

    
558
        ost->sync_opts += size_out / (2 * enc->channels);
559

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

    
585
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
586
{
587
    AVCodecContext *dec;
588
    AVPicture *picture2;
589
    AVPicture picture_tmp;
590
    uint8_t *buf = 0;
591

    
592
    dec = &ist->st->codec;
593

    
594
    /* deinterlace : must be done before any resize */
595
    if (do_deinterlace || using_vhook) {
596
        int size;
597

    
598
        /* create temporary picture */
599
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
600
        buf = av_malloc(size);
601
        if (!buf)
602
            return;
603
        
604
        picture2 = &picture_tmp;
605
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
606

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

    
628
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
629

    
630
    if (picture != picture2)
631
        *picture = *picture2;
632
    *bufp = buf;
633
}
634

    
635
/* we begin to correct av delay at this threshold */
636
#define AV_DELAY_MAX 0.100
637

    
638

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

    
654
        if (padleft || padright) {
655
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
656
                (img->linesize[i] - (padright >> shift));
657

    
658
            for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
659
                memset(optr, color[i], (padleft + padright) >> shift);
660
                optr += img->linesize[i];
661
            }
662
        }
663
      
664
        if (padbottom) {
665
            optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
666
            memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
667
        }
668
    }
669
}
670

    
671
static int bit_buffer_size= 1024*256;
672
static uint8_t *bit_buffer= NULL;
673

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

    
690
    enc = &ost->st->codec;
691
    dec = &ist->st->codec;
692

    
693
    /* by default, we output a single frame */
694
    nb_frames = 1;
695

    
696
    *frame_size = 0;
697

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

    
719
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
720
    if (nb_frames <= 0) 
721
        return;
722

    
723
    /* convert pixel format if needed */
724
    target_pixfmt = ost->video_resample || ost->video_pad
725
        ? PIX_FMT_YUV420P : enc->pix_fmt;
726
    if (dec->pix_fmt != target_pixfmt) {
727
        int size;
728

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

    
741
            if (verbose >= 0)
742
                fprintf(stderr, "pixel format conversion not handled\n");
743

    
744
            goto the_end;
745
        }
746
    } else {
747
        formatted_picture = in_picture;
748
    }
749

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

    
779
                if (verbose >= 0)
780
                    fprintf(stderr, "pixel format conversion not handled\n");
781

    
782
                goto the_end;
783
            }
784
        }
785
    } else if (ost->video_crop) {
786
        picture_crop_temp.data[0] = formatted_picture->data[0] +
787
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
788

    
789
        picture_crop_temp.data[1] = formatted_picture->data[1] +
790
                ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
791
                (ost->leftBand >> 1);
792

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

    
797
        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
798
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
799
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
800
        final_picture = &picture_crop_temp;
801
    } else if (ost->video_pad) {
802
        final_picture = &ost->pict_tmp;
803

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

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

    
823
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
824
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
825
                padcolor);
826
        
827
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
828
            int size;
829

    
830
            av_free(buf);
831
            /* create temporary picture */
832
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
833
            buf = av_malloc(size);
834
            if (!buf)
835
                return;
836
            final_picture = &picture_format_temp;
837
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
838

    
839
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
840
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
841
                        enc->width, enc->height) < 0) {
842

    
843
                if (verbose >= 0)
844
                    fprintf(stderr, "pixel format conversion not handled\n");
845

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

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

    
871
            av_interleaved_write_frame(s, &pkt);
872
            enc->coded_frame = old_frame;
873
        } else {
874
            AVFrame big_picture;
875

    
876
            big_picture= *final_picture;
877
            /* better than nothing: use input picture interlaced
878
               settings */
879
            big_picture.interlaced_frame = in_picture->interlaced_frame;
880
            if(do_interlace_me || do_interlace_dct){
881
                if(top_field_first == -1)
882
                    big_picture.top_field_first = in_picture->top_field_first;
883
                else
884
                    big_picture.top_field_first = top_field_first;
885
            }
886

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

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

    
932
static double psnr(double d){
933
    if(d==0) return INFINITY;
934
    return -10.0*log(d)/log(10.0);
935
}
936

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

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

    
1010

    
1011
    oc = output_files[0];
1012

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

    
1070
        if (verbose > 1)
1071
          sprintf(buf + strlen(buf), " dup=%d drop=%d",
1072
                  nb_frames_dup, nb_frames_drop);
1073
        
1074
        if (verbose >= 0)
1075
            fprintf(stderr, "%s    \r", buf);
1076

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

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

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

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

    
1197
            buffer_to_free = NULL;
1198
            if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1199
                pre_process_video_frame(ist, (AVPicture *)&picture, 
1200
                                        &buffer_to_free);
1201
            }
1202

    
1203
            /* frame rate emulation */
1204
            if (ist->st->codec.rate_emu) {
1205
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1206
                int64_t now = av_gettime() - ist->start;
1207
                if (pts > now)
1208
                    usleep(pts - now);
1209

    
1210
                ist->frame++;
1211
            }
1212

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

    
1232
                    ost = ost_table[i];
1233
                    if (ost->source_index == ist_index) {
1234
                        os = output_files[ost->file_index];
1235

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

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

    
1264
                            /* no reencoding needed : output the packet directly */
1265
                            /* force the input stream PTS */
1266
                        
1267
                            avcodec_get_frame_defaults(&avframe);
1268
                            ost->st->codec.coded_frame= &avframe;
1269
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1270

    
1271
                            if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1272
                                audio_size += data_size;
1273
                            else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1274
                                video_size += data_size;
1275
                                ost->sync_opts++;
1276
                            }
1277

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

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

    
1354

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

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

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

    
1408
            if (ist->st->codec.rate_emu) {
1409
                ist->start = av_gettime();
1410
                ist->frame = 0;
1411
            }
1412
        }
1413
    }
1414

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

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

    
1503
    /* for each output stream, we compute the right encoding parameters */
1504
    for(i=0;i<nb_ostreams;i++) {
1505
        ost = ost_table[i];
1506
        ist = ist_table[ost->source_index];
1507

    
1508
        codec = &ost->st->codec;
1509
        icodec = &ist->st->codec;
1510

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

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

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

    
1685
    if (!bit_buffer)
1686
        bit_buffer = av_malloc(bit_buffer_size);
1687
    if (!bit_buffer)
1688
        goto fail;
1689

    
1690
    /* dump the file output parameters - cannot be done before in case
1691
       of stream copy */
1692
    for(i=0;i<nb_output_files;i++) {
1693
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1694
    }
1695

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

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

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

    
1750
    /* init pts */
1751
    for(i=0;i<nb_istreams;i++) {
1752
        ist = ist_table[i];
1753
        is = input_files[ist->file_index];
1754
        ist->pts = 0;
1755
        ist->next_pts = ist->st->start_time;
1756
        if(ist->next_pts == AV_NOPTS_VALUE) 
1757
            ist->next_pts=0;
1758
        ist->is_start = 1;
1759
    }
1760

    
1761
    /* compute buffer size max (should use a complete heuristic) */
1762
    for(i=0;i<nb_input_files;i++) {
1763
        file_table[i].buffer_size_max = 2048;
1764
    }
1765

    
1766
    /* set meta data information from input file if required */
1767
    for (i=0;i<nb_meta_data_maps;i++) {
1768
        AVFormatContext *out_file;
1769
        AVFormatContext *in_file;
1770

    
1771
        int out_file_index = meta_data_maps[i].out_file;
1772
        int in_file_index = meta_data_maps[i].in_file;
1773
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1774
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1775
            ret = -EINVAL;
1776
            goto fail;
1777
        }
1778
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1779
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1780
            ret = -EINVAL;
1781
            goto fail;
1782
        }                
1783
                 
1784
        out_file = output_files[out_file_index];
1785
        in_file = input_files[in_file_index];
1786

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

    
1807
#ifndef CONFIG_WIN32
1808
    if ( !using_stdin && verbose >= 0) {
1809
        fprintf(stderr, "Press [q] to stop encoding\n");
1810
        url_set_interrupt_cb(decode_interrupt_cb);
1811
    }
1812
#endif
1813
    term_init();
1814

    
1815
    stream_no_data = 0;
1816
    key = -1;
1817

    
1818
    for(; received_sigterm == 0;) {
1819
        int file_index, ist_index;
1820
        AVPacket pkt;
1821
        double ipts_min;
1822
        double opts_min;
1823

    
1824
    redo:
1825
        ipts_min= 1e100;
1826
        opts_min= 1e100;
1827
        /* if 'q' pressed, exits */
1828
        if (!using_stdin) {
1829
            if (q_pressed)
1830
                break;
1831
            /* read_key() returns 0 on EOF */
1832
            key = read_key();
1833
            if (key == 'q')
1834
                break;
1835
        }
1836

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

    
1870
        /* finish if recording time exhausted */
1871
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1872
            break;
1873

    
1874
        /* read a frame from it and output it in the fifo */
1875
        is = input_files[file_index];
1876
        if (av_read_frame(is, &pkt) < 0) {
1877
            file_table[file_index].eof_reached = 1;
1878
            continue;
1879
        }
1880

    
1881
        if (!pkt.size) {
1882
            stream_no_data = is;
1883
        } else {
1884
            stream_no_data = 0;
1885
        }
1886
        if (do_pkt_dump) {
1887
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1888
        }
1889
        /* the following test is needed in case new streams appear
1890
           dynamically in stream : we ignore them */
1891
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1892
            goto discard_packet;
1893
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1894
        ist = ist_table[ist_index];
1895
        if (ist->discard)
1896
            goto discard_packet;
1897

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

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

    
1916
            if (verbose >= 0)
1917
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1918
                        ist->file_index, ist->index);
1919

    
1920
            av_free_packet(&pkt);
1921
            goto redo;
1922
        }
1923
        
1924
    discard_packet:
1925
        av_free_packet(&pkt);
1926
        
1927
        /* dump report by using the output first video and audio streams */
1928
        print_report(output_files, ost_table, nb_ostreams, 0);
1929
    }
1930

    
1931
    /* at the end of stream, we must flush the decoder buffers */
1932
    for(i=0;i<nb_istreams;i++) {
1933
        ist = ist_table[i];
1934
        if (ist->decoding_needed) {
1935
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1936
        }
1937
    }
1938

    
1939
    term_exit();
1940

    
1941
    /* write the trailer if needed and close file */
1942
    for(i=0;i<nb_output_files;i++) {
1943
        os = output_files[i];
1944
        av_write_trailer(os);
1945
    }
1946

    
1947
    /* dump report by using the first video and audio streams */
1948
    print_report(output_files, ost_table, nb_ostreams, 1);
1949

    
1950
    /* close each encoder */
1951
    for(i=0;i<nb_ostreams;i++) {
1952
        ost = ost_table[i];
1953
        if (ost->encoding_needed) {
1954
            av_freep(&ost->st->codec.stats_in);
1955
            avcodec_close(&ost->st->codec);
1956
        }
1957
    }
1958
    
1959
    /* close each decoder */
1960
    for(i=0;i<nb_istreams;i++) {
1961
        ist = ist_table[i];
1962
        if (ist->decoding_needed) {
1963
            avcodec_close(&ist->st->codec);
1964
        }
1965
    }
1966

    
1967
    /* finished ! */
1968
    
1969
    ret = 0;
1970
 fail1:
1971
    av_free(file_table);
1972

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

    
2006
#if 0
2007
int file_read(const char *filename)
2008
{
2009
    URLContext *h;
2010
    unsigned char buffer[1024];
2011
    int len, i;
2012

2013
    if (url_open(&h, filename, O_RDONLY) < 0) {
2014
        printf("could not open '%s'\n", filename);
2015
        return -1;
2016
    }
2017
    for(;;) {
2018
        len = url_read(h, buffer, sizeof(buffer));
2019
        if (len <= 0)
2020
            break;
2021
        for(i=0;i<len;i++) putchar(buffer[i]);
2022
    }
2023
    url_close(h);
2024
    return 0;
2025
}
2026
#endif
2027

    
2028
static void opt_image_format(const char *arg)
2029
{
2030
    AVImageFormat *f;
2031
    
2032
    for(f = first_image_format; f != NULL; f = f->next) {
2033
        if (!strcmp(arg, f->name))
2034
            break;
2035
    }
2036
    if (!f) {
2037
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2038
        exit(1);
2039
    }
2040
    image_format = f;
2041
}
2042

    
2043
static void opt_format(const char *arg)
2044
{
2045
    /* compatibility stuff for pgmyuv */
2046
    if (!strcmp(arg, "pgmyuv")) {
2047
        pgmyuv_compatibility_hack=1;
2048
//        opt_image_format(arg);
2049
        arg = "image2";
2050
    }
2051

    
2052
    file_iformat = av_find_input_format(arg);
2053
    file_oformat = guess_format(arg, NULL, NULL);
2054
    if (!file_iformat && !file_oformat) {
2055
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2056
        exit(1);
2057
    }
2058
}
2059

    
2060
static void opt_video_bitrate(const char *arg)
2061
{
2062
    video_bit_rate = atoi(arg) * 1000;
2063
}
2064

    
2065
static void opt_video_bitrate_tolerance(const char *arg)
2066
{
2067
    video_bit_rate_tolerance = atoi(arg) * 1000;
2068
}
2069

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

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

    
2080
static void opt_video_buffer_size(const char *arg)
2081
{
2082
    video_rc_buffer_size = atoi(arg) * 8*1024;
2083
}
2084

    
2085
static void opt_video_rc_eq(char *arg)
2086
{
2087
    video_rc_eq = arg;
2088
}
2089

    
2090
static void opt_video_rc_override_string(char *arg)
2091
{
2092
    video_rc_override_string = arg;
2093
}
2094

    
2095

    
2096
static void opt_workaround_bugs(const char *arg)
2097
{
2098
    workaround_bugs = atoi(arg);
2099
}
2100

    
2101
static void opt_dct_algo(const char *arg)
2102
{
2103
    dct_algo = atoi(arg);
2104
}
2105

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

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

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

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

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

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

    
2136
static void opt_vismv(const char *arg)
2137
{
2138
    debug_mv = atoi(arg);
2139
}
2140
    
2141
static void opt_verbose(const char *arg)
2142
{
2143
    verbose = atoi(arg);
2144
    av_log_set_level(atoi(arg));
2145
}
2146

    
2147
static void opt_frame_rate(const char *arg)
2148
{
2149
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2150
        fprintf(stderr, "Incorrect frame rate\n");
2151
        exit(1);
2152
    }
2153
}
2154

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

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

    
2191
static void opt_frame_crop_left(const char *arg)
2192
{
2193
    frame_leftBand = atoi(arg);
2194
    if (frame_leftBand < 0) {
2195
        fprintf(stderr, "Incorrect left crop size\n");
2196
        exit(1);
2197
    }
2198
    if ((frame_leftBand % 2) != 0) {
2199
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2200
        exit(1);
2201
    }
2202
    if ((frame_leftBand) >= frame_width){
2203
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2204
        exit(1);
2205
    }
2206
    frame_width -= frame_leftBand;
2207
}
2208

    
2209
static void opt_frame_crop_right(const char *arg)
2210
{
2211
    frame_rightBand = atoi(arg);
2212
    if (frame_rightBand < 0) {
2213
        fprintf(stderr, "Incorrect right crop size\n");
2214
        exit(1);
2215
    }
2216
    if ((frame_rightBand % 2) != 0) {
2217
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2218
        exit(1);        
2219
    }
2220
    if ((frame_rightBand) >= frame_width){
2221
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2222
        exit(1);
2223
    }
2224
    frame_width -= frame_rightBand;
2225
}
2226

    
2227
static void opt_frame_size(const char *arg)
2228
{
2229
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2230
        fprintf(stderr, "Incorrect frame size\n");
2231
        exit(1);
2232
    }
2233
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2234
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2235
        exit(1);
2236
    }
2237
}
2238

    
2239

    
2240
#define SCALEBITS 10
2241
#define ONE_HALF  (1 << (SCALEBITS - 1))
2242
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
2243

    
2244
#define RGB_TO_Y(r, g, b) \
2245
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2246
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2247

    
2248
#define RGB_TO_U(r1, g1, b1, shift)\
2249
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2250
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2251

    
2252
#define RGB_TO_V(r1, g1, b1, shift)\
2253
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2254
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2255

    
2256
static void opt_pad_color(const char *arg) {
2257
    /* Input is expected to be six hex digits similar to
2258
       how colors are expressed in html tags (but without the #) */
2259
    int rgb = strtol(arg, NULL, 16);
2260
    int r,g,b;
2261
    
2262
    r = (rgb >> 16); 
2263
    g = ((rgb >> 8) & 255);
2264
    b = (rgb & 255);
2265

    
2266
    padcolor[0] = RGB_TO_Y(r,g,b);
2267
    padcolor[1] = RGB_TO_U(r,g,b,0);
2268
    padcolor[2] = RGB_TO_V(r,g,b,0);
2269
}
2270

    
2271
static void opt_frame_pad_top(const char *arg)
2272
{
2273
    frame_padtop = atoi(arg); 
2274
    if (frame_padtop < 0) {
2275
        fprintf(stderr, "Incorrect top pad size\n");
2276
        exit(1);
2277
    }
2278
    if ((frame_padtop % 2) != 0) {
2279
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2280
        exit(1);
2281
    }
2282
}
2283

    
2284
static void opt_frame_pad_bottom(const char *arg)
2285
{
2286
    frame_padbottom = atoi(arg); 
2287
    if (frame_padbottom < 0) {
2288
        fprintf(stderr, "Incorrect bottom pad size\n");
2289
        exit(1);
2290
    }
2291
    if ((frame_padbottom % 2) != 0) {
2292
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2293
        exit(1);
2294
    }
2295
}
2296

    
2297

    
2298
static void opt_frame_pad_left(const char *arg)
2299
{
2300
    frame_padleft = atoi(arg); 
2301
    if (frame_padleft < 0) {
2302
        fprintf(stderr, "Incorrect left pad size\n");
2303
        exit(1);
2304
    }
2305
    if ((frame_padleft % 2) != 0) {
2306
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2307
        exit(1);
2308
    }
2309
}
2310

    
2311

    
2312
static void opt_frame_pad_right(const char *arg)
2313
{
2314
    frame_padright = atoi(arg); 
2315
    if (frame_padright < 0) {
2316
        fprintf(stderr, "Incorrect right pad size\n");
2317
        exit(1);
2318
    }
2319
    if ((frame_padright % 2) != 0) {
2320
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2321
        exit(1);
2322
    }
2323
}
2324

    
2325

    
2326
static void opt_frame_pix_fmt(const char *arg)
2327
{
2328
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2329
}
2330

    
2331
static void opt_frame_aspect_ratio(const char *arg)
2332
{
2333
    int x = 0, y = 0;
2334
    double ar = 0;
2335
    const char *p;
2336
    
2337
    p = strchr(arg, ':');
2338
    if (p) {
2339
        x = strtol(arg, (char **)&arg, 10);
2340
        if (arg == p)
2341
            y = strtol(arg+1, (char **)&arg, 10);
2342
        if (x > 0 && y > 0)
2343
            ar = (double)x / (double)y;
2344
    } else
2345
        ar = strtod(arg, (char **)&arg);
2346

    
2347
    if (!ar) {
2348
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2349
        exit(1);
2350
    }
2351
    frame_aspect_ratio = ar;
2352
}
2353

    
2354
static void opt_gop_size(const char *arg)
2355
{
2356
    gop_size = atoi(arg);
2357
}
2358

    
2359
static void opt_b_frames(const char *arg)
2360
{
2361
    b_frames = atoi(arg);
2362
    if (b_frames > FF_MAX_B_FRAMES) {
2363
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2364
        exit(1);
2365
    } else if (b_frames < 1) {
2366
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2367
        exit(1);
2368
    }
2369
}
2370

    
2371
static void opt_mb_decision(const char *arg)
2372
{
2373
    mb_decision = atoi(arg);
2374
}
2375

    
2376
static void opt_mb_cmp(const char *arg)
2377
{
2378
    mb_cmp = atoi(arg);
2379
}
2380

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

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

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

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

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

    
2406
static void opt_lumi_mask(const char *arg)
2407
{
2408
    lumi_mask = atof(arg);
2409
}
2410

    
2411
static void opt_dark_mask(const char *arg)
2412
{
2413
    dark_mask = atof(arg);
2414
}
2415

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

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

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

    
2431
static void opt_qscale(const char *arg)
2432
{
2433
    video_qscale = atof(arg);
2434
    if (video_qscale < 0.01 ||
2435
        video_qscale > 255) {
2436
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2437
        exit(1);
2438
    }
2439
}
2440

    
2441
static void opt_lmax(const char *arg)
2442
{
2443
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2444
}
2445

    
2446
static void opt_lmin(const char *arg)
2447
{
2448
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2449
}
2450

    
2451
static void opt_qmin(const char *arg)
2452
{
2453
    video_qmin = atoi(arg);
2454
    if (video_qmin < 0 ||
2455
        video_qmin > 31) {
2456
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2457
        exit(1);
2458
    }
2459
}
2460

    
2461
static void opt_qmax(const char *arg)
2462
{
2463
    video_qmax = atoi(arg);
2464
    if (video_qmax < 0 ||
2465
        video_qmax > 31) {
2466
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2467
        exit(1);
2468
    }
2469
}
2470

    
2471
static void opt_mb_qmin(const char *arg)
2472
{
2473
    video_mb_qmin = atoi(arg);
2474
    if (video_mb_qmin < 0 ||
2475
        video_mb_qmin > 31) {
2476
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2477
        exit(1);
2478
    }
2479
}
2480

    
2481
static void opt_mb_qmax(const char *arg)
2482
{
2483
    video_mb_qmax = atoi(arg);
2484
    if (video_mb_qmax < 0 ||
2485
        video_mb_qmax > 31) {
2486
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2487
        exit(1);
2488
    }
2489
}
2490

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

    
2501
static void opt_qblur(const char *arg)
2502
{
2503
    video_qblur = atof(arg);
2504
}
2505

    
2506
static void opt_qcomp(const char *arg)
2507
{
2508
    video_qcomp = atof(arg);
2509
}
2510

    
2511
static void opt_rc_initial_cplx(const char *arg)
2512
{
2513
    video_rc_initial_cplx = atof(arg);
2514
}
2515
static void opt_b_qfactor(const char *arg)
2516
{
2517
    video_b_qfactor = atof(arg);
2518
}
2519
static void opt_i_qfactor(const char *arg)
2520
{
2521
    video_i_qfactor = atof(arg);
2522
}
2523
static void opt_b_qoffset(const char *arg)
2524
{
2525
    video_b_qoffset = atof(arg);
2526
}
2527
static void opt_i_qoffset(const char *arg)
2528
{
2529
    video_i_qoffset = atof(arg);
2530
}
2531

    
2532
static void opt_ibias(const char *arg)
2533
{
2534
    video_intra_quant_bias = atoi(arg);
2535
}
2536
static void opt_pbias(const char *arg)
2537
{
2538
    video_inter_quant_bias = atoi(arg);
2539
}
2540

    
2541
static void opt_packet_size(const char *arg)
2542
{
2543
    packet_size= atoi(arg);
2544
}
2545

    
2546
static void opt_error_rate(const char *arg)
2547
{
2548
    error_rate= atoi(arg);
2549
}
2550

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

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

    
2561
static void opt_noise_reduction(const char *arg)
2562
{
2563
    noise_reduction= atoi(arg);
2564
}
2565

    
2566
static void opt_qns(const char *arg)
2567
{
2568
    qns= atoi(arg);
2569
}
2570

    
2571
static void opt_sc_threshold(const char *arg)
2572
{
2573
    sc_threshold= atoi(arg);
2574
}
2575

    
2576
static void opt_me_range(const char *arg)
2577
{
2578
    me_range = atoi(arg);
2579
}
2580

    
2581
static void opt_thread_count(const char *arg)
2582
{
2583
    thread_count= atoi(arg);
2584
#if !defined(HAVE_THREADS)
2585
    if (verbose >= 0)
2586
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2587
#endif
2588
}
2589

    
2590
static void opt_audio_bitrate(const char *arg)
2591
{
2592
    audio_bit_rate = atoi(arg) * 1000;
2593
}
2594

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

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

    
2605
static void opt_video_device(const char *arg)
2606
{
2607
    video_device = av_strdup(arg);
2608
}
2609

    
2610
static void opt_grab_device(const char *arg)
2611
{
2612
    grab_device = av_strdup(arg);
2613
}
2614

    
2615
static void opt_video_channel(const char *arg)
2616
{
2617
    video_channel = strtol(arg, NULL, 0);
2618
}
2619

    
2620
static void opt_video_standard(const char *arg)
2621
{
2622
    video_standard = av_strdup(arg);
2623
}
2624

    
2625
static void opt_audio_device(const char *arg)
2626
{
2627
    audio_device = av_strdup(arg);
2628
}
2629

    
2630
static void opt_audio_codec(const char *arg)
2631
{
2632
    AVCodec *p;
2633

    
2634
    if (!strcmp(arg, "copy")) {
2635
        audio_stream_copy = 1;
2636
    } else {
2637
        p = first_avcodec;
2638
        while (p) {
2639
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2640
                break;
2641
            p = p->next;
2642
        }
2643
        if (p == NULL) {
2644
            fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2645
            exit(1);
2646
        } else {
2647
            audio_codec_id = p->id;
2648
        }
2649
    }
2650
}
2651

    
2652
static void opt_audio_tag(const char *arg)
2653
{
2654
    char *tail;
2655
    audio_codec_tag= strtol(arg, &tail, 0);
2656

    
2657
    if(!tail || *tail)
2658
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2659
}
2660

    
2661
static void opt_video_tag(const char *arg)
2662
{
2663
    char *tail;
2664
    video_codec_tag= strtol(arg, &tail, 0);
2665

    
2666
    if(!tail || *tail)
2667
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2668
}
2669

    
2670
static void add_frame_hooker(const char *arg)
2671
{
2672
    int argc = 0;
2673
    char *argv[64];
2674
    int i;
2675
    char *args = av_strdup(arg);
2676

    
2677
    using_vhook = 1;
2678

    
2679
    argv[0] = strtok(args, " ");
2680
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2681
    }
2682

    
2683
    i = frame_hook_add(argc, argv);
2684

    
2685
    if (i != 0) {
2686
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2687
        exit(1);
2688
    }
2689
}
2690

    
2691
const char *motion_str[] = {
2692
    "zero",
2693
    "full",
2694
    "log",
2695
    "phods",
2696
    "epzs",
2697
    "x1",
2698
    NULL,
2699
};
2700

    
2701
static void opt_motion_estimation(const char *arg)
2702
{
2703
    const char **p;
2704
    p = motion_str;
2705
    for(;;) {
2706
        if (!*p) {
2707
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2708
            exit(1);
2709
        }
2710
        if (!strcmp(*p, arg))
2711
            break;
2712
        p++;
2713
    }
2714
    me_method = (p - motion_str) + 1;
2715
}
2716

    
2717
static void opt_video_codec(const char *arg)
2718
{
2719
    AVCodec *p;
2720

    
2721
    if (!strcmp(arg, "copy")) {
2722
        video_stream_copy = 1;
2723
    } else {
2724
        p = first_avcodec;
2725
        while (p) {
2726
            if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2727
                break;
2728
            p = p->next;
2729
        }
2730
        if (p == NULL) {
2731
            fprintf(stderr, "Unknown video codec '%s'\n", arg);
2732
            exit(1);
2733
        } else {
2734
            video_codec_id = p->id;
2735
        }
2736
    }
2737
}
2738

    
2739
static void opt_map(const char *arg)
2740
{
2741
    AVStreamMap *m;
2742
    const char *p;
2743

    
2744
    p = arg;
2745
    m = &stream_maps[nb_stream_maps++];
2746

    
2747
    m->file_index = strtol(arg, (char **)&p, 0);
2748
    if (*p)
2749
        p++;
2750

    
2751
    m->stream_index = strtol(p, (char **)&p, 0);
2752
}
2753

    
2754
static void opt_map_meta_data(const char *arg)
2755
{
2756
    AVMetaDataMap *m;
2757
    const char *p;
2758
        
2759
    p = arg;
2760
    m = &meta_data_maps[nb_meta_data_maps++];
2761

    
2762
    m->out_file = strtol(arg, (char **)&p, 0);
2763
    if (*p)
2764
        p++;
2765

    
2766
    m->in_file = strtol(p, (char **)&p, 0);
2767
}
2768

    
2769
static void opt_recording_time(const char *arg)
2770
{
2771
    recording_time = parse_date(arg, 1);
2772
}
2773

    
2774
static void opt_start_time(const char *arg)
2775
{
2776
    start_time = parse_date(arg, 1);
2777
}
2778

    
2779
static void opt_rec_timestamp(const char *arg)
2780
{
2781
    rec_timestamp = parse_date(arg, 0) / 1000000;
2782
}
2783

    
2784
static void opt_input_ts_offset(const char *arg)
2785
{
2786
    input_ts_offset = parse_date(arg, 1);
2787
}
2788

    
2789
static void opt_input_file(const char *filename)
2790
{
2791
    AVFormatContext *ic;
2792
    AVFormatParameters params, *ap = &params;
2793
    int err, i, ret, rfps, rfps_base;
2794
    int64_t timestamp;
2795

    
2796
    if (!strcmp(filename, "-"))
2797
        filename = "pipe:";
2798

    
2799
    using_stdin |= !strncmp(filename, "pipe:", 5) || 
2800
                   !strcmp( filename, "/dev/stdin" );
2801

    
2802
    /* get default parameters from command line */
2803
    memset(ap, 0, sizeof(*ap));
2804
    ap->sample_rate = audio_sample_rate;
2805
    ap->channels = audio_channels;
2806
    ap->frame_rate = frame_rate;
2807
    ap->frame_rate_base = frame_rate_base;
2808
    ap->width = frame_width + frame_padleft + frame_padright;
2809
    ap->height = frame_height + frame_padtop + frame_padbottom;
2810
    ap->image_format = image_format;
2811
    ap->pix_fmt = frame_pix_fmt;
2812
    ap->device  = grab_device;
2813
    ap->channel = video_channel;
2814
    ap->standard = video_standard;
2815
    ap->video_codec_id = video_codec_id;
2816
    ap->audio_codec_id = audio_codec_id;
2817
    if(pgmyuv_compatibility_hack)
2818
        ap->video_codec_id= CODEC_ID_PGMYUV;
2819

    
2820
    /* open the input file with generic libav function */
2821
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2822
    if (err < 0) {
2823
        print_error(filename, err);
2824
        exit(1);
2825
    }
2826
    
2827
    /* If not enough info to get the stream parameters, we decode the
2828
       first frames to get it. (used in mpeg case for example) */
2829
    ret = av_find_stream_info(ic);
2830
    if (ret < 0 && verbose >= 0) {
2831
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2832
        exit(1);
2833
    }
2834

    
2835
    timestamp = start_time;
2836
    /* add the stream start time */
2837
    if (ic->start_time != AV_NOPTS_VALUE)
2838
        timestamp += ic->start_time;
2839

    
2840
    /* if seeking requested, we execute it */
2841
    if (start_time != 0) {
2842
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2843
        if (ret < 0) {
2844
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
2845
                    filename, (double)timestamp / AV_TIME_BASE);
2846
        }
2847
        /* reset seek info */
2848
        start_time = 0;
2849
    }
2850

    
2851
    /* update the current parameters so that they match the one of the input stream */
2852
    for(i=0;i<ic->nb_streams;i++) {
2853
        AVCodecContext *enc = &ic->streams[i]->codec;
2854
#if defined(HAVE_THREADS)
2855
        if(thread_count>1)
2856
            avcodec_thread_init(enc, thread_count);
2857
#endif
2858
        enc->thread_count= thread_count;
2859
        switch(enc->codec_type) {
2860
        case CODEC_TYPE_AUDIO:
2861
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2862
            audio_channels = enc->channels;
2863
            audio_sample_rate = enc->sample_rate;
2864
            break;
2865
        case CODEC_TYPE_VIDEO:
2866
            frame_height = enc->height;
2867
            frame_width = enc->width;
2868
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2869
            frame_pix_fmt = enc->pix_fmt;
2870
            rfps      = ic->streams[i]->r_frame_rate;
2871
            rfps_base = ic->streams[i]->r_frame_rate_base;
2872
            enc->workaround_bugs = workaround_bugs;
2873
            enc->error_resilience = error_resilience; 
2874
            enc->error_concealment = error_concealment; 
2875
            enc->idct_algo = idct_algo;
2876
            enc->debug = debug;
2877
            enc->debug_mv = debug_mv;            
2878
            enc->lowres= lowres;
2879
            if(bitexact)
2880
                enc->flags|= CODEC_FLAG_BITEXACT;
2881
            if(me_threshold)
2882
                enc->debug |= FF_DEBUG_MV;
2883

    
2884
            if (enc->frame_rate != rfps || enc->frame_rate_base != rfps_base) { 
2885

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

    
2890
                    (float)rfps / rfps_base, rfps, rfps_base);
2891
            }
2892
            /* update the current frame rate to match the stream frame rate */
2893
            frame_rate      = rfps;
2894
            frame_rate_base = rfps_base;
2895

    
2896
            enc->rate_emu = rate_emu;
2897
            break;
2898
        case CODEC_TYPE_DATA:
2899
            break;
2900
        default:
2901
            av_abort();
2902
        }
2903
    }
2904
    
2905
    input_files[nb_input_files] = ic;
2906
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2907
    /* dump the file content */
2908
    if (verbose >= 0)
2909
        dump_format(ic, nb_input_files, filename, 0);
2910

    
2911
    nb_input_files++;
2912
    file_iformat = NULL;
2913
    file_oformat = NULL;
2914
    image_format = NULL;
2915

    
2916
    grab_device = NULL;
2917
    video_channel = 0;
2918
    
2919
    rate_emu = 0;
2920
}
2921

    
2922
static void opt_grab(const char *arg)
2923
{
2924
    file_iformat = av_find_input_format(arg);
2925
    opt_input_file("");
2926
}
2927

    
2928
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2929
{
2930
    int has_video, has_audio, i, j;
2931
    AVFormatContext *ic;
2932

    
2933
    has_video = 0;
2934
    has_audio = 0;
2935
    for(j=0;j<nb_input_files;j++) {
2936
        ic = input_files[j];
2937
        for(i=0;i<ic->nb_streams;i++) {
2938
            AVCodecContext *enc = &ic->streams[i]->codec;
2939
            switch(enc->codec_type) {
2940
            case CODEC_TYPE_AUDIO:
2941
                has_audio = 1;
2942
                break;
2943
            case CODEC_TYPE_VIDEO:
2944
                has_video = 1;
2945
                break;
2946
            case CODEC_TYPE_DATA:
2947
                break;
2948
            default:
2949
                av_abort();
2950
            }
2951
        }
2952
    }
2953
    *has_video_ptr = has_video;
2954
    *has_audio_ptr = has_audio;
2955
}
2956

    
2957
static void opt_output_file(const char *filename)
2958
{
2959
    AVStream *st;
2960
    AVFormatContext *oc;
2961
    int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2962
    int codec_id;
2963
    AVFormatParameters params, *ap = &params;
2964

    
2965
    if (!strcmp(filename, "-"))
2966
        filename = "pipe:";
2967

    
2968
    oc = av_alloc_format_context();
2969

    
2970
    if (!file_oformat) {
2971
        file_oformat = guess_format(NULL, filename, NULL);
2972
        if (!file_oformat) {
2973
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2974
                    filename);
2975
            exit(1);
2976
        }
2977
    }
2978
    
2979
    oc->oformat = file_oformat;
2980

    
2981
    if (!strcmp(file_oformat->name, "ffm") && 
2982
        strstart(filename, "http:", NULL)) {
2983
        /* special case for files sent to ffserver: we get the stream
2984
           parameters from ffserver */
2985
        if (read_ffserver_streams(oc, filename) < 0) {
2986
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2987
            exit(1);
2988
        }
2989
    } else {
2990
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2991
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2992

    
2993
        /* disable if no corresponding type found and at least one
2994
           input file */
2995
        if (nb_input_files > 0) {
2996
            check_audio_video_inputs(&input_has_video, &input_has_audio);
2997
            if (!input_has_video)
2998
                use_video = 0;
2999
            if (!input_has_audio)
3000
                use_audio = 0;
3001
        }
3002

    
3003
        /* manual disable */
3004
        if (audio_disable) {
3005
            use_audio = 0;
3006
        }
3007
        if (video_disable) {
3008
            use_video = 0;
3009
        }
3010
        
3011
        nb_streams = 0;
3012
        if (use_video) {
3013
            AVCodecContext *video_enc;
3014
            
3015
            st = av_new_stream(oc, nb_streams++);
3016
            if (!st) {
3017
                fprintf(stderr, "Could not alloc stream\n");
3018
                exit(1);
3019
            }
3020
#if defined(HAVE_THREADS)
3021
            if(thread_count>1)
3022
                avcodec_thread_init(&st->codec, thread_count);
3023
#endif
3024

    
3025
            video_enc = &st->codec;
3026
            
3027
            if(video_codec_tag)
3028
                video_enc->codec_tag= video_codec_tag;
3029
                
3030
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3031
                video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3032
            if (video_stream_copy) {
3033
                st->stream_copy = 1;
3034
                video_enc->codec_type = CODEC_TYPE_VIDEO;
3035
            } else {
3036
                char *p;
3037
                int i;
3038
                AVCodec *codec;
3039
            
3040
                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
3041
                if (video_codec_id != CODEC_ID_NONE)
3042
                    codec_id = video_codec_id;
3043
                
3044
                video_enc->codec_id = codec_id;
3045
                codec = avcodec_find_encoder(codec_id);
3046
                
3047
                video_enc->bit_rate = video_bit_rate;
3048
                video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3049
                video_enc->frame_rate = frame_rate; 
3050
                video_enc->frame_rate_base = frame_rate_base; 
3051
                if(codec && codec->supported_framerates){
3052
                    const AVRational *p= codec->supported_framerates;
3053
                    AVRational req= (AVRational){frame_rate, frame_rate_base};
3054
                    const AVRational *best=NULL;
3055
                    AVRational best_error= (AVRational){INT_MAX, 1};
3056
                    for(; p->den!=0; p++){
3057
                        AVRational error= av_sub_q(req, *p);
3058
                        if(error.num <0) error.num *= -1;
3059
                        if(av_cmp_q(error, best_error) < 0){
3060
                            best_error= error;
3061
                            best= p;
3062
                        }
3063
                    }
3064
                    video_enc->frame_rate     = best->num;
3065
                    video_enc->frame_rate_base= best->den;
3066
                }
3067
                
3068
                video_enc->width = frame_width + frame_padright + frame_padleft;
3069
                video_enc->height = frame_height + frame_padtop + frame_padbottom;
3070
                video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3071
                video_enc->pix_fmt = frame_pix_fmt;
3072

    
3073
                if(codec && codec->pix_fmts){
3074
                    const enum PixelFormat *p= codec->pix_fmts;
3075
                    for(; *p!=-1; p++){
3076
                        if(*p == video_enc->pix_fmt)
3077
                            break;
3078
                    }
3079
                    if(*p == -1)
3080
                        video_enc->pix_fmt = codec->pix_fmts[0];
3081
                }
3082

    
3083
                if (!intra_only)
3084
                    video_enc->gop_size = gop_size;
3085
                else
3086
                    video_enc->gop_size = 0;
3087
                if (video_qscale || same_quality) {
3088
                    video_enc->flags |= CODEC_FLAG_QSCALE;
3089
                    st->quality = FF_QP2LAMBDA * video_qscale;
3090
                }
3091

    
3092
                if(intra_matrix)
3093
                    video_enc->intra_matrix = intra_matrix;
3094
                if(inter_matrix)
3095
                    video_enc->inter_matrix = inter_matrix;
3096

    
3097
                if(bitexact)
3098
                    video_enc->flags |= CODEC_FLAG_BITEXACT;
3099

    
3100
                video_enc->mb_decision = mb_decision;
3101
                video_enc->mb_cmp = mb_cmp;
3102
                video_enc->ildct_cmp = ildct_cmp;
3103
                video_enc->me_sub_cmp = sub_cmp;
3104
                video_enc->me_cmp = cmp;
3105
                video_enc->me_pre_cmp = pre_cmp;
3106
                video_enc->pre_me = pre_me;
3107
                video_enc->lumi_masking = lumi_mask;
3108
                video_enc->dark_masking = dark_mask;
3109
                video_enc->spatial_cplx_masking = scplx_mask;
3110
                video_enc->temporal_cplx_masking = tcplx_mask;
3111
                video_enc->p_masking = p_mask;
3112
                video_enc->quantizer_noise_shaping= qns;
3113
                
3114
                if (use_umv) {
3115
                    video_enc->flags |= CODEC_FLAG_H263P_UMV;
3116
                }
3117
                if (use_ss) {
3118
                    video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3119
                }
3120
                   if (use_aic) {
3121
                    video_enc->flags |= CODEC_FLAG_H263P_AIC;
3122
                }
3123
                   if (use_aiv) {
3124
                    video_enc->flags |= CODEC_FLAG_H263P_AIV;
3125
                }
3126
                if (use_4mv) {
3127
                    video_enc->flags |= CODEC_FLAG_4MV;
3128
                }
3129
                if (use_obmc) {
3130
                    video_enc->flags |= CODEC_FLAG_OBMC;
3131
                }
3132
                if (use_loop) {
3133
                    video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3134
                }
3135
            
3136
                if(use_part) {
3137
                    video_enc->flags |= CODEC_FLAG_PART;
3138
                }
3139
                   if (use_alt_scan) {
3140
                    video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3141
                }
3142
                   if (use_trell) {
3143
                    video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3144
                }
3145
                   if (use_scan_offset) {
3146
                    video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3147
                }
3148
                   if (closed_gop) {
3149
                    video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3150
                }
3151
                if (strict_gop) {
3152
                    video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3153
                }
3154
                   if (use_qpel) {
3155
                    video_enc->flags |= CODEC_FLAG_QPEL;
3156
                }
3157
                   if (use_qprd) {
3158
                    video_enc->flags |= CODEC_FLAG_QP_RD;
3159
                }
3160
                   if (use_cbprd) {
3161
                    video_enc->flags |= CODEC_FLAG_CBP_RD;
3162
                }
3163
                if (b_frames) {
3164
                    video_enc->max_b_frames = b_frames;
3165
                    video_enc->b_frame_strategy = 0;
3166
                    video_enc->b_quant_factor = 2.0;
3167
                }
3168
                if (do_interlace_dct) {
3169
                    video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3170
                }
3171
                if (do_interlace_me) {
3172
                    video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3173
                }
3174
                video_enc->qmin = video_qmin;
3175
                video_enc->qmax = video_qmax;
3176
                video_enc->lmin = video_lmin;
3177
                video_enc->lmax = video_lmax;
3178
                video_enc->mb_qmin = video_mb_qmin;
3179
                video_enc->mb_qmax = video_mb_qmax;
3180
                video_enc->max_qdiff = video_qdiff;
3181
                video_enc->qblur = video_qblur;
3182
                video_enc->qcompress = video_qcomp;
3183
                video_enc->rc_eq = video_rc_eq;
3184
                video_enc->debug = debug;
3185
                video_enc->debug_mv = debug_mv;
3186
                video_enc->thread_count = thread_count;
3187
                p= video_rc_override_string;
3188
                for(i=0; p; i++){
3189
                    int start, end, q;
3190
                    int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3191
                    if(e!=3){
3192
                        fprintf(stderr, "error parsing rc_override\n");
3193
                        exit(1);
3194
                    }
3195
                    video_enc->rc_override= 
3196
                        av_realloc(video_enc->rc_override, 
3197
                                   sizeof(RcOverride)*(i+1));
3198
                    video_enc->rc_override[i].start_frame= start;
3199
                    video_enc->rc_override[i].end_frame  = end;
3200
                    if(q>0){
3201
                        video_enc->rc_override[i].qscale= q;
3202
                        video_enc->rc_override[i].quality_factor= 1.0;
3203
                    }
3204
                    else{
3205
                        video_enc->rc_override[i].qscale= 0;
3206
                        video_enc->rc_override[i].quality_factor= -q/100.0;
3207
                    }
3208
                    p= strchr(p, '/');
3209
                    if(p) p++;
3210
                }
3211
                video_enc->rc_override_count=i;
3212

    
3213
                video_enc->rc_max_rate = video_rc_max_rate;
3214
                video_enc->rc_min_rate = video_rc_min_rate;
3215
                video_enc->rc_buffer_size = video_rc_buffer_size;
3216
                video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3217
                video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3218
                video_enc->rc_initial_cplx= video_rc_initial_cplx;
3219
                video_enc->i_quant_factor = video_i_qfactor;
3220
                video_enc->b_quant_factor = video_b_qfactor;
3221
                video_enc->i_quant_offset = video_i_qoffset;
3222
                video_enc->b_quant_offset = video_b_qoffset;
3223
                video_enc->intra_quant_bias = video_intra_quant_bias;
3224
                video_enc->inter_quant_bias = video_inter_quant_bias;
3225
                video_enc->dct_algo = dct_algo;
3226
                video_enc->idct_algo = idct_algo;
3227
                video_enc->me_threshold= me_threshold;
3228
                video_enc->mb_threshold= mb_threshold;
3229
                video_enc->intra_dc_precision= intra_dc_precision - 8;
3230
                video_enc->strict_std_compliance = strict;
3231
                video_enc->error_rate = error_rate;
3232
                video_enc->noise_reduction= noise_reduction;
3233
                video_enc->scenechange_threshold= sc_threshold;
3234
                video_enc->me_range = me_range;
3235
                video_enc->coder_type= coder;
3236
                video_enc->context_model= context;
3237
                video_enc->prediction_method= predictor;
3238
                video_enc->profile= video_profile;
3239
                video_enc->level= video_level;
3240
                video_enc->nsse_weight= nsse_weight;
3241
                video_enc->me_subpel_quality= subpel_quality;
3242
                video_enc->frame_skip_threshold= frame_skip_threshold;
3243
                video_enc->frame_skip_factor= frame_skip_factor;
3244
                video_enc->frame_skip_exp= frame_skip_exp;
3245
                video_enc->frame_skip_cmp= frame_skip_cmp;
3246

    
3247
                if(packet_size){
3248
                    video_enc->rtp_mode= 1;
3249
                    video_enc->rtp_payload_size= packet_size;
3250
                }
3251
            
3252
                if (do_psnr)
3253
                    video_enc->flags|= CODEC_FLAG_PSNR;
3254
            
3255
                video_enc->me_method = me_method;
3256

    
3257
                /* two pass mode */
3258
                if (do_pass) {
3259
                    if (do_pass == 1) {
3260
                        video_enc->flags |= CODEC_FLAG_PASS1;
3261
                    } else {
3262
                        video_enc->flags |= CODEC_FLAG_PASS2;
3263
                    }
3264
                }
3265
            }
3266
        }
3267
    
3268
        if (use_audio) {
3269
            AVCodecContext *audio_enc;
3270

    
3271
            st = av_new_stream(oc, nb_streams++);
3272
            if (!st) {
3273
                fprintf(stderr, "Could not alloc stream\n");
3274
                exit(1);
3275
            }
3276
#if defined(HAVE_THREADS)
3277
            if(thread_count>1)
3278
                avcodec_thread_init(&st->codec, thread_count);
3279
#endif
3280

    
3281
            audio_enc = &st->codec;
3282
            audio_enc->codec_type = CODEC_TYPE_AUDIO;
3283

    
3284
            if(audio_codec_tag)
3285
                audio_enc->codec_tag= audio_codec_tag;
3286

    
3287
            if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3288
                audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3289
            if (audio_stream_copy) {
3290
                st->stream_copy = 1;
3291
                audio_enc->channels = audio_channels;
3292
            } else {
3293
                codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
3294
                if (audio_codec_id != CODEC_ID_NONE)
3295
                    codec_id = audio_codec_id;
3296
                audio_enc->codec_id = codec_id;
3297
                
3298
                audio_enc->bit_rate = audio_bit_rate;
3299
                audio_enc->strict_std_compliance = strict;
3300
                audio_enc->thread_count = thread_count;
3301
                /* For audio codecs other than AC3 or DTS we limit */
3302
                /* the number of coded channels to stereo   */
3303
                if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3304
                    && codec_id != CODEC_ID_DTS) {
3305
                    audio_enc->channels = 2;
3306
                } else
3307
                    audio_enc->channels = audio_channels;
3308
            }
3309
            audio_enc->sample_rate = audio_sample_rate;
3310
        }
3311

    
3312
        oc->nb_streams = nb_streams;
3313

    
3314
        if (!nb_streams) {
3315
            fprintf(stderr, "No audio or video streams available\n");
3316
            exit(1);
3317
        }
3318

    
3319
        oc->timestamp = rec_timestamp;
3320
            
3321
        if (str_title)
3322
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3323
        if (str_author)
3324
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3325
        if (str_copyright)
3326
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3327
        if (str_comment)
3328
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3329
    }
3330

    
3331
    output_files[nb_output_files++] = oc;
3332

    
3333
    strcpy(oc->filename, filename);
3334

    
3335
    /* check filename in case of an image number is expected */
3336
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3337
        if (filename_number_test(oc->filename) < 0) {
3338
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3339
            exit(1);
3340
        }
3341
    }
3342

    
3343
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3344
        /* test if it already exists to avoid loosing precious files */
3345
        if (!file_overwrite && 
3346
            (strchr(filename, ':') == NULL ||
3347
             strstart(filename, "file:", NULL))) {
3348
            if (url_exist(filename)) {
3349
                int c;
3350
                
3351
                if ( !using_stdin ) {
3352
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3353
                    fflush(stderr);
3354
                    c = getchar();
3355
                    if (toupper(c) != 'Y') {
3356
                        fprintf(stderr, "Not overwriting - exiting\n");
3357
                        exit(1);
3358
                    }
3359
                                }
3360
                                else {
3361
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3362
                    exit(1);
3363
                                }
3364
            }
3365
        }
3366
        
3367
        /* open the file */
3368
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3369
            fprintf(stderr, "Could not open '%s'\n", filename);
3370
            exit(1);
3371
        }
3372
    }
3373

    
3374
    memset(ap, 0, sizeof(*ap));
3375
    ap->image_format = image_format;
3376
    if (av_set_parameters(oc, ap) < 0) {
3377
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3378
                oc->filename);
3379
        exit(1);
3380
    }
3381

    
3382
    oc->packet_size= mux_packet_size;
3383
    oc->mux_rate= mux_rate;
3384
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3385
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3386

    
3387
    /* reset some options */
3388
    file_oformat = NULL;
3389
    file_iformat = NULL;
3390
    image_format = NULL;
3391
    audio_disable = 0;
3392
    video_disable = 0;
3393
    audio_codec_id = CODEC_ID_NONE;
3394
    video_codec_id = CODEC_ID_NONE;
3395
    audio_stream_copy = 0;
3396
    video_stream_copy = 0;
3397
}
3398

    
3399
/* prepare dummy protocols for grab */
3400
static void prepare_grab(void)
3401
{
3402
    int has_video, has_audio, i, j;
3403
    AVFormatContext *oc;
3404
    AVFormatContext *ic;
3405
    AVFormatParameters vp1, *vp = &vp1;
3406
    AVFormatParameters ap1, *ap = &ap1;
3407
    
3408
    /* see if audio/video inputs are needed */
3409
    has_video = 0;
3410
    has_audio = 0;
3411
    memset(ap, 0, sizeof(*ap));
3412
    memset(vp, 0, sizeof(*vp));
3413
    vp->frame_rate_base= 1;
3414
    for(j=0;j<nb_output_files;j++) {
3415
        oc = output_files[j];
3416
        for(i=0;i<oc->nb_streams;i++) {
3417
            AVCodecContext *enc = &oc->streams[i]->codec;
3418
            switch(enc->codec_type) {
3419
            case CODEC_TYPE_AUDIO:
3420
                if (enc->sample_rate > ap->sample_rate)
3421
                    ap->sample_rate = enc->sample_rate;
3422
                if (enc->channels > ap->channels)
3423
                    ap->channels = enc->channels;
3424
                has_audio = 1;
3425
                break;
3426
            case CODEC_TYPE_VIDEO:
3427
                if (enc->width > vp->width)
3428
                    vp->width = enc->width;
3429
                if (enc->height > vp->height)
3430
                    vp->height = enc->height;
3431
                
3432
                if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3433
                    vp->frame_rate      = enc->frame_rate;
3434
                    vp->frame_rate_base = enc->frame_rate_base;
3435
                }
3436
                has_video = 1;
3437
                break;
3438
            default:
3439
                av_abort();
3440
            }
3441
        }
3442
    }
3443
    
3444
    if (has_video == 0 && has_audio == 0) {
3445
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3446
        exit(1);
3447
    }
3448
    
3449
    if (has_video) {
3450
        AVInputFormat *fmt1;
3451
        fmt1 = av_find_input_format(video_grab_format);
3452
        vp->device  = video_device;
3453
        vp->channel = video_channel;
3454
        vp->standard = video_standard;
3455
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3456
            fprintf(stderr, "Could not find video grab device\n");
3457
            exit(1);
3458
        }
3459
        /* If not enough info to get the stream parameters, we decode the
3460
           first frames to get it. */
3461
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3462
            fprintf(stderr, "Could not find video grab parameters\n");
3463
            exit(1);
3464
        }
3465
        /* by now video grab has one stream */
3466
        ic->streams[0]->r_frame_rate      = vp->frame_rate;
3467
        ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3468
        input_files[nb_input_files] = ic;
3469

    
3470
        if (verbose >= 0)
3471
            dump_format(ic, nb_input_files, "", 0);
3472

    
3473
        nb_input_files++;
3474
    }
3475
    if (has_audio && audio_grab_format) {
3476
        AVInputFormat *fmt1;
3477
        fmt1 = av_find_input_format(audio_grab_format);
3478
        ap->device = audio_device;
3479
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3480
            fprintf(stderr, "Could not find audio grab device\n");
3481
            exit(1);
3482
        }
3483
        input_files[nb_input_files] = ic;
3484

    
3485
        if (verbose >= 0)
3486
            dump_format(ic, nb_input_files, "", 0);
3487

    
3488
        nb_input_files++;
3489
    }
3490
}
3491

    
3492
/* same option as mencoder */
3493
static void opt_pass(const char *pass_str)
3494
{
3495
    int pass;
3496
    pass = atoi(pass_str);
3497
    if (pass != 1 && pass != 2) {
3498
        fprintf(stderr, "pass number can be only 1 or 2\n");
3499
        exit(1);
3500
    }
3501
    do_pass = pass;
3502
}
3503

    
3504
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3505
static int64_t getutime(void)
3506
{
3507
  return av_gettime();
3508
}
3509
#else
3510
static int64_t getutime(void)
3511
{
3512
    struct rusage rusage;
3513

    
3514
    getrusage(RUSAGE_SELF, &rusage);
3515
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3516
}
3517
#endif
3518

    
3519
extern int ffm_nopts;
3520

    
3521
static void opt_bitexact(void)
3522
{
3523
    bitexact=1;
3524
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3525
    ffm_nopts = 1;
3526
}
3527

    
3528
static void show_formats(void)
3529
{
3530
    AVInputFormat *ifmt;
3531
    AVOutputFormat *ofmt;
3532
    AVImageFormat *image_fmt;
3533
    URLProtocol *up;
3534
    AVCodec *p, *p2;
3535
    const char **pp, *last_name;
3536

    
3537
    printf("File formats:\n");
3538
    last_name= "000";
3539
    for(;;){
3540
        int decode=0;
3541
        int encode=0;
3542
        const char *name=NULL;
3543
        const char *long_name=NULL;
3544

    
3545
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3546
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3547
                strcmp(ofmt->name, last_name)>0){
3548
                name= ofmt->name;
3549
                long_name= ofmt->long_name;
3550
                encode=1;
3551
            }
3552
        }
3553
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3554
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3555
                strcmp(ifmt->name, last_name)>0){
3556
                name= ifmt->name;
3557
                long_name= ifmt->long_name;
3558
                encode=0;
3559
            }
3560
            if(name && strcmp(ifmt->name, name)==0)
3561
                decode=1;
3562
        }
3563
        if(name==NULL)
3564
            break;
3565
        last_name= name;
3566
        
3567
        printf(
3568
            " %s%s %-15s %s\n", 
3569
            decode ? "D":" ", 
3570
            encode ? "E":" ", 
3571
            name,
3572
            long_name ? long_name:" ");
3573
    }
3574
    printf("\n");
3575

    
3576
    printf("Image formats (filename extensions, if any, follow):\n");
3577
    for(image_fmt = first_image_format; image_fmt != NULL; 
3578
        image_fmt = image_fmt->next) {
3579
        printf(
3580
            " %s%s %-6s %s\n",
3581
            image_fmt->img_read  ? "D":" ",
3582
            image_fmt->img_write ? "E":" ",
3583
            image_fmt->name,
3584
            image_fmt->extensions ? image_fmt->extensions:" ");
3585
    }
3586
    printf("\n");
3587

    
3588
    printf("Codecs:\n");
3589
    last_name= "000";
3590
    for(;;){
3591
        int decode=0;
3592
        int encode=0;
3593
        int cap=0;
3594

    
3595
        p2=NULL;
3596
        for(p = first_avcodec; p != NULL; p = p->next) {
3597
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3598
                strcmp(p->name, last_name)>0){
3599
                p2= p;
3600
                decode= encode= cap=0;
3601
            }
3602
            if(p2 && strcmp(p->name, p2->name)==0){
3603
                if(p->decode) decode=1;
3604
                if(p->encode) encode=1;
3605
                cap |= p->capabilities;
3606
            }
3607
        }
3608
        if(p2==NULL)
3609
            break;
3610
        last_name= p2->name;
3611
        
3612
        printf(
3613
            " %s%s%s%s%s%s %s", 
3614
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
3615
            encode ? "E":" ", 
3616
            p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3617
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3618
            cap & CODEC_CAP_DR1 ? "D":" ",
3619
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3620
            p2->name);
3621
       /* if(p2->decoder && decode==0)
3622
            printf(" use %s for decoding", p2->decoder->name);*/
3623
        printf("\n");
3624
    }
3625
    printf("\n");
3626

    
3627
    printf("Supported file protocols:\n");
3628
    for(up = first_protocol; up != NULL; up = up->next)
3629
        printf(" %s:", up->name);
3630
    printf("\n");
3631
    
3632
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3633
    printf("Motion estimation methods:\n");
3634
    pp = motion_str;
3635
    while (*pp) {
3636
        printf(" %s", *pp);
3637
        if ((pp - motion_str + 1) == ME_ZERO) 
3638
            printf("(fastest)");
3639
        else if ((pp - motion_str + 1) == ME_FULL) 
3640
            printf("(slowest)");
3641
        else if ((pp - motion_str + 1) == ME_EPZS) 
3642
            printf("(default)");
3643
        pp++;
3644
    }
3645
    printf("\n\n");
3646
    printf(
3647
"Note, the names of encoders and decoders dont always match, so there are\n"
3648
"several cases where the above table shows encoder only or decoder only entries\n"
3649
"even though both encoding and decoding are supported for example, the h263\n"
3650
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3651
"worse\n");
3652
    exit(1);
3653
}
3654

    
3655
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3656
{
3657
    int i;
3658
    const char *p = str;
3659
    for(i = 0;; i++) {
3660
        dest[i] = atoi(p);
3661
        if(i == 63)
3662
            break;
3663
        p = strchr(p, ',');
3664
        if(!p) {
3665
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3666
            exit(1);
3667
        }
3668
        p++;
3669
    }
3670
}
3671

    
3672
void opt_inter_matrix(const char *arg)
3673
{
3674
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3675
    parse_matrix_coeffs(inter_matrix, arg);
3676
}
3677

    
3678
void opt_intra_matrix(const char *arg)
3679
{
3680
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3681
    parse_matrix_coeffs(intra_matrix, arg);
3682
}
3683

    
3684
static void opt_target(const char *arg)
3685
{
3686
    int norm = -1;
3687

    
3688
    if(!strncmp(arg, "pal-", 4)) {
3689
        norm = 0;
3690
        arg += 4;
3691
    } else if(!strncmp(arg, "ntsc-", 5)) {
3692
        norm = 1;
3693
        arg += 5;
3694
    } else {
3695
        int fr;
3696
        /* Calculate FR via float to avoid int overflow */
3697
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3698
        if(fr == 25000) {
3699
            norm = 0;
3700
        } else if((fr == 29970) || (fr == 23976)) {
3701
            norm = 1;
3702
        } else {
3703
            /* Try to determine PAL/NTSC by peeking in the input files */
3704
            if(nb_input_files) {
3705
                int i, j;
3706
                for(j = 0; j < nb_input_files; j++) {
3707
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3708
                        AVCodecContext *c = &input_files[j]->streams[i]->codec;
3709
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3710
                            continue;
3711
                        fr = c->frame_rate * 1000 / c->frame_rate_base;
3712
                        if(fr == 25000) {
3713
                            norm = 0;
3714
                            break;
3715
                        } else if((fr == 29970) || (fr == 23976)) {
3716
                            norm = 1;
3717
                            break;
3718
                        }
3719
                    }
3720
                    if(norm >= 0)
3721
                        break;
3722
                }
3723
            }
3724
        }
3725
        if(verbose && norm >= 0)
3726
            printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3727
    }
3728

    
3729
    if(norm < 0) {
3730
        fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3731
        fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3732
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3733
        exit(1);
3734
    }
3735

    
3736
    if(!strcmp(arg, "vcd")) {
3737

    
3738
        opt_video_codec("mpeg1video");
3739
        opt_audio_codec("mp2");
3740
        opt_format("vcd");
3741

    
3742
        opt_frame_size(norm ? "352x240" : "352x288");
3743

    
3744
        video_bit_rate = 1150000;
3745
        video_rc_max_rate = 1150000;
3746
        video_rc_min_rate = 1150000;
3747
        video_rc_buffer_size = 40*1024*8;
3748

    
3749
        audio_bit_rate = 224000;
3750
        audio_sample_rate = 44100;
3751
        
3752
        mux_packet_size= 2324;
3753
        mux_rate= 2352 * 75 * 8;
3754

    
3755
        /* We have to offset the PTS, so that it is consistent with the SCR.
3756
           SCR starts at 36000, but the first two packs contain only padding
3757
           and the first pack from the other stream, respectively, may also have
3758
           been written before.
3759
           So the real data starts at SCR 36000+3*1200. */
3760
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3761
    } else if(!strcmp(arg, "svcd")) {
3762

    
3763
        opt_video_codec("mpeg2video");
3764
        opt_audio_codec("mp2");
3765
        opt_format("svcd");
3766

    
3767
        opt_frame_size(norm ? "480x480" : "480x576");
3768
        opt_gop_size(norm ? "18" : "15");
3769

    
3770
        video_bit_rate = 2040000;
3771
        video_rc_max_rate = 2516000;
3772
        video_rc_min_rate = 0; //1145000;
3773
        video_rc_buffer_size = 224*1024*8;
3774
        use_scan_offset = 1;
3775

    
3776
        audio_bit_rate = 224000;
3777
        audio_sample_rate = 44100;
3778

    
3779
        mux_packet_size= 2324;
3780

    
3781
    } else if(!strcmp(arg, "dvd")) {
3782

    
3783
        opt_video_codec("mpeg2video");
3784
        opt_audio_codec("ac3");
3785
        opt_format("dvd");
3786

    
3787
        opt_frame_size(norm ? "720x480" : "720x576");
3788
        opt_gop_size(norm ? "18" : "15");
3789

    
3790
        video_bit_rate = 6000000;
3791
        video_rc_max_rate = 9000000;
3792
        video_rc_min_rate = 0; //1500000;
3793
        video_rc_buffer_size = 224*1024*8;
3794

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

    
3798
        audio_bit_rate = 448000;
3799
        audio_sample_rate = 48000;
3800

    
3801
    } else {
3802
        fprintf(stderr, "Unknown target: %s\n", arg);
3803
        exit(1);
3804
    }
3805
}
3806

    
3807
static void show_version(void)
3808
{
3809
    printf("ffmpeg      " FFMPEG_VERSION "\n"
3810
           "libavcodec  %d\n"
3811
           "libavformat %d\n", 
3812
           avcodec_build(), LIBAVFORMAT_BUILD);
3813
    exit(1);
3814
}
3815

    
3816
const OptionDef options[] = {
3817
    /* main options */
3818
    { "L", 0, {(void*)show_license}, "show license" },
3819
    { "h", 0, {(void*)show_help}, "show help" },
3820
    { "version", 0, {(void*)show_version}, "show version" },
3821
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3822
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3823
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3824
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3825
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3826
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3827
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3828
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3829
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3830
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3831
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3832
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3833
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3834
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3835
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3836
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3837
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3838
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
3839
      "add timings for benchmarking" },
3840
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
3841
      "dump each input packet" },
3842
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
3843
      "when dumping packets, also dump the payload" },
3844
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
3845
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3846
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3847
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3848
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3849
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3850
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3851
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3852
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3853

    
3854
    /* video options */
3855
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3856
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3857
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3858
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3859
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3860
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3861
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3862
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3863
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3864
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3865
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3866
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3867
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3868
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3869
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3870
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3871
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3872
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3873
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3874
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3875
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3876
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3877
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3878
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3879
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3880
    { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3881
    { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3882
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3883
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3884
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3885
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3886
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3887
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3888
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3889
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3890
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3891
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3892
//    { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3893
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3894
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3895
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3896
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3897
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3898
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3899
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3900
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
3901
      "method" },
3902
    { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
3903
    { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
3904
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3905
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3906
    { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
3907
    { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
3908
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3909
    { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3910
    { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3911
    { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3912
    { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3913
    { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3914
    { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3915
    { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3916
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3917
    { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3918
    { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3919
    { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3920
    { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3921
    { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3922
    { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3923
    { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3924
    { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3925
    { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3926
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3927
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3928
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3929
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3930
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
3931
      "use same video quality as source (implies VBR)" },
3932
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3933
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3934
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
3935
      "deinterlace pictures" },
3936
    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 
3937
      "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3938
    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 
3939
      "force interlaced me support in encoder (MPEG2/MPEG4)" },
3940
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3941
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
3942
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3943
    { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3944
    { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3945
    { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3946
    { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3947
    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3948
    { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3949
    { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3950
    { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3951
    { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3952
    { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
3953
    { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3954
    { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3955
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3956
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3957
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3958
    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3959
    { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3960
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3961
    { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3962
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3963
    { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3964
    { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3965
    { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3966
    { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
3967
    { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
3968
    { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
3969
    { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
3970
    { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
3971
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3972
    { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3973
    { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3974
    { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3975
    { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
3976

    
3977
    /* audio options */
3978
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3979
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3980
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3981
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3982
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3983
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3984

    
3985
    /* grab options */
3986
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3987
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3988
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3989
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3990

    
3991
    /* G.2 grab options */ 
3992
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3993
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3994
 
3995
    /* muxer options */   
3996
    { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
3997
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
3998
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3999
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4000
    { NULL, },
4001
};
4002

    
4003
static void show_banner(void)
4004
{
4005
    printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4006
        LIBAVCODEC_BUILD);
4007
    printf("  configuration: %s\n", FFMPEG_CONFIGURATION);
4008
    printf("  built on " __DATE__ " " __TIME__);
4009
#ifdef __GNUC__
4010
    printf(", gcc: %s\n", __VERSION__);
4011
#else
4012
    printf(", using a non-gcc compiler\n");
4013
#endif
4014
}
4015

    
4016
static void show_license(void)
4017
{
4018
    show_banner();
4019
#ifdef CONFIG_GPL
4020
    printf(
4021
    "This program is free software; you can redistribute it and/or modify\n"   
4022
    "it under the terms of the GNU General Public License as published by\n"
4023
    "the Free Software Foundation; either version 2 of the License, or\n"
4024
    "(at your option) any later version.\n"
4025
    "\n"
4026
    "This program is distributed in the hope that it will be useful,\n"
4027
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4028
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4029
    "GNU General Public License for more details.\n"
4030
    "\n"
4031
    "You should have received a copy of the GNU General Public License\n"
4032
    "along with this program; if not, write to the Free Software\n"
4033
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4034
    );
4035
#else
4036
    printf(
4037
    "This library is free software; you can redistribute it and/or\n"
4038
    "modify it under the terms of the GNU Lesser General Public\n"
4039
    "License as published by the Free Software Foundation; either\n"
4040
    "version 2 of the License, or (at your option) any later version.\n"
4041
    "\n"
4042
    "This library is distributed in the hope that it will be useful,\n"
4043
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4044
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4045
    "Lesser General Public License for more details.\n"
4046
    "\n"
4047
    "You should have received a copy of the GNU Lesser General Public\n"
4048
    "License along with this library; if not, write to the Free Software\n"
4049
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4050
    );
4051
#endif
4052
    exit(1);
4053
}
4054

    
4055
static void show_help(void)
4056
{
4057
    show_banner();
4058
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4059
           "Hyper fast Audio and Video encoder\n");
4060
    printf("\n");
4061
    show_help_options(options, "Main options:\n",
4062
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4063
    show_help_options(options, "\nVideo options:\n",
4064
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4065
                      OPT_VIDEO);
4066
    show_help_options(options, "\nAdvanced Video options:\n",
4067
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4068
                      OPT_VIDEO | OPT_EXPERT);
4069
    show_help_options(options, "\nAudio options:\n",
4070
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4071
                      OPT_AUDIO);
4072
    show_help_options(options, "\nAdvanced Audio options:\n",
4073
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4074
                      OPT_AUDIO | OPT_EXPERT);
4075
    show_help_options(options, "\nAudio/Video grab options:\n",
4076
                      OPT_GRAB, 
4077
                      OPT_GRAB);
4078
    show_help_options(options, "\nAdvanced options:\n",
4079
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4080
                      OPT_EXPERT);
4081
    exit(1);
4082
}
4083

    
4084
void parse_arg_file(const char *filename)
4085
{
4086
    opt_output_file(filename);
4087
}
4088

    
4089
int main(int argc, char **argv)
4090
{
4091
    int i;
4092
    int64_t ti;
4093

    
4094
    av_register_all();
4095

    
4096
    if (argc <= 1)
4097
        show_help();
4098
    else
4099
        show_banner();
4100
    
4101
    /* parse options */
4102
    parse_options(argc, argv, options);
4103

    
4104
    /* file converter / grab */
4105
    if (nb_output_files <= 0) {
4106
        fprintf(stderr, "Must supply at least one output file\n");
4107
        exit(1);
4108
    }
4109
    
4110
    if (nb_input_files == 0) {
4111
        input_sync = 1;
4112
        prepare_grab();
4113
    }
4114

    
4115
    ti = getutime();
4116
    av_encode(output_files, nb_output_files, input_files, nb_input_files, 
4117
              stream_maps, nb_stream_maps);
4118
    ti = getutime() - ti;
4119
    if (do_benchmark) {
4120
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4121
    }
4122

    
4123
    /* close files */
4124
    for(i=0;i<nb_output_files;i++) {
4125
        /* maybe av_close_output_file ??? */
4126
        AVFormatContext *s = output_files[i];
4127
        int j;
4128
        if (!(s->oformat->flags & AVFMT_NOFILE))
4129
            url_fclose(&s->pb);
4130
        for(j=0;j<s->nb_streams;j++)
4131
            av_free(s->streams[j]);
4132
        av_free(s);
4133
    }
4134
    for(i=0;i<nb_input_files;i++)
4135
        av_close_input_file(input_files[i]);
4136

    
4137
    av_free_static();
4138

    
4139
    if(intra_matrix)
4140
        av_free(intra_matrix);
4141
    if(inter_matrix)
4142
        av_free(inter_matrix);
4143
    
4144
#ifdef POWERPC_PERFORMANCE_REPORT
4145
    extern void powerpc_display_perf_report(void);
4146
    powerpc_display_perf_report();
4147
#endif /* POWERPC_PERFORMANCE_REPORT */
4148

    
4149
#ifndef CONFIG_WIN32
4150
    if (received_sigterm) {
4151
        fprintf(stderr,
4152
            "Received signal %d: terminating.\n",
4153
            (int) received_sigterm);
4154
        exit (255);
4155
    }
4156
#endif
4157
    exit(0); /* not all OS-es handle main() return value */
4158
    return 0;
4159
}