Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 01f4895c

History | View | Annotate | Download (156 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
    int sync_file_index;
56
    int sync_stream_index;
57
} AVStreamMap;
58

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

    
65
extern const OptionDef options[];
66

    
67
static void show_help(void);
68
static void show_license(void);
69

    
70
#define MAX_FILES 20
71

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

    
76
static AVFormatContext *output_files[MAX_FILES];
77
static int nb_output_files = 0;
78

    
79
static AVStreamMap stream_maps[MAX_FILES];
80
static int nb_stream_maps;
81

    
82
static AVMetaDataMap meta_data_maps[MAX_FILES];
83
static int nb_meta_data_maps;
84

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

    
215
static int gop_size = 12;
216
static int intra_only = 0;
217
static int audio_sample_rate = 44100;
218
static int audio_bit_rate = 64000;
219
static int audio_disable = 0;
220
static int audio_channels = 1;
221
static int audio_codec_id = CODEC_ID_NONE;
222
static int audio_codec_tag = 0;
223
static char *audio_language = NULL;
224

    
225
static int subtitle_codec_id = CODEC_ID_NONE;
226
static char *subtitle_language = NULL;
227

    
228
static int mux_rate= 0;
229
static int mux_packet_size= 0;
230
static float mux_preload= 0.5;
231
static float mux_max_delay= 0.7;
232

    
233
static int64_t recording_time = 0;
234
static int64_t start_time = 0;
235
static int64_t rec_timestamp = 0;
236
static int64_t input_ts_offset = 0;
237
static int file_overwrite = 0;
238
static char *str_title = NULL;
239
static char *str_author = NULL;
240
static char *str_copyright = NULL;
241
static char *str_comment = NULL;
242
static int do_benchmark = 0;
243
static int do_hex_dump = 0;
244
static int do_pkt_dump = 0;
245
static int do_psnr = 0;
246
static int do_vstats = 0;
247
static int do_pass = 0;
248
static int bitexact = 0;
249
static char *pass_logfilename = NULL;
250
static int audio_stream_copy = 0;
251
static int video_stream_copy = 0;
252
static int subtitle_stream_copy = 0;
253
static int video_sync_method= 1;
254
static int audio_sync_method= 0;
255
static int copy_ts= 0;
256
static int opt_shortest = 0; //
257
static int video_global_header = 0;
258

    
259
static int rate_emu = 0;
260

    
261
#ifdef CONFIG_BKTR
262
static char *video_grab_format = "bktr";
263
#else
264
static char *video_grab_format = "video4linux";
265
#endif
266
static char *video_device = NULL;
267
static char *grab_device = NULL;
268
static int  video_channel = 0;
269
static char *video_standard = "ntsc";
270

    
271
static char *audio_grab_format = "audio_device";
272
static char *audio_device = NULL;
273
static int audio_volume = 256;
274

    
275
static int using_stdin = 0;
276
static int using_vhook = 0;
277
static int verbose = 1;
278
static int thread_count= 1;
279
static int q_pressed = 0;
280
static int me_range = 0;
281
static int64_t video_size = 0;
282
static int64_t audio_size = 0;
283
static int64_t extra_size = 0;
284
static int nb_frames_dup = 0;
285
static int nb_frames_drop = 0;
286
static int input_sync;
287
static int limit_filesize = 0; //
288

    
289
static int pgmyuv_compatibility_hack=0;
290

    
291

    
292
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
293

    
294
struct AVInputStream;
295

    
296
typedef struct AVOutputStream {
297
    int file_index;          /* file index */
298
    int index;               /* stream index in the output file */
299
    int source_index;        /* AVInputStream index */
300
    AVStream *st;            /* stream in the output file */
301
    int encoding_needed;     /* true if encoding needed for this stream */
302
    int frame_number;
303
    /* input pts and corresponding output pts
304
       for A/V sync */
305
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
306
    struct AVInputStream *sync_ist; /* input stream to sync against */
307
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
308
    /* video only */
309
    int video_resample;      /* video_resample and video_crop are mutually exclusive */
310
    AVFrame pict_tmp;      /* temporary image for resampling */
311
    ImgReSampleContext *img_resample_ctx; /* for image resampling */
312

    
313
    int video_crop;          /* video_resample and video_crop are mutually exclusive */
314
    int topBand;             /* cropping area sizes */
315
    int leftBand;
316
    
317
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
318
    int padtop;              /* padding area sizes */
319
    int padbottom;
320
    int padleft;
321
    int padright;
322
    
323
    /* audio only */
324
    int audio_resample;
325
    ReSampleContext *resample; /* for audio resampling */
326
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
327
    FILE *logfile;
328
} AVOutputStream;
329

    
330
typedef struct AVInputStream {
331
    int file_index;
332
    int index;
333
    AVStream *st;
334
    int discard;             /* true if stream data should be discarded */
335
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
336
    int64_t sample_index;      /* current sample */
337

    
338
    int64_t       start;     /* time when read started */
339
    unsigned long frame;     /* current frame */
340
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
341
                                is not defined */
342
    int64_t       pts;       /* current pts */
343
    int is_start;            /* is 1 at the start and after a discontinuity */
344
} AVInputStream;
345

    
346
typedef struct AVInputFile {
347
    int eof_reached;      /* true if eof reached */
348
    int ist_index;        /* index of first stream in ist_table */
349
    int buffer_size;      /* current total buffer size */
350
    int buffer_size_max;  /* buffer size at which we consider we can stop
351
                             buffering */
352
    int nb_streams;       /* nb streams we are aware of */
353
} AVInputFile;
354

    
355
#ifndef CONFIG_WIN32
356

    
357
/* init terminal so that we can grab keys */
358
static struct termios oldtty;
359

    
360
static void term_exit(void)
361
{
362
    tcsetattr (0, TCSANOW, &oldtty);
363
}
364

    
365
static volatile sig_atomic_t received_sigterm = 0;
366

    
367
static void
368
sigterm_handler(int sig)
369
{
370
    received_sigterm = sig;
371
    term_exit();
372
}
373

    
374
static void term_init(void)
375
{
376
    struct termios tty;
377

    
378
    tcgetattr (0, &tty);
379
    oldtty = tty;
380

    
381
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
382
                          |INLCR|IGNCR|ICRNL|IXON);
383
    tty.c_oflag |= OPOST;
384
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
385
    tty.c_cflag &= ~(CSIZE|PARENB);
386
    tty.c_cflag |= CS8;
387
    tty.c_cc[VMIN] = 1;
388
    tty.c_cc[VTIME] = 0;
389
    
390
    tcsetattr (0, TCSANOW, &tty);
391

    
392
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
393
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
394
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
395
    /*
396
    register a function to be called at normal program termination
397
    */
398
    atexit(term_exit);
399
#ifdef CONFIG_BEOS_NETSERVER
400
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
401
#endif
402
}
403

    
404
/* read a key without blocking */
405
static int read_key(void)
406
{
407
    int n = 1;
408
    unsigned char ch;
409
#ifndef CONFIG_BEOS_NETSERVER
410
    struct timeval tv;
411
    fd_set rfds;
412

    
413
    FD_ZERO(&rfds);
414
    FD_SET(0, &rfds);
415
    tv.tv_sec = 0;
416
    tv.tv_usec = 0;
417
    n = select(1, &rfds, NULL, NULL, &tv);
418
#endif
419
    if (n > 0) {
420
        n = read(0, &ch, 1);
421
        if (n == 1)
422
            return ch;
423

    
424
        return n;
425
    }
426
    return -1;
427
}
428

    
429
static int decode_interrupt_cb(void)
430
{
431
    return q_pressed || (q_pressed = read_key() == 'q');
432
}
433

    
434
#else
435

    
436
static volatile int received_sigterm = 0;
437

    
438
/* no interactive support */
439
static void term_exit(void)
440
{
441
}
442

    
443
static void term_init(void)
444
{
445
}
446

    
447
static int read_key(void)
448
{
449
    return 0;
450
}
451

    
452
#endif
453

    
454
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
455
{
456
    int i, err;
457
    AVFormatContext *ic;
458

    
459
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
460
    if (err < 0)
461
        return err;
462
    /* copy stream format */
463
    s->nb_streams = ic->nb_streams;
464
    for(i=0;i<ic->nb_streams;i++) {
465
        AVStream *st;
466

    
467
        st = av_mallocz(sizeof(AVStream));
468
        memcpy(st, ic->streams[i], sizeof(AVStream));
469
        s->streams[i] = st;
470
    }
471

    
472
    av_close_input_file(ic);
473
    return 0;
474
}
475

    
476
static double
477
get_sync_ipts(const AVOutputStream *ost)
478
{
479
    const AVInputStream *ist = ost->sync_ist;
480
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
481
}
482

    
483
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
484

    
485
static void do_audio_out(AVFormatContext *s, 
486
                         AVOutputStream *ost, 
487
                         AVInputStream *ist,
488
                         unsigned char *buf, int size)
489
{
490
    uint8_t *buftmp;
491
    static uint8_t *audio_buf = NULL;
492
    static uint8_t *audio_out = NULL;
493
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
494

    
495
    int size_out, frame_bytes, ret;
496
    AVCodecContext *enc= ost->st->codec;
497

    
498
    /* SC: dynamic allocation of buffers */
499
    if (!audio_buf)
500
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
501
    if (!audio_out)
502
        audio_out = av_malloc(audio_out_size);
503
    if (!audio_buf || !audio_out)
504
        return;               /* Should signal an error ! */
505

    
506
    if(audio_sync_method){
507
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts 
508
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
509
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
510
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
511

    
512
        //FIXME resample delay
513
        if(fabs(delta) > 50){
514
            if(ist->is_start){
515
                if(byte_delta < 0){
516
                    byte_delta= FFMAX(byte_delta, -size);
517
                    size += byte_delta;
518
                    buf  -= byte_delta;
519
                    if(verbose > 2)
520
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
521
                    if(!size)
522
                        return;
523
                    ist->is_start=0;
524
                }else{
525
                    static uint8_t *input_tmp= NULL;
526
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
527

    
528
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
529
                        ist->is_start=0;
530
                    else
531
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
532

    
533
                    memset(input_tmp, 0, byte_delta);
534
                    memcpy(input_tmp + byte_delta, buf, size);
535
                    buf= input_tmp;
536
                    size += byte_delta;
537
                    if(verbose > 2)
538
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
539
                }
540
            }else if(audio_sync_method>1){
541
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
542
                assert(ost->audio_resample);
543
                if(verbose > 2)
544
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
545
//                fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
546
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
547
            }
548
        } 
549
    }else
550
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
551
                        - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
552

    
553
    if (ost->audio_resample) {
554
        buftmp = audio_buf;
555
        size_out = audio_resample(ost->resample, 
556
                                  (short *)buftmp, (short *)buf,
557
                                  size / (ist->st->codec->channels * 2));
558
        size_out = size_out * enc->channels * 2;
559
    } else {
560
        buftmp = buf;
561
        size_out = size;
562
    }
563

    
564
    /* now encode as many frames as possible */
565
    if (enc->frame_size > 1) {
566
        /* output resampled raw samples */
567
        fifo_write(&ost->fifo, buftmp, size_out, 
568
                   &ost->fifo.wptr);
569

    
570
        frame_bytes = enc->frame_size * 2 * enc->channels;
571
        
572
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes, 
573
                     &ost->fifo.rptr) == 0) {
574
            AVPacket pkt;
575
            av_init_packet(&pkt);
576

    
577
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size, 
578
                                       (short *)audio_buf);
579
            audio_size += ret;
580
            pkt.stream_index= ost->index;
581
            pkt.data= audio_out;
582
            pkt.size= ret;
583
            if(enc->coded_frame)
584
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
585
            pkt.flags |= PKT_FLAG_KEY;
586
            av_interleaved_write_frame(s, &pkt);
587
            
588
            ost->sync_opts += enc->frame_size;
589
        }
590
    } else {
591
        AVPacket pkt;
592
        av_init_packet(&pkt);
593

    
594
        ost->sync_opts += size_out / (2 * enc->channels);
595

    
596
        /* output a pcm frame */
597
        /* XXX: change encoding codec API to avoid this ? */
598
        switch(enc->codec->id) {
599
        case CODEC_ID_PCM_S16LE:
600
        case CODEC_ID_PCM_S16BE:
601
        case CODEC_ID_PCM_U16LE:
602
        case CODEC_ID_PCM_U16BE:
603
            break;
604
        default:
605
            size_out = size_out >> 1;
606
            break;
607
        }
608
        ret = avcodec_encode_audio(enc, audio_out, size_out, 
609
                                   (short *)buftmp);
610
        audio_size += ret;
611
        pkt.stream_index= ost->index;
612
        pkt.data= audio_out;
613
        pkt.size= ret;
614
        if(enc->coded_frame)
615
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
616
        pkt.flags |= PKT_FLAG_KEY;
617
        av_interleaved_write_frame(s, &pkt);
618
    }
619
}
620

    
621
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
622
{
623
    AVCodecContext *dec;
624
    AVPicture *picture2;
625
    AVPicture picture_tmp;
626
    uint8_t *buf = 0;
627

    
628
    dec = ist->st->codec;
629

    
630
    /* deinterlace : must be done before any resize */
631
    if (do_deinterlace || using_vhook) {
632
        int size;
633

    
634
        /* create temporary picture */
635
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
636
        buf = av_malloc(size);
637
        if (!buf)
638
            return;
639
        
640
        picture2 = &picture_tmp;
641
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
642

    
643
        if (do_deinterlace){
644
            if(avpicture_deinterlace(picture2, picture, 
645
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
646
                /* if error, do not deinterlace */
647
                av_free(buf);
648
                buf = NULL;
649
                picture2 = picture;
650
            }
651
        } else {
652
            if (img_convert(picture2, dec->pix_fmt, picture, 
653
                            dec->pix_fmt, dec->width, dec->height) < 0) {
654
                /* if error, do not copy */
655
                av_free(buf);
656
                buf = NULL;
657
                picture2 = picture;
658
            }
659
        }
660
    } else {
661
        picture2 = picture;
662
    }
663

    
664
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
665

    
666
    if (picture != picture2)
667
        *picture = *picture2;
668
    *bufp = buf;
669
}
670

    
671
/* we begin to correct av delay at this threshold */
672
#define AV_DELAY_MAX 0.100
673

    
674

    
675
/* Expects img to be yuv420 */
676
static void fill_pad_region(AVPicture* img, int height, int width,
677
        int padtop, int padbottom, int padleft, int padright, int *color) {
678
  
679
    int i, y, shift;
680
    uint8_t *optr;
681
    
682
    for (i = 0; i < 3; i++) {
683
        shift = (i == 0) ? 0 : 1;
684
        
685
        if (padtop || padleft) {
686
            memset(img->data[i], color[i], (((img->linesize[i] * padtop) + 
687
                            padleft) >> shift));
688
        }
689

    
690
        if (padleft || padright) {
691
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
692
                (img->linesize[i] - (padright >> shift));
693

    
694
            for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
695
                memset(optr, color[i], (padleft + padright) >> shift);
696
                optr += img->linesize[i];
697
            }
698
        }
699
      
700
        if (padbottom || padright) {
701
            optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
702
            memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
703
        }
704
    }
705
}
706

    
707
static void do_subtitle_out(AVFormatContext *s, 
708
                            AVOutputStream *ost, 
709
                            AVInputStream *ist,
710
                            AVSubtitle *sub,
711
                            int64_t pts)
712
{
713
    static uint8_t *subtitle_out = NULL;
714
    int subtitle_out_max_size = 65536;
715
    int subtitle_out_size, nb, i;
716
    AVCodecContext *enc;
717
    AVPacket pkt;
718

    
719
    if (pts == AV_NOPTS_VALUE) {
720
        fprintf(stderr, "Subtitle packets must have a pts\n");
721
        return;
722
    }
723

    
724
    enc = ost->st->codec;
725

    
726
    if (!subtitle_out) {
727
        subtitle_out = av_malloc(subtitle_out_max_size);
728
    }
729

    
730
    /* Note: DVB subtitle need one packet to draw them and one other
731
       packet to clear them */
732
    /* XXX: signal it in the codec context ? */
733
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
734
        nb = 2;
735
    else
736
        nb = 1;
737

    
738
    for(i = 0; i < nb; i++) {
739
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out, 
740
                                                    subtitle_out_max_size, sub);
741
        
742
        av_init_packet(&pkt);
743
        pkt.stream_index = ost->index;
744
        pkt.data = subtitle_out;
745
        pkt.size = subtitle_out_size;
746
        pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
747
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
748
            /* XXX: the pts correction is handled here. Maybe handling
749
               it in the codec would be better */
750
            if (i == 0)
751
                pkt.pts += 90 * sub->start_display_time;
752
            else
753
                pkt.pts += 90 * sub->end_display_time;
754
        }
755
        av_interleaved_write_frame(s, &pkt);
756
    }
757
}
758

    
759
static int bit_buffer_size= 1024*256;
760
static uint8_t *bit_buffer= NULL;
761

    
762
static void do_video_out(AVFormatContext *s, 
763
                         AVOutputStream *ost, 
764
                         AVInputStream *ist,
765
                         AVFrame *in_picture,
766
                         int *frame_size)
767
{
768
    int nb_frames, i, ret;
769
    AVFrame *final_picture, *formatted_picture;
770
    AVFrame picture_format_temp, picture_crop_temp;
771
    uint8_t *buf = NULL, *buf1 = NULL;
772
    AVCodecContext *enc, *dec;
773
    enum PixelFormat target_pixfmt;
774
    
775
    avcodec_get_frame_defaults(&picture_format_temp);
776
    avcodec_get_frame_defaults(&picture_crop_temp);
777

    
778
    enc = ost->st->codec;
779
    dec = ist->st->codec;
780

    
781
    /* by default, we output a single frame */
782
    nb_frames = 1;
783

    
784
    *frame_size = 0;
785

    
786
    if(video_sync_method){
787
        double vdelta;
788
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
789
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
790
        if (vdelta < -1.1)
791
            nb_frames = 0;
792
        else if (vdelta > 1.1)
793
            nb_frames = lrintf(vdelta);
794
//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);
795
        if (nb_frames == 0){
796
            ++nb_frames_drop;
797
            if (verbose>2)
798
                fprintf(stderr, "*** drop!\n");
799
        }else if (nb_frames > 1) {
800
            nb_frames_dup += nb_frames;
801
            if (verbose>2)
802
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
803
        }
804
    }else
805
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
806

    
807
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
808
    if (nb_frames <= 0) 
809
        return;
810

    
811
    /* convert pixel format if needed */
812
    target_pixfmt = ost->video_resample || ost->video_pad
813
        ? PIX_FMT_YUV420P : enc->pix_fmt;
814
    if (dec->pix_fmt != target_pixfmt) {
815
        int size;
816

    
817
        /* create temporary picture */
818
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
819
        buf = av_malloc(size);
820
        if (!buf)
821
            return;
822
        formatted_picture = &picture_format_temp;
823
        avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
824
        
825
        if (img_convert((AVPicture*)formatted_picture, target_pixfmt, 
826
                        (AVPicture *)in_picture, dec->pix_fmt, 
827
                        dec->width, dec->height) < 0) {
828

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

    
832
            goto the_end;
833
        }
834
    } else {
835
        formatted_picture = in_picture;
836
    }
837

    
838
    /* XXX: resampling could be done before raw format conversion in
839
       some cases to go faster */
840
    /* XXX: only works for YUV420P */
841
    if (ost->video_resample) {
842
        final_picture = &ost->pict_tmp;
843
        img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
844
       
845
        if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
846
            fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
847
                    ost->padtop, ost->padbottom, ost->padleft, ost->padright,
848
                    padcolor);
849
        }
850
        
851
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
852
            int size;
853
            
854
            av_free(buf);
855
            /* create temporary picture */
856
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
857
            buf = av_malloc(size);
858
            if (!buf)
859
                return;
860
            final_picture = &picture_format_temp;
861
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
862
        
863
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
864
                            (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
865
                            enc->width, enc->height) < 0) {
866

    
867
                if (verbose >= 0)
868
                    fprintf(stderr, "pixel format conversion not handled\n");
869

    
870
                goto the_end;
871
            }
872
        }
873
    } else if (ost->video_crop) {
874
        picture_crop_temp.data[0] = formatted_picture->data[0] +
875
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
876

    
877
        picture_crop_temp.data[1] = formatted_picture->data[1] +
878
                ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
879
                (ost->leftBand >> 1);
880

    
881
        picture_crop_temp.data[2] = formatted_picture->data[2] +
882
                ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
883
                (ost->leftBand >> 1);
884

    
885
        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
886
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
887
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
888
        final_picture = &picture_crop_temp;
889
    } else if (ost->video_pad) {
890
        final_picture = &ost->pict_tmp;
891

    
892
        for (i = 0; i < 3; i++) {
893
            uint8_t *optr, *iptr;
894
            int shift = (i == 0) ? 0 : 1;
895
            int y, yheight;
896
            
897
            /* set offset to start writing image into */
898
            optr = final_picture->data[i] + (((final_picture->linesize[i] * 
899
                            ost->padtop) + ost->padleft) >> shift);
900
            iptr = formatted_picture->data[i];
901

    
902
            yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
903
            for (y = 0; y < yheight; y++) {
904
                /* copy unpadded image row into padded image row */
905
                memcpy(optr, iptr, formatted_picture->linesize[i]);
906
                optr += final_picture->linesize[i];
907
                iptr += formatted_picture->linesize[i];
908
            }
909
        }
910

    
911
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
912
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
913
                padcolor);
914
        
915
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
916
            int size;
917

    
918
            av_free(buf);
919
            /* create temporary picture */
920
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
921
            buf = av_malloc(size);
922
            if (!buf)
923
                return;
924
            final_picture = &picture_format_temp;
925
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
926

    
927
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt, 
928
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P, 
929
                        enc->width, enc->height) < 0) {
930

    
931
                if (verbose >= 0)
932
                    fprintf(stderr, "pixel format conversion not handled\n");
933

    
934
                goto the_end;
935
            }
936
        }
937
    } else {
938
        final_picture = formatted_picture;
939
    }
940
    /* duplicates frame if needed */
941
    for(i=0;i<nb_frames;i++) {
942
        AVPacket pkt;
943
        av_init_packet(&pkt);
944
        pkt.stream_index= ost->index;
945

    
946
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
947
            /* raw pictures are written as AVPicture structure to
948
               avoid any copies. We support temorarily the older
949
               method. */
950
            AVFrame* old_frame = enc->coded_frame;
951
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
952
            pkt.data= (uint8_t *)final_picture;
953
            pkt.size=  sizeof(AVPicture);
954
            if(dec->coded_frame)
955
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
956
            if(dec->coded_frame && dec->coded_frame->key_frame)
957
                pkt.flags |= PKT_FLAG_KEY;
958

    
959
            av_interleaved_write_frame(s, &pkt);
960
            enc->coded_frame = old_frame;
961
        } else {
962
            AVFrame big_picture;
963

    
964
            big_picture= *final_picture;
965
            /* better than nothing: use input picture interlaced
966
               settings */
967
            big_picture.interlaced_frame = in_picture->interlaced_frame;
968
            if(do_interlace_me || do_interlace_dct){
969
                if(top_field_first == -1)
970
                    big_picture.top_field_first = in_picture->top_field_first;
971
                else
972
                    big_picture.top_field_first = top_field_first;
973
            }
974

    
975
            /* handles sameq here. This is not correct because it may
976
               not be a global option */
977
            if (same_quality) {
978
                big_picture.quality = ist->st->quality;
979
            }else
980
                big_picture.quality = ost->st->quality;
981
            if(!me_threshold)
982
                big_picture.pict_type = 0;
983
//            big_picture.pts = AV_NOPTS_VALUE;
984
            big_picture.pts= ost->sync_opts;
985
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
986
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
987
            ret = avcodec_encode_video(enc, 
988
                                       bit_buffer, bit_buffer_size,
989
                                       &big_picture);
990
            //enc->frame_number = enc->real_pict_num;
991
            if(ret>0){
992
                pkt.data= bit_buffer;
993
                pkt.size= ret;
994
                if(enc->coded_frame)
995
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
996
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n", 
997
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
998
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
999

    
1000
                if(enc->coded_frame && enc->coded_frame->key_frame)
1001
                    pkt.flags |= PKT_FLAG_KEY;
1002
                av_interleaved_write_frame(s, &pkt);
1003
                *frame_size = ret;
1004
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
1005
                //        enc->frame_number-1, enc->real_pict_num, ret,
1006
                //        enc->pict_type);
1007
                /* if two pass, output log */
1008
                if (ost->logfile && enc->stats_out) {
1009
                    fprintf(ost->logfile, "%s", enc->stats_out);
1010
                }
1011
            }
1012
        }
1013
        ost->sync_opts++;
1014
        ost->frame_number++;
1015
    }
1016
 the_end:
1017
    av_free(buf);
1018
    av_free(buf1);
1019
}
1020

    
1021
static double psnr(double d){
1022
    if(d==0) return INFINITY;
1023
    return -10.0*log(d)/log(10.0);
1024
}
1025

    
1026
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost, 
1027
                           int frame_size)
1028
{
1029
    static FILE *fvstats=NULL;
1030
    char filename[40];
1031
    time_t today2;
1032
    struct tm *today;
1033
    AVCodecContext *enc;
1034
    int frame_number;
1035
    int64_t ti;
1036
    double ti1, bitrate, avg_bitrate;
1037
    
1038
    if (!fvstats) {
1039
        today2 = time(NULL);
1040
        today = localtime(&today2);
1041
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
1042
                                               today->tm_min,
1043
                                               today->tm_sec);
1044
        fvstats = fopen(filename,"w");
1045
        if (!fvstats) {
1046
            perror("fopen");
1047
            exit(1);
1048
        }
1049
    }
1050
    
1051
    ti = MAXINT64;
1052
    enc = ost->st->codec;
1053
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1054
        frame_number = ost->frame_number;
1055
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1056
        if (enc->flags&CODEC_FLAG_PSNR)
1057
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1058
        
1059
        fprintf(fvstats,"f_size= %6d ", frame_size);
1060
        /* compute pts value */
1061
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1062
        if (ti1 < 0.01)
1063
            ti1 = 0.01;
1064
    
1065
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1066
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1067
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1068
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1069
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));        
1070
    }
1071
}
1072

    
1073
static void print_report(AVFormatContext **output_files,
1074
                         AVOutputStream **ost_table, int nb_ostreams,
1075
                         int is_last_report)
1076
{
1077
    char buf[1024];
1078
    AVOutputStream *ost;
1079
    AVFormatContext *oc, *os;
1080
    int64_t total_size;
1081
    AVCodecContext *enc;
1082
    int frame_number, vid, i;
1083
    double bitrate, ti1, pts;
1084
    static int64_t last_time = -1;
1085
    
1086
    if (!is_last_report) {
1087
        int64_t cur_time;
1088
        /* display the report every 0.5 seconds */
1089
        cur_time = av_gettime();
1090
        if (last_time == -1) {
1091
            last_time = cur_time;
1092
            return;
1093
        } 
1094
        if ((cur_time - last_time) < 500000)
1095
            return;
1096
        last_time = cur_time;
1097
    }
1098

    
1099

    
1100
    oc = output_files[0];
1101

    
1102
    total_size = url_ftell(&oc->pb);
1103
    
1104
    buf[0] = '\0';
1105
    ti1 = 1e10;
1106
    vid = 0;
1107
    for(i=0;i<nb_ostreams;i++) {
1108
        ost = ost_table[i];
1109
        os = output_files[ost->file_index];
1110
        enc = ost->st->codec;
1111
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1112
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1113
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1114
        }
1115
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1116
            frame_number = ost->frame_number;
1117
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%2.1f ",
1118
                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1119
            if(is_last_report)
1120
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1121
            if (enc->flags&CODEC_FLAG_PSNR){
1122
                int j;
1123
                double error, error_sum=0;
1124
                double scale, scale_sum=0;
1125
                char type[3]= {'Y','U','V'};
1126
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1127
                for(j=0; j<3; j++){
1128
                    if(is_last_report){
1129
                        error= enc->error[j];
1130
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1131
                    }else{
1132
                        error= enc->coded_frame->error[j];
1133
                        scale= enc->width*enc->height*255.0*255.0;
1134
                    }
1135
                    if(j) scale/=4;
1136
                    error_sum += error;
1137
                    scale_sum += scale;
1138
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1139
                }
1140
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1141
            }
1142
            vid = 1;
1143
        }
1144
        /* compute min output value */
1145
        pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1146
        if ((pts < ti1) && (pts > 0))
1147
            ti1 = pts;
1148
    }
1149
    if (ti1 < 0.01)
1150
        ti1 = 0.01;
1151
    
1152
    if (verbose || is_last_report) {
1153
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1154
        
1155
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), 
1156
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1157
            (double)total_size / 1024, ti1, bitrate);
1158

    
1159
        if (verbose > 1)
1160
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1161
                  nb_frames_dup, nb_frames_drop);
1162
        
1163
        if (verbose >= 0)
1164
            fprintf(stderr, "%s    \r", buf);
1165

    
1166
        fflush(stderr);
1167
    }
1168
        
1169
    if (is_last_report && verbose >= 0){
1170
        int64_t raw= audio_size + video_size + extra_size;
1171
        fprintf(stderr, "\n");
1172
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1173
                video_size/1024.0,
1174
                audio_size/1024.0,
1175
                extra_size/1024.0,
1176
                100.0*(total_size - raw)/raw
1177
        );
1178
    }
1179
}
1180

    
1181
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1182
static int output_packet(AVInputStream *ist, int ist_index,
1183
                         AVOutputStream **ost_table, int nb_ostreams,
1184
                         const AVPacket *pkt)
1185
{
1186
    AVFormatContext *os;
1187
    AVOutputStream *ost;
1188
    uint8_t *ptr;
1189
    int len, ret, i;
1190
    uint8_t *data_buf;
1191
    int data_size, got_picture;
1192
    AVFrame picture;
1193
    void *buffer_to_free;
1194
    static int samples_size= 0;
1195
    static short *samples= NULL;
1196
    AVSubtitle subtitle, *subtitle_to_free;
1197
    int got_subtitle;
1198
    
1199
    if(!pkt){
1200
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1201
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1202
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1203
    } else {
1204
//        assert(ist->pts == ist->next_pts);
1205
    }
1206
    
1207
    if (pkt == NULL) {
1208
        /* EOF handling */
1209
        ptr = NULL;
1210
        len = 0;
1211
        goto handle_eof;
1212
    }
1213

    
1214
    len = pkt->size;
1215
    ptr = pkt->data;
1216
    while (len > 0) {
1217
    handle_eof:
1218
        /* decode the packet if needed */
1219
        data_buf = NULL; /* fail safe */
1220
        data_size = 0;
1221
        subtitle_to_free = NULL;
1222
        if (ist->decoding_needed) {
1223
            switch(ist->st->codec->codec_type) {
1224
            case CODEC_TYPE_AUDIO:{
1225
                if(pkt) 
1226
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1227
                    /* XXX: could avoid copy if PCM 16 bits with same
1228
                       endianness as CPU */
1229
                ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1230
                                           ptr, len);
1231
                if (ret < 0)
1232
                    goto fail_decode;
1233
                ptr += ret;
1234
                len -= ret;
1235
                /* Some bug in mpeg audio decoder gives */
1236
                /* data_size < 0, it seems they are overflows */
1237
                if (data_size <= 0) {
1238
                    /* no audio frame */
1239
                    continue;
1240
                }
1241
                data_buf = (uint8_t *)samples;
1242
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) / 
1243
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1244
                break;}
1245
            case CODEC_TYPE_VIDEO:
1246
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1247
                    /* XXX: allocate picture correctly */
1248
                    avcodec_get_frame_defaults(&picture);
1249

    
1250
                    ret = avcodec_decode_video(ist->st->codec, 
1251
                                               &picture, &got_picture, ptr, len);
1252
                    ist->st->quality= picture.quality;
1253
                    if (ret < 0) 
1254
                        goto fail_decode;
1255
                    if (!got_picture) {
1256
                        /* no picture yet */
1257
                        goto discard_packet;
1258
                    }
1259
                    if (ist->st->codec->time_base.num != 0) {
1260
                        ist->next_pts += ((int64_t)AV_TIME_BASE * 
1261
                                          ist->st->codec->time_base.num) /
1262
                            ist->st->codec->time_base.den;
1263
                    }
1264
                    len = 0;
1265
                    break;
1266
            case CODEC_TYPE_SUBTITLE:
1267
                ret = avcodec_decode_subtitle(ist->st->codec, 
1268
                                              &subtitle, &got_subtitle, ptr, len);
1269
                if (ret < 0)
1270
                    goto fail_decode;
1271
                if (!got_subtitle) {
1272
                    goto discard_packet;
1273
                }
1274
                subtitle_to_free = &subtitle;
1275
                len = 0;
1276
                break;
1277
            default:
1278
                goto fail_decode;
1279
            }
1280
        } else {
1281
                switch(ist->st->codec->codec_type) {
1282
                case CODEC_TYPE_AUDIO:
1283
                    ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) / 
1284
                        (ist->st->codec->sample_rate * ist->st->codec->channels);
1285
                    break;
1286
                case CODEC_TYPE_VIDEO:
1287
                    if (ist->st->codec->time_base.num != 0) {
1288
                        ist->next_pts += ((int64_t)AV_TIME_BASE * 
1289
                                          ist->st->codec->time_base.num) /
1290
                            ist->st->codec->time_base.den;
1291
                    }
1292
                    break;
1293
                }
1294
                data_buf = ptr;
1295
                data_size = len;
1296
                ret = len;
1297
                len = 0;
1298
            }
1299

    
1300
            buffer_to_free = NULL;
1301
            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1302
                pre_process_video_frame(ist, (AVPicture *)&picture, 
1303
                                        &buffer_to_free);
1304
            }
1305

    
1306
            // preprocess audio (volume)
1307
            if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1308
                if (audio_volume != 256) {
1309
                    short *volp;
1310
                    volp = samples;
1311
                    for(i=0;i<(data_size / sizeof(short));i++) {
1312
                        int v = ((*volp) * audio_volume + 128) >> 8;
1313
                        if (v < -32768) v = -32768;
1314
                        if (v >  32767) v = 32767;
1315
                        *volp++ = v;
1316
                    }
1317
                }
1318
            }
1319

    
1320
            /* frame rate emulation */
1321
            if (ist->st->codec->rate_emu) {
1322
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1323
                int64_t now = av_gettime() - ist->start;
1324
                if (pts > now)
1325
                    usleep(pts - now);
1326

    
1327
                ist->frame++;
1328
            }
1329

    
1330
#if 0
1331
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1332
               is the one of the next displayed one */
1333
            /* XXX: add mpeg4 too ? */
1334
            if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1335
                if (ist->st->codec->pict_type != B_TYPE) {
1336
                    int64_t tmp;
1337
                    tmp = ist->last_ip_pts;
1338
                    ist->last_ip_pts  = ist->frac_pts.val;
1339
                    ist->frac_pts.val = tmp;
1340
                }
1341
            }
1342
#endif
1343
            /* if output time reached then transcode raw format, 
1344
               encode packets and output them */
1345
            if (start_time == 0 || ist->pts >= start_time)
1346
                for(i=0;i<nb_ostreams;i++) {
1347
                    int frame_size;
1348

    
1349
                    ost = ost_table[i];
1350
                    if (ost->source_index == ist_index) {
1351
                        os = output_files[ost->file_index];
1352

    
1353
#if 0
1354
                        printf("%d: got pts=%0.3f %0.3f\n", i, 
1355
                               (double)pkt->pts / AV_TIME_BASE, 
1356
                               ((double)ist->pts / AV_TIME_BASE) - 
1357
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1358
#endif
1359
                        /* set the input output pts pairs */
1360
                        //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1361

    
1362
                        if (ost->encoding_needed) {
1363
                            switch(ost->st->codec->codec_type) {
1364
                            case CODEC_TYPE_AUDIO:
1365
                                do_audio_out(os, ost, ist, data_buf, data_size);
1366
                                break;
1367
                            case CODEC_TYPE_VIDEO:
1368
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1369
                                    video_size += frame_size;
1370
                                    if (do_vstats && frame_size)
1371
                                        do_video_stats(os, ost, frame_size);
1372
                                break;
1373
                            case CODEC_TYPE_SUBTITLE:
1374
                                do_subtitle_out(os, ost, ist, &subtitle,
1375
                                                pkt->pts);
1376
                                break;
1377
                            default:
1378
                                av_abort();
1379
                            }
1380
                        } else {
1381
                            AVFrame avframe; //FIXME/XXX remove this
1382
                            AVPacket opkt;
1383
                            av_init_packet(&opkt);
1384

    
1385
                            /* no reencoding needed : output the packet directly */
1386
                            /* force the input stream PTS */
1387
                        
1388
                            avcodec_get_frame_defaults(&avframe);
1389
                            ost->st->codec->coded_frame= &avframe;
1390
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY; 
1391

    
1392
                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1393
                                audio_size += data_size;
1394
                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1395
                                video_size += data_size;
1396
                                ost->sync_opts++;
1397
                            }
1398

    
1399
                            opkt.stream_index= ost->index;
1400
                            if(pkt->pts != AV_NOPTS_VALUE)
1401
                                opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1402
                            else
1403
                                opkt.pts= AV_NOPTS_VALUE;
1404

    
1405
                            {
1406
                                int64_t dts;
1407
                                if (pkt->dts == AV_NOPTS_VALUE)
1408
                                    dts = ist->next_pts;
1409
                                else
1410
                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1411
                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1412
                            }
1413
                            opkt.flags= pkt->flags;
1414
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1415
                                opkt.destruct= av_destruct_packet;
1416
                            av_interleaved_write_frame(os, &opkt);
1417
                            ost->st->codec->frame_number++;
1418
                            ost->frame_number++;
1419
                            av_free_packet(&opkt);
1420
                        }
1421
                    }
1422
                }
1423
            av_free(buffer_to_free);
1424
            /* XXX: allocate the subtitles in the codec ? */
1425
            if (subtitle_to_free) {
1426
                if (subtitle_to_free->rects != NULL) {
1427
                    for (i = 0; i < subtitle_to_free->num_rects; i++) {
1428
                        av_free(subtitle_to_free->rects[i].bitmap);
1429
                        av_free(subtitle_to_free->rects[i].rgba_palette);
1430
                    }
1431
                    av_freep(&subtitle_to_free->rects);
1432
                }
1433
                subtitle_to_free->num_rects = 0;
1434
                subtitle_to_free = NULL;
1435
            }
1436
        }
1437
 discard_packet:
1438
    if (pkt == NULL) {
1439
        /* EOF handling */
1440
  
1441
        for(i=0;i<nb_ostreams;i++) {
1442
            ost = ost_table[i];
1443
            if (ost->source_index == ist_index) {
1444
                AVCodecContext *enc= ost->st->codec;
1445
                os = output_files[ost->file_index];
1446
                
1447
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1448
                    continue;
1449
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1450
                    continue;
1451

    
1452
                if (ost->encoding_needed) {
1453
                    for(;;) {
1454
                        AVPacket pkt;
1455
                        av_init_packet(&pkt);
1456
                        pkt.stream_index= ost->index;
1457
 
1458
                        switch(ost->st->codec->codec_type) {
1459
                        case CODEC_TYPE_AUDIO:        
1460
                            ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1461
                            audio_size += ret;
1462
                            pkt.flags |= PKT_FLAG_KEY;
1463
                            break;
1464
                        case CODEC_TYPE_VIDEO:
1465
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1466
                            video_size += ret;
1467
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1468
                                pkt.flags |= PKT_FLAG_KEY;
1469
                            if (ost->logfile && enc->stats_out) {
1470
                                fprintf(ost->logfile, "%s", enc->stats_out);
1471
                            }
1472
                            break;
1473
                        default:
1474
                            ret=-1;
1475
                        }
1476
                            
1477
                        if(ret<=0)
1478
                            break;
1479
                        pkt.data= bit_buffer;
1480
                        pkt.size= ret;
1481
                        if(enc->coded_frame)
1482
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1483
                        av_interleaved_write_frame(os, &pkt);
1484
                    }
1485
                }
1486
            }
1487
        }
1488
    }
1489
 
1490
    return 0;
1491
 fail_decode:
1492
    return -1;
1493
}
1494

    
1495

    
1496
/*
1497
 * The following code is the main loop of the file converter
1498
 */
1499
static int av_encode(AVFormatContext **output_files,
1500
                     int nb_output_files,
1501
                     AVFormatContext **input_files,
1502
                     int nb_input_files,
1503
                     AVStreamMap *stream_maps, int nb_stream_maps)
1504
{
1505
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1506
    AVFormatContext *is, *os;
1507
    AVCodecContext *codec, *icodec;
1508
    AVOutputStream *ost, **ost_table = NULL;
1509
    AVInputStream *ist, **ist_table = NULL;
1510
    AVInputFile *file_table;
1511
    AVFormatContext *stream_no_data;
1512
    int key;
1513

    
1514
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1515
    if (!file_table)
1516
        goto fail;
1517
        
1518
    /* input stream init */
1519
    j = 0;
1520
    for(i=0;i<nb_input_files;i++) {
1521
        is = input_files[i];
1522
        file_table[i].ist_index = j;
1523
        file_table[i].nb_streams = is->nb_streams;
1524
        j += is->nb_streams;
1525
    }
1526
    nb_istreams = j;
1527

    
1528
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1529
    if (!ist_table)
1530
        goto fail;
1531
    
1532
    for(i=0;i<nb_istreams;i++) {
1533
        ist = av_mallocz(sizeof(AVInputStream));
1534
        if (!ist)
1535
            goto fail;
1536
        ist_table[i] = ist;
1537
    }
1538
    j = 0;
1539
    for(i=0;i<nb_input_files;i++) {
1540
        is = input_files[i];
1541
        for(k=0;k<is->nb_streams;k++) {
1542
            ist = ist_table[j++];
1543
            ist->st = is->streams[k];
1544
            ist->file_index = i;
1545
            ist->index = k;
1546
            ist->discard = 1; /* the stream is discarded by default
1547
                                 (changed later) */
1548

    
1549
            if (ist->st->codec->rate_emu) {
1550
                ist->start = av_gettime();
1551
                ist->frame = 0;
1552
            }
1553
        }
1554
    }
1555

    
1556
    /* output stream init */
1557
    nb_ostreams = 0;
1558
    for(i=0;i<nb_output_files;i++) {
1559
        os = output_files[i];
1560
        nb_ostreams += os->nb_streams;
1561
    }
1562
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1563
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1564
        exit(1);
1565
    }
1566

    
1567
    /* Sanity check the mapping args -- do the input files & streams exist? */
1568
    for(i=0;i<nb_stream_maps;i++) {
1569
        int fi = stream_maps[i].file_index;
1570
        int si = stream_maps[i].stream_index;
1571
        
1572
        if (fi < 0 || fi > nb_input_files - 1 ||
1573
            si < 0 || si > file_table[fi].nb_streams - 1) {
1574
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1575
            exit(1);
1576
        }
1577
        fi = stream_maps[i].sync_file_index;
1578
        si = stream_maps[i].sync_stream_index;
1579
        if (fi < 0 || fi > nb_input_files - 1 ||
1580
            si < 0 || si > file_table[fi].nb_streams - 1) {
1581
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1582
            exit(1);
1583
        }
1584
    }
1585
    
1586
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1587
    if (!ost_table)
1588
        goto fail;
1589
    for(i=0;i<nb_ostreams;i++) {
1590
        ost = av_mallocz(sizeof(AVOutputStream));
1591
        if (!ost)
1592
            goto fail;
1593
        ost_table[i] = ost;
1594
    }
1595
    
1596
    n = 0;
1597
    for(k=0;k<nb_output_files;k++) {
1598
        os = output_files[k];
1599
        for(i=0;i<os->nb_streams;i++) {
1600
            int found;
1601
            ost = ost_table[n++];
1602
            ost->file_index = k;
1603
            ost->index = i;
1604
            ost->st = os->streams[i];
1605
            if (nb_stream_maps > 0) {
1606
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index + 
1607
                    stream_maps[n-1].stream_index;
1608
                    
1609
                /* Sanity check that the stream types match */
1610
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1611
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1612
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1613
                        ost->file_index, ost->index);
1614
                    exit(1);
1615
                }
1616
                
1617
            } else {
1618
                /* get corresponding input stream index : we select the first one with the right type */
1619
                found = 0;
1620
                for(j=0;j<nb_istreams;j++) {
1621
                    ist = ist_table[j];
1622
                    if (ist->discard && 
1623
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1624
                        ost->source_index = j;
1625
                        found = 1;
1626
                        break;
1627
                    }
1628
                }
1629
                
1630
                if (!found) {
1631
                    /* try again and reuse existing stream */
1632
                    for(j=0;j<nb_istreams;j++) {
1633
                        ist = ist_table[j];
1634
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1635
                            ost->source_index = j;
1636
                            found = 1;
1637
                        }
1638
                    }
1639
                    if (!found) {
1640
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1641
                                ost->file_index, ost->index);
1642
                        exit(1);
1643
                    }
1644
                }
1645
            }
1646
            ist = ist_table[ost->source_index];
1647
            ist->discard = 0;
1648
            ost->sync_ist = (nb_stream_maps > 0) ?
1649
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1650
                         stream_maps[n-1].sync_stream_index] : ist;
1651
        }
1652
    }
1653

    
1654
    /* for each output stream, we compute the right encoding parameters */
1655
    for(i=0;i<nb_ostreams;i++) {
1656
        ost = ost_table[i];
1657
        ist = ist_table[ost->source_index];
1658

    
1659
        codec = ost->st->codec;
1660
        icodec = ist->st->codec;
1661

    
1662
        if (ost->st->stream_copy) {
1663
            /* if stream_copy is selected, no need to decode or encode */
1664
            codec->codec_id = icodec->codec_id;
1665
            codec->codec_type = icodec->codec_type;
1666
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1667
            codec->bit_rate = icodec->bit_rate;
1668
            codec->extradata= icodec->extradata;
1669
            codec->extradata_size= icodec->extradata_size;
1670
            switch(codec->codec_type) {
1671
            case CODEC_TYPE_AUDIO:
1672
                codec->sample_rate = icodec->sample_rate;
1673
                codec->channels = icodec->channels;
1674
                codec->frame_size = icodec->frame_size;
1675
                codec->block_align= icodec->block_align;
1676
                break;
1677
            case CODEC_TYPE_VIDEO:
1678
                codec->time_base = icodec->time_base;
1679
                codec->width = icodec->width;
1680
                codec->height = icodec->height;
1681
                codec->has_b_frames = icodec->has_b_frames;
1682
                break;
1683
            case CODEC_TYPE_SUBTITLE:
1684
                break;
1685
            default:
1686
                av_abort();
1687
            }
1688
        } else {
1689
            switch(codec->codec_type) {
1690
            case CODEC_TYPE_AUDIO:
1691
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1692
                    goto fail;
1693
                
1694
                if (codec->channels == icodec->channels &&
1695
                    codec->sample_rate == icodec->sample_rate) {
1696
                    ost->audio_resample = 0;
1697
                } else {
1698
                    if (codec->channels != icodec->channels &&
1699
                        (icodec->codec_id == CODEC_ID_AC3 ||
1700
                         icodec->codec_id == CODEC_ID_DTS)) {
1701
                        /* Special case for 5:1 AC3 and DTS input */
1702
                        /* and mono or stereo output      */
1703
                        /* Request specific number of channels */
1704
                        icodec->channels = codec->channels;
1705
                        if (codec->sample_rate == icodec->sample_rate)
1706
                            ost->audio_resample = 0;
1707
                        else {
1708
                            ost->audio_resample = 1;
1709
                        }
1710
                    } else {
1711
                        ost->audio_resample = 1; 
1712
                    }
1713
                }
1714
                if(audio_sync_method>1)
1715
                    ost->audio_resample = 1;
1716

    
1717
                if(ost->audio_resample){
1718
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1719
                                                    codec->sample_rate, icodec->sample_rate);
1720
                    if(!ost->resample){
1721
                        printf("Can't resample.  Aborting.\n");
1722
                        av_abort();
1723
                    }
1724
                }
1725
                ist->decoding_needed = 1;
1726
                ost->encoding_needed = 1;
1727
                break;
1728
            case CODEC_TYPE_VIDEO:
1729
                if (codec->width == icodec->width &&
1730
                    codec->height == icodec->height &&
1731
                    frame_topBand == 0 &&
1732
                    frame_bottomBand == 0 &&
1733
                    frame_leftBand == 0 &&
1734
                    frame_rightBand == 0 && 
1735
                    frame_padtop == 0 &&
1736
                    frame_padbottom == 0 &&
1737
                    frame_padleft == 0 &&
1738
                    frame_padright == 0)
1739
                {
1740
                    ost->video_resample = 0;
1741
                    ost->video_crop = 0;
1742
                    ost->video_pad = 0;
1743
                } else if ((codec->width == icodec->width -
1744
                                (frame_leftBand + frame_rightBand)) &&
1745
                        (codec->height == icodec->height -
1746
                                (frame_topBand  + frame_bottomBand)))
1747
                {
1748
                    ost->video_resample = 0;
1749
                    ost->video_crop = 1;
1750
                    ost->topBand = frame_topBand;
1751
                    ost->leftBand = frame_leftBand;
1752
                } else if ((codec->width == icodec->width + 
1753
                                (frame_padleft + frame_padright)) &&
1754
                        (codec->height == icodec->height +
1755
                                (frame_padtop + frame_padbottom))) {
1756
                    ost->video_resample = 0;
1757
                    ost->video_crop = 0;
1758
                    ost->video_pad = 1;
1759
                    ost->padtop = frame_padtop;
1760
                    ost->padleft = frame_padleft;
1761
                    ost->padbottom = frame_padbottom;
1762
                    ost->padright = frame_padright;
1763
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1764
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1765
                                codec->width, codec->height ) )
1766
                        goto fail;
1767
                } else {
1768
                    ost->video_resample = 1;
1769
                    ost->video_crop = 0; // cropping is handled as part of resample
1770
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1771
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1772
                                         codec->width, codec->height ) )
1773
                        goto fail;
1774

    
1775
                    ost->img_resample_ctx = img_resample_full_init( 
1776
                                      ost->st->codec->width, ost->st->codec->height,
1777
                                      ist->st->codec->width, ist->st->codec->height,
1778
                                      frame_topBand, frame_bottomBand,
1779
                            frame_leftBand, frame_rightBand, 
1780
                            frame_padtop, frame_padbottom, 
1781
                            frame_padleft, frame_padright);
1782
                    
1783
                    ost->padtop = frame_padtop;
1784
                    ost->padleft = frame_padleft;
1785
                    ost->padbottom = frame_padbottom;
1786
                    ost->padright = frame_padright;
1787
                   
1788
                }
1789
                ost->encoding_needed = 1;
1790
                ist->decoding_needed = 1;
1791
                break;
1792
            case CODEC_TYPE_SUBTITLE:
1793
                ost->encoding_needed = 1;
1794
                ist->decoding_needed = 1;
1795
                break;
1796
            default:
1797
                av_abort();
1798
                break;
1799
            }
1800
            /* two pass mode */
1801
            if (ost->encoding_needed && 
1802
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1803
                char logfilename[1024];
1804
                FILE *f;
1805
                int size;
1806
                char *logbuffer;
1807
                
1808
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log", 
1809
                         pass_logfilename ? 
1810
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1811
                if (codec->flags & CODEC_FLAG_PASS1) {
1812
                    f = fopen(logfilename, "w");
1813
                    if (!f) {
1814
                        perror(logfilename);
1815
                        exit(1);
1816
                    }
1817
                    ost->logfile = f;
1818
                } else {
1819
                    /* read the log file */
1820
                    f = fopen(logfilename, "r");
1821
                    if (!f) {
1822
                        perror(logfilename);
1823
                        exit(1);
1824
                    }
1825
                    fseek(f, 0, SEEK_END);
1826
                    size = ftell(f);
1827
                    fseek(f, 0, SEEK_SET);
1828
                    logbuffer = av_malloc(size + 1);
1829
                    if (!logbuffer) {
1830
                        fprintf(stderr, "Could not allocate log buffer\n");
1831
                        exit(1);
1832
                    }
1833
                    size = fread(logbuffer, 1, size, f);
1834
                    fclose(f);
1835
                    logbuffer[size] = '\0';
1836
                    codec->stats_in = logbuffer;
1837
                }
1838
            }
1839
        }
1840
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1841
            int size= codec->width * codec->height;
1842
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1843
        }
1844
    }
1845

    
1846
    if (!bit_buffer)
1847
        bit_buffer = av_malloc(bit_buffer_size);
1848
    if (!bit_buffer)
1849
        goto fail;
1850

    
1851
    /* dump the file output parameters - cannot be done before in case
1852
       of stream copy */
1853
    for(i=0;i<nb_output_files;i++) {
1854
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1855
    }
1856

    
1857
    /* dump the stream mapping */
1858
    if (verbose >= 0) {
1859
        fprintf(stderr, "Stream mapping:\n");
1860
        for(i=0;i<nb_ostreams;i++) {
1861
            ost = ost_table[i];
1862
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1863
                    ist_table[ost->source_index]->file_index,
1864
                    ist_table[ost->source_index]->index,
1865
                    ost->file_index, 
1866
                    ost->index);
1867
            if (ost->sync_ist != ist_table[ost->source_index])
1868
                fprintf(stderr, " [sync #%d.%d]",
1869
                        ost->sync_ist->file_index,
1870
                        ost->sync_ist->index);
1871
            fprintf(stderr, "\n");
1872
        }
1873
    }
1874

    
1875
    /* open each encoder */
1876
    for(i=0;i<nb_ostreams;i++) {
1877
        ost = ost_table[i];
1878
        if (ost->encoding_needed) {
1879
            AVCodec *codec;
1880
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1881
            if (!codec) {
1882
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n", 
1883
                        ost->file_index, ost->index);
1884
                exit(1);
1885
            }
1886
            if (avcodec_open(ost->st->codec, codec) < 0) {
1887
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n", 
1888
                        ost->file_index, ost->index);
1889
                exit(1);
1890
            }
1891
            extra_size += ost->st->codec->extradata_size;
1892
        }
1893
    }
1894

    
1895
    /* open each decoder */
1896
    for(i=0;i<nb_istreams;i++) {
1897
        ist = ist_table[i];
1898
        if (ist->decoding_needed) {
1899
            AVCodec *codec;
1900
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1901
            if (!codec) {
1902
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n", 
1903
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1904
                exit(1);
1905
            }
1906
            if (avcodec_open(ist->st->codec, codec) < 0) {
1907
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n", 
1908
                        ist->file_index, ist->index);
1909
                exit(1);
1910
            }
1911
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1912
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1913
        }
1914
    }
1915

    
1916
    /* init pts */
1917
    for(i=0;i<nb_istreams;i++) {
1918
        ist = ist_table[i];
1919
        is = input_files[ist->file_index];
1920
        ist->pts = 0;
1921
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1922
        if(ist->st->start_time == AV_NOPTS_VALUE) 
1923
            ist->next_pts=0;
1924
        if(input_files_ts_offset[ist->file_index])
1925
            ist->next_pts= AV_NOPTS_VALUE;
1926
        ist->is_start = 1;
1927
    }
1928

    
1929
    /* compute buffer size max (should use a complete heuristic) */
1930
    for(i=0;i<nb_input_files;i++) {
1931
        file_table[i].buffer_size_max = 2048;
1932
    }
1933

    
1934
    /* set meta data information from input file if required */
1935
    for (i=0;i<nb_meta_data_maps;i++) {
1936
        AVFormatContext *out_file;
1937
        AVFormatContext *in_file;
1938

    
1939
        int out_file_index = meta_data_maps[i].out_file;
1940
        int in_file_index = meta_data_maps[i].in_file;
1941
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1942
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1943
            ret = -EINVAL;
1944
            goto fail;
1945
        }
1946
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1947
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1948
            ret = -EINVAL;
1949
            goto fail;
1950
        }                
1951
                 
1952
        out_file = output_files[out_file_index];
1953
        in_file = input_files[in_file_index];
1954

    
1955
        strcpy(out_file->title, in_file->title);
1956
        strcpy(out_file->author, in_file->author);
1957
        strcpy(out_file->copyright, in_file->copyright);
1958
        strcpy(out_file->comment, in_file->comment);
1959
        strcpy(out_file->album, in_file->album);
1960
        out_file->year = in_file->year;
1961
        out_file->track = in_file->track;
1962
        strcpy(out_file->genre, in_file->genre);
1963
    }
1964
        
1965
    /* open files and write file headers */
1966
    for(i=0;i<nb_output_files;i++) {
1967
        os = output_files[i];
1968
        if (av_write_header(os) < 0) {
1969
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1970
            ret = -EINVAL;
1971
            goto fail;
1972
        }
1973
    }
1974

    
1975
#ifndef CONFIG_WIN32
1976
    if ( !using_stdin && verbose >= 0) {
1977
        fprintf(stderr, "Press [q] to stop encoding\n");
1978
        url_set_interrupt_cb(decode_interrupt_cb);
1979
    }
1980
#endif
1981
    term_init();
1982

    
1983
    stream_no_data = 0;
1984
    key = -1;
1985

    
1986
    for(; received_sigterm == 0;) {
1987
        int file_index, ist_index;
1988
        AVPacket pkt;
1989
        double ipts_min;
1990
        double opts_min;
1991

    
1992
    redo:
1993
        ipts_min= 1e100;
1994
        opts_min= 1e100;
1995
        /* if 'q' pressed, exits */
1996
        if (!using_stdin) {
1997
            if (q_pressed)
1998
                break;
1999
            /* read_key() returns 0 on EOF */
2000
            key = read_key();
2001
            if (key == 'q')
2002
                break;
2003
        }
2004

    
2005
        /* select the stream that we must read now by looking at the
2006
           smallest output pts */
2007
        file_index = -1;
2008
        for(i=0;i<nb_ostreams;i++) {
2009
            double ipts, opts;
2010
            ost = ost_table[i];
2011
            os = output_files[ost->file_index];
2012
            ist = ist_table[ost->source_index];
2013
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2014
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2015
            else
2016
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2017
            ipts = (double)ist->pts;
2018
            if (!file_table[ist->file_index].eof_reached){
2019
                if(ipts < ipts_min) {
2020
                    ipts_min = ipts;
2021
                    if(input_sync ) file_index = ist->file_index;
2022
                }
2023
                if(opts < opts_min) {
2024
                    opts_min = opts;
2025
                    if(!input_sync) file_index = ist->file_index;
2026
                }
2027
            }
2028
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2029
                file_index= -1;
2030
                break;
2031
            }
2032
        }
2033
        /* if none, if is finished */
2034
        if (file_index < 0) {
2035
            break;
2036
        }
2037

    
2038
        /* finish if recording time exhausted */
2039
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2040
            break;
2041

    
2042
        /* finish if limit size exhausted */
2043
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
2044
            break;
2045

    
2046
        /* read a frame from it and output it in the fifo */
2047
        is = input_files[file_index];
2048
        if (av_read_frame(is, &pkt) < 0) {
2049
            file_table[file_index].eof_reached = 1;
2050
            if (opt_shortest) break; else continue; //
2051
        }
2052

    
2053
        if (!pkt.size) {
2054
            stream_no_data = is;
2055
        } else {
2056
            stream_no_data = 0;
2057
        }
2058
        if (do_pkt_dump) {
2059
            av_pkt_dump(stdout, &pkt, do_hex_dump);
2060
        }
2061
        /* the following test is needed in case new streams appear
2062
           dynamically in stream : we ignore them */
2063
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2064
            goto discard_packet;
2065
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2066
        ist = ist_table[ist_index];
2067
        if (ist->discard)
2068
            goto discard_packet;
2069

    
2070
//        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);
2071
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2072
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
2073
            if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
2074
                input_files_ts_offset[ist->file_index]-= delta;
2075
                if (verbose > 2)
2076
                    fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
2077
                for(i=0; i<file_table[file_index].nb_streams; i++){
2078
                    int index= file_table[file_index].ist_index + i;
2079
                    ist_table[index]->next_pts += delta;
2080
                    ist_table[index]->is_start=1;
2081
                }
2082
            }
2083
        }
2084

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

    
2088
            if (verbose >= 0)
2089
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2090
                        ist->file_index, ist->index);
2091

    
2092
            av_free_packet(&pkt);
2093
            goto redo;
2094
        }
2095

    
2096
    discard_packet:
2097
        av_free_packet(&pkt);
2098
        
2099
        /* dump report by using the output first video and audio streams */
2100
        print_report(output_files, ost_table, nb_ostreams, 0);
2101
    }
2102

    
2103
    /* at the end of stream, we must flush the decoder buffers */
2104
    for(i=0;i<nb_istreams;i++) {
2105
        ist = ist_table[i];
2106
        if (ist->decoding_needed) {
2107
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2108
        }
2109
    }
2110

    
2111
    term_exit();
2112

    
2113
    /* write the trailer if needed and close file */
2114
    for(i=0;i<nb_output_files;i++) {
2115
        os = output_files[i];
2116
        av_write_trailer(os);
2117
    }
2118

    
2119
    /* dump report by using the first video and audio streams */
2120
    print_report(output_files, ost_table, nb_ostreams, 1);
2121

    
2122
    /* close each encoder */
2123
    for(i=0;i<nb_ostreams;i++) {
2124
        ost = ost_table[i];
2125
        if (ost->encoding_needed) {
2126
            av_freep(&ost->st->codec->stats_in);
2127
            avcodec_close(ost->st->codec);
2128
        }
2129
    }
2130
    
2131
    /* close each decoder */
2132
    for(i=0;i<nb_istreams;i++) {
2133
        ist = ist_table[i];
2134
        if (ist->decoding_needed) {
2135
            avcodec_close(ist->st->codec);
2136
        }
2137
    }
2138

    
2139
    /* finished ! */
2140
    
2141
    ret = 0;
2142
 fail1:
2143
    av_freep(&bit_buffer);
2144
    av_free(file_table);
2145

    
2146
    if (ist_table) {
2147
        for(i=0;i<nb_istreams;i++) {
2148
            ist = ist_table[i];
2149
            av_free(ist);
2150
        }
2151
        av_free(ist_table);
2152
    }
2153
    if (ost_table) {
2154
        for(i=0;i<nb_ostreams;i++) {
2155
            ost = ost_table[i];
2156
            if (ost) {
2157
                if (ost->logfile) {
2158
                    fclose(ost->logfile);
2159
                    ost->logfile = NULL;
2160
                }
2161
                fifo_free(&ost->fifo); /* works even if fifo is not
2162
                                          initialized but set to zero */
2163
                av_free(ost->pict_tmp.data[0]);
2164
                if (ost->video_resample)
2165
                    img_resample_close(ost->img_resample_ctx);
2166
                if (ost->audio_resample)
2167
                    audio_resample_close(ost->resample);
2168
                av_free(ost);
2169
            }
2170
        }
2171
        av_free(ost_table);
2172
    }
2173
    return ret;
2174
 fail:
2175
    ret = -ENOMEM;
2176
    goto fail1;
2177
}
2178

    
2179
#if 0
2180
int file_read(const char *filename)
2181
{
2182
    URLContext *h;
2183
    unsigned char buffer[1024];
2184
    int len, i;
2185

2186
    if (url_open(&h, filename, O_RDONLY) < 0) {
2187
        printf("could not open '%s'\n", filename);
2188
        return -1;
2189
    }
2190
    for(;;) {
2191
        len = url_read(h, buffer, sizeof(buffer));
2192
        if (len <= 0)
2193
            break;
2194
        for(i=0;i<len;i++) putchar(buffer[i]);
2195
    }
2196
    url_close(h);
2197
    return 0;
2198
}
2199
#endif
2200

    
2201
static void opt_image_format(const char *arg)
2202
{
2203
    AVImageFormat *f;
2204
    
2205
    for(f = first_image_format; f != NULL; f = f->next) {
2206
        if (!strcmp(arg, f->name))
2207
            break;
2208
    }
2209
    if (!f) {
2210
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2211
        exit(1);
2212
    }
2213
    image_format = f;
2214
}
2215

    
2216
static void opt_format(const char *arg)
2217
{
2218
    /* compatibility stuff for pgmyuv */
2219
    if (!strcmp(arg, "pgmyuv")) {
2220
        pgmyuv_compatibility_hack=1;
2221
//        opt_image_format(arg);
2222
        arg = "image2";
2223
    }
2224

    
2225
    file_iformat = av_find_input_format(arg);
2226
    file_oformat = guess_format(arg, NULL, NULL);
2227
    if (!file_iformat && !file_oformat) {
2228
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2229
        exit(1);
2230
    }
2231
}
2232

    
2233
static void opt_video_bitrate(const char *arg)
2234
{
2235
    video_bit_rate = atoi(arg) * 1000;
2236
}
2237

    
2238
static void opt_video_bitrate_tolerance(const char *arg)
2239
{
2240
    video_bit_rate_tolerance = atoi(arg) * 1000;
2241
}
2242

    
2243
static void opt_video_bitrate_max(const char *arg)
2244
{
2245
    video_rc_max_rate = atoi(arg) * 1000;
2246
}
2247

    
2248
static void opt_video_bitrate_min(const char *arg)
2249
{
2250
    video_rc_min_rate = atoi(arg) * 1000;
2251
}
2252

    
2253
static void opt_video_buffer_size(const char *arg)
2254
{
2255
    video_rc_buffer_size = atoi(arg) * 8*1024;
2256
}
2257

    
2258
static void opt_video_rc_eq(char *arg)
2259
{
2260
    video_rc_eq = arg;
2261
}
2262

    
2263
static void opt_video_rc_override_string(char *arg)
2264
{
2265
    video_rc_override_string = arg;
2266
}
2267

    
2268

    
2269
static void opt_workaround_bugs(const char *arg)
2270
{
2271
    workaround_bugs = atoi(arg);
2272
}
2273

    
2274
static void opt_dct_algo(const char *arg)
2275
{
2276
    dct_algo = atoi(arg);
2277
}
2278

    
2279
static void opt_idct_algo(const char *arg)
2280
{
2281
    idct_algo = atoi(arg);
2282
}
2283

    
2284
static void opt_me_threshold(const char *arg)
2285
{
2286
    me_threshold = atoi(arg);
2287
}
2288

    
2289
static void opt_mb_threshold(const char *arg)
2290
{
2291
    mb_threshold = atoi(arg);
2292
}
2293

    
2294
static void opt_error_resilience(const char *arg)
2295
{
2296
    error_resilience = atoi(arg);
2297
}
2298

    
2299
static void opt_error_concealment(const char *arg)
2300
{
2301
    error_concealment = atoi(arg);
2302
}
2303

    
2304
static void opt_debug(const char *arg)
2305
{
2306
    debug = atoi(arg);
2307
    av_log_set_level(AV_LOG_DEBUG);
2308
}
2309

    
2310
static void opt_vismv(const char *arg)
2311
{
2312
    debug_mv = atoi(arg);
2313
}
2314
    
2315
static void opt_verbose(const char *arg)
2316
{
2317
    verbose = atoi(arg);
2318
    av_log_set_level(atoi(arg));
2319
}
2320

    
2321
static void opt_frame_rate(const char *arg)
2322
{
2323
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2324
        fprintf(stderr, "Incorrect frame rate\n");
2325
        exit(1);
2326
    }
2327
}
2328

    
2329
static void opt_frame_crop_top(const char *arg)
2330
{
2331
    frame_topBand = atoi(arg); 
2332
    if (frame_topBand < 0) {
2333
        fprintf(stderr, "Incorrect top crop size\n");
2334
        exit(1);
2335
    }
2336
    if ((frame_topBand % 2) != 0) {
2337
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2338
        exit(1);
2339
    }
2340
    if ((frame_topBand) >= frame_height){
2341
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2342
        exit(1);
2343
    }
2344
    frame_height -= frame_topBand;
2345
}
2346

    
2347
static void opt_frame_crop_bottom(const char *arg)
2348
{
2349
    frame_bottomBand = atoi(arg);
2350
    if (frame_bottomBand < 0) {
2351
        fprintf(stderr, "Incorrect bottom crop size\n");
2352
        exit(1);
2353
    }
2354
    if ((frame_bottomBand % 2) != 0) {
2355
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2356
        exit(1);        
2357
    }
2358
    if ((frame_bottomBand) >= frame_height){
2359
            fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2360
        exit(1);
2361
    }
2362
    frame_height -= frame_bottomBand;
2363
}
2364

    
2365
static void opt_frame_crop_left(const char *arg)
2366
{
2367
    frame_leftBand = atoi(arg);
2368
    if (frame_leftBand < 0) {
2369
        fprintf(stderr, "Incorrect left crop size\n");
2370
        exit(1);
2371
    }
2372
    if ((frame_leftBand % 2) != 0) {
2373
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2374
        exit(1);
2375
    }
2376
    if ((frame_leftBand) >= frame_width){
2377
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2378
        exit(1);
2379
    }
2380
    frame_width -= frame_leftBand;
2381
}
2382

    
2383
static void opt_frame_crop_right(const char *arg)
2384
{
2385
    frame_rightBand = atoi(arg);
2386
    if (frame_rightBand < 0) {
2387
        fprintf(stderr, "Incorrect right crop size\n");
2388
        exit(1);
2389
    }
2390
    if ((frame_rightBand % 2) != 0) {
2391
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2392
        exit(1);        
2393
    }
2394
    if ((frame_rightBand) >= frame_width){
2395
            fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2396
        exit(1);
2397
    }
2398
    frame_width -= frame_rightBand;
2399
}
2400

    
2401
static void opt_frame_size(const char *arg)
2402
{
2403
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2404
        fprintf(stderr, "Incorrect frame size\n");
2405
        exit(1);
2406
    }
2407
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2408
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2409
        exit(1);
2410
    }
2411
}
2412

    
2413

    
2414
#define SCALEBITS 10
2415
#define ONE_HALF  (1 << (SCALEBITS - 1))
2416
#define FIX(x)          ((int) ((x) * (1<<SCALEBITS) + 0.5))
2417

    
2418
#define RGB_TO_Y(r, g, b) \
2419
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2420
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2421

    
2422
#define RGB_TO_U(r1, g1, b1, shift)\
2423
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2424
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2425

    
2426
#define RGB_TO_V(r1, g1, b1, shift)\
2427
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2428
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2429

    
2430
static void opt_pad_color(const char *arg) {
2431
    /* Input is expected to be six hex digits similar to
2432
       how colors are expressed in html tags (but without the #) */
2433
    int rgb = strtol(arg, NULL, 16);
2434
    int r,g,b;
2435
    
2436
    r = (rgb >> 16); 
2437
    g = ((rgb >> 8) & 255);
2438
    b = (rgb & 255);
2439

    
2440
    padcolor[0] = RGB_TO_Y(r,g,b);
2441
    padcolor[1] = RGB_TO_U(r,g,b,0);
2442
    padcolor[2] = RGB_TO_V(r,g,b,0);
2443
}
2444

    
2445
static void opt_frame_pad_top(const char *arg)
2446
{
2447
    frame_padtop = atoi(arg); 
2448
    if (frame_padtop < 0) {
2449
        fprintf(stderr, "Incorrect top pad size\n");
2450
        exit(1);
2451
    }
2452
    if ((frame_padtop % 2) != 0) {
2453
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2454
        exit(1);
2455
    }
2456
}
2457

    
2458
static void opt_frame_pad_bottom(const char *arg)
2459
{
2460
    frame_padbottom = atoi(arg); 
2461
    if (frame_padbottom < 0) {
2462
        fprintf(stderr, "Incorrect bottom pad size\n");
2463
        exit(1);
2464
    }
2465
    if ((frame_padbottom % 2) != 0) {
2466
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2467
        exit(1);
2468
    }
2469
}
2470

    
2471

    
2472
static void opt_frame_pad_left(const char *arg)
2473
{
2474
    frame_padleft = atoi(arg); 
2475
    if (frame_padleft < 0) {
2476
        fprintf(stderr, "Incorrect left pad size\n");
2477
        exit(1);
2478
    }
2479
    if ((frame_padleft % 2) != 0) {
2480
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2481
        exit(1);
2482
    }
2483
}
2484

    
2485

    
2486
static void opt_frame_pad_right(const char *arg)
2487
{
2488
    frame_padright = atoi(arg); 
2489
    if (frame_padright < 0) {
2490
        fprintf(stderr, "Incorrect right pad size\n");
2491
        exit(1);
2492
    }
2493
    if ((frame_padright % 2) != 0) {
2494
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2495
        exit(1);
2496
    }
2497
}
2498

    
2499

    
2500
static void opt_frame_pix_fmt(const char *arg)
2501
{
2502
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2503
}
2504

    
2505
static void opt_frame_aspect_ratio(const char *arg)
2506
{
2507
    int x = 0, y = 0;
2508
    double ar = 0;
2509
    const char *p;
2510
    
2511
    p = strchr(arg, ':');
2512
    if (p) {
2513
        x = strtol(arg, (char **)&arg, 10);
2514
        if (arg == p)
2515
            y = strtol(arg+1, (char **)&arg, 10);
2516
        if (x > 0 && y > 0)
2517
            ar = (double)x / (double)y;
2518
    } else
2519
        ar = strtod(arg, (char **)&arg);
2520

    
2521
    if (!ar) {
2522
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2523
        exit(1);
2524
    }
2525
    frame_aspect_ratio = ar;
2526
}
2527

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

    
2533
static void opt_b_frames(const char *arg)
2534
{
2535
    b_frames = atoi(arg);
2536
    if (b_frames > FF_MAX_B_FRAMES) {
2537
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2538
        exit(1);
2539
    } else if (b_frames < 1) {
2540
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2541
        exit(1);
2542
    }
2543
}
2544

    
2545
static void opt_mb_decision(const char *arg)
2546
{
2547
    mb_decision = atoi(arg);
2548
}
2549

    
2550
static void opt_mb_cmp(const char *arg)
2551
{
2552
    mb_cmp = atoi(arg);
2553
}
2554

    
2555
static void opt_ildct_cmp(const char *arg)
2556
{
2557
    ildct_cmp = atoi(arg);
2558
}
2559

    
2560
static void opt_sub_cmp(const char *arg)
2561
{
2562
    sub_cmp = atoi(arg);
2563
}
2564

    
2565
static void opt_cmp(const char *arg)
2566
{
2567
    cmp = atoi(arg);
2568
}
2569

    
2570
static void opt_pre_cmp(const char *arg)
2571
{
2572
    pre_cmp = atoi(arg);
2573
}
2574

    
2575
static void opt_pre_me(const char *arg)
2576
{
2577
    pre_me = atoi(arg);
2578
}
2579

    
2580
static void opt_lumi_mask(const char *arg)
2581
{
2582
    lumi_mask = atof(arg);
2583
}
2584

    
2585
static void opt_dark_mask(const char *arg)
2586
{
2587
    dark_mask = atof(arg);
2588
}
2589

    
2590
static void opt_scplx_mask(const char *arg)
2591
{
2592
    scplx_mask = atof(arg);
2593
}
2594

    
2595
static void opt_tcplx_mask(const char *arg)
2596
{
2597
    tcplx_mask = atof(arg);
2598
}
2599

    
2600
static void opt_p_mask(const char *arg)
2601
{
2602
    p_mask = atof(arg);
2603
}
2604

    
2605
static void opt_qscale(const char *arg)
2606
{
2607
    video_qscale = atof(arg);
2608
    if (video_qscale < 0.01 ||
2609
        video_qscale > 255) {
2610
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2611
        exit(1);
2612
    }
2613
}
2614

    
2615
static void opt_qsquish(const char *arg)
2616
{
2617
    video_qsquish = atof(arg);
2618
    if (video_qsquish < 0.0 ||
2619
        video_qsquish > 99.0) {
2620
        fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2621
        exit(1);
2622
    }
2623
}
2624

    
2625
static void opt_lelim(const char *arg)
2626
{
2627
    video_lelim = atoi(arg);
2628
    if (video_lelim < -99 ||
2629
        video_lelim > 99) {
2630
        fprintf(stderr, "lelim must be >= -99 and <= 99\n");
2631
        exit(1);
2632
    }
2633
}
2634

    
2635
static void opt_celim(const char *arg)
2636
{
2637
    video_celim = atoi(arg);
2638
    if (video_celim < -99 ||
2639
        video_celim > 99) {
2640
        fprintf(stderr, "celim must be >= -99 and <= 99\n");
2641
        exit(1);
2642
    }
2643
}
2644

    
2645
static void opt_lmax(const char *arg)
2646
{
2647
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2648
}
2649

    
2650
static void opt_lmin(const char *arg)
2651
{
2652
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2653
}
2654

    
2655
static void opt_qmin(const char *arg)
2656
{
2657
    video_qmin = atoi(arg);
2658
    if (video_qmin < 1 ||
2659
        video_qmin > 31) {
2660
        fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2661
        exit(1);
2662
    }
2663
}
2664

    
2665
static void opt_qmax(const char *arg)
2666
{
2667
    video_qmax = atoi(arg);
2668
    if (video_qmax < 1 ||
2669
        video_qmax > 31) {
2670
        fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2671
        exit(1);
2672
    }
2673
}
2674

    
2675
static void opt_mb_lmin(const char *arg)
2676
{
2677
    video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2678
    if (video_mb_lmin < 1 ||
2679
        video_mb_lmin > FF_LAMBDA_MAX) {
2680
        fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2681
        exit(1);
2682
    }
2683
}
2684

    
2685
static void opt_mb_lmax(const char *arg)
2686
{
2687
    video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2688
    if (video_mb_lmax < 1 ||
2689
        video_mb_lmax > FF_LAMBDA_MAX) {
2690
        fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2691
        exit(1);
2692
    }
2693
}
2694

    
2695
static void opt_qdiff(const char *arg)
2696
{
2697
    video_qdiff = atoi(arg);
2698
    if (video_qdiff < 0 ||
2699
        video_qdiff > 31) {
2700
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2701
        exit(1);
2702
    }
2703
}
2704

    
2705
static void opt_qblur(const char *arg)
2706
{
2707
    video_qblur = atof(arg);
2708
}
2709

    
2710
static void opt_qcomp(const char *arg)
2711
{
2712
    video_qcomp = atof(arg);
2713
}
2714

    
2715
static void opt_rc_initial_cplx(const char *arg)
2716
{
2717
    video_rc_initial_cplx = atof(arg);
2718
}
2719
static void opt_b_qfactor(const char *arg)
2720
{
2721
    video_b_qfactor = atof(arg);
2722
}
2723
static void opt_i_qfactor(const char *arg)
2724
{
2725
    video_i_qfactor = atof(arg);
2726
}
2727
static void opt_b_qoffset(const char *arg)
2728
{
2729
    video_b_qoffset = atof(arg);
2730
}
2731
static void opt_i_qoffset(const char *arg)
2732
{
2733
    video_i_qoffset = atof(arg);
2734
}
2735

    
2736
static void opt_ibias(const char *arg)
2737
{
2738
    video_intra_quant_bias = atoi(arg);
2739
}
2740
static void opt_pbias(const char *arg)
2741
{
2742
    video_inter_quant_bias = atoi(arg);
2743
}
2744

    
2745
static void opt_packet_size(const char *arg)
2746
{
2747
    packet_size= atoi(arg);
2748
}
2749

    
2750
static void opt_error_rate(const char *arg)
2751
{
2752
    error_rate= atoi(arg);
2753
}
2754

    
2755
static void opt_strict(const char *arg)
2756
{
2757
    strict= atoi(arg);
2758
}
2759

    
2760
static void opt_top_field_first(const char *arg)
2761
{
2762
    top_field_first= atoi(arg);
2763
}
2764

    
2765
static void opt_noise_reduction(const char *arg)
2766
{
2767
    noise_reduction= atoi(arg);
2768
}
2769

    
2770
static void opt_qns(const char *arg)
2771
{
2772
    qns= atoi(arg);
2773
}
2774

    
2775
static void opt_sc_threshold(const char *arg)
2776
{
2777
    sc_threshold= atoi(arg);
2778
}
2779

    
2780
static void opt_me_range(const char *arg)
2781
{
2782
    me_range = atoi(arg);
2783
}
2784

    
2785
static void opt_thread_count(const char *arg)
2786
{
2787
    thread_count= atoi(arg);
2788
#if !defined(HAVE_THREADS)
2789
    if (verbose >= 0)
2790
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2791
#endif
2792
}
2793

    
2794
static void opt_audio_bitrate(const char *arg)
2795
{
2796
    audio_bit_rate = atoi(arg) * 1000;
2797
}
2798

    
2799
static void opt_audio_rate(const char *arg)
2800
{
2801
    audio_sample_rate = atoi(arg);
2802
}
2803

    
2804
static void opt_audio_channels(const char *arg)
2805
{
2806
    audio_channels = atoi(arg);
2807
}
2808

    
2809
static void opt_video_device(const char *arg)
2810
{
2811
    video_device = av_strdup(arg);
2812
}
2813

    
2814
static void opt_grab_device(const char *arg)
2815
{
2816
    grab_device = av_strdup(arg);
2817
}
2818

    
2819
static void opt_video_channel(const char *arg)
2820
{
2821
    video_channel = strtol(arg, NULL, 0);
2822
}
2823

    
2824
static void opt_video_standard(const char *arg)
2825
{
2826
    video_standard = av_strdup(arg);
2827
}
2828

    
2829
static void opt_audio_device(const char *arg)
2830
{
2831
    audio_device = av_strdup(arg);
2832
}
2833

    
2834
static void opt_codec(int *pstream_copy, int *pcodec_id,
2835
                      int codec_type, const char *arg)
2836
{
2837
    AVCodec *p;
2838

    
2839
    if (!strcmp(arg, "copy")) {
2840
        *pstream_copy = 1;
2841
    } else {
2842
        p = first_avcodec;
2843
        while (p) {
2844
            if (!strcmp(p->name, arg) && p->type == codec_type)
2845
                break;
2846
            p = p->next;
2847
        }
2848
        if (p == NULL) {
2849
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2850
            exit(1);
2851
        } else {
2852
            *pcodec_id = p->id;
2853
        }
2854
    }
2855
}
2856

    
2857
static void opt_audio_codec(const char *arg)
2858
{
2859
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2860
}
2861

    
2862
static void opt_audio_tag(const char *arg)
2863
{
2864
    char *tail;
2865
    audio_codec_tag= strtol(arg, &tail, 0);
2866

    
2867
    if(!tail || *tail)
2868
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2869
}
2870

    
2871
static void opt_video_tag(const char *arg)
2872
{
2873
    char *tail;
2874
    video_codec_tag= strtol(arg, &tail, 0);
2875

    
2876
    if(!tail || *tail)
2877
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2878
}
2879

    
2880
static void add_frame_hooker(const char *arg)
2881
{
2882
    int argc = 0;
2883
    char *argv[64];
2884
    int i;
2885
    char *args = av_strdup(arg);
2886

    
2887
    using_vhook = 1;
2888

    
2889
    argv[0] = strtok(args, " ");
2890
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2891
    }
2892

    
2893
    i = frame_hook_add(argc, argv);
2894

    
2895
    if (i != 0) {
2896
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2897
        exit(1);
2898
    }
2899
}
2900

    
2901
const char *motion_str[] = {
2902
    "zero",
2903
    "full",
2904
    "log",
2905
    "phods",
2906
    "epzs",
2907
    "x1",
2908
    NULL,
2909
};
2910

    
2911
static void opt_motion_estimation(const char *arg)
2912
{
2913
    const char **p;
2914
    p = motion_str;
2915
    for(;;) {
2916
        if (!*p) {
2917
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2918
            exit(1);
2919
        }
2920
        if (!strcmp(*p, arg))
2921
            break;
2922
        p++;
2923
    }
2924
    me_method = (p - motion_str) + 1;
2925
}
2926

    
2927
static void opt_video_codec(const char *arg)
2928
{
2929
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2930
}
2931

    
2932
static void opt_subtitle_codec(const char *arg)
2933
{
2934
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2935
}
2936

    
2937
static void opt_map(const char *arg)
2938
{
2939
    AVStreamMap *m;
2940
    const char *p;
2941

    
2942
    p = arg;
2943
    m = &stream_maps[nb_stream_maps++];
2944

    
2945
    m->file_index = strtol(arg, (char **)&p, 0);
2946
    if (*p)
2947
        p++;
2948

    
2949
    m->stream_index = strtol(p, (char **)&p, 0);
2950
    if (*p) {
2951
        p++;
2952
        m->sync_file_index = strtol(p, (char **)&p, 0);
2953
        if (*p)
2954
            p++;
2955
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2956
    } else {
2957
        m->sync_file_index = m->file_index;
2958
        m->sync_stream_index = m->stream_index;
2959
    }
2960
}
2961

    
2962
static void opt_map_meta_data(const char *arg)
2963
{
2964
    AVMetaDataMap *m;
2965
    const char *p;
2966
        
2967
    p = arg;
2968
    m = &meta_data_maps[nb_meta_data_maps++];
2969

    
2970
    m->out_file = strtol(arg, (char **)&p, 0);
2971
    if (*p)
2972
        p++;
2973

    
2974
    m->in_file = strtol(p, (char **)&p, 0);
2975
}
2976

    
2977
static void opt_recording_time(const char *arg)
2978
{
2979
    recording_time = parse_date(arg, 1);
2980
}
2981

    
2982
static void opt_start_time(const char *arg)
2983
{
2984
    start_time = parse_date(arg, 1);
2985
}
2986

    
2987
static void opt_rec_timestamp(const char *arg)
2988
{
2989
    rec_timestamp = parse_date(arg, 0) / 1000000;
2990
}
2991

    
2992
static void opt_input_ts_offset(const char *arg)
2993
{
2994
    input_ts_offset = parse_date(arg, 1);
2995
}
2996

    
2997
static void opt_input_file(const char *filename)
2998
{
2999
    AVFormatContext *ic;
3000
    AVFormatParameters params, *ap = &params;
3001
    int err, i, ret, rfps, rfps_base;
3002
    int64_t timestamp;
3003

    
3004
    if (!strcmp(filename, "-"))
3005
        filename = "pipe:";
3006

    
3007
    using_stdin |= !strncmp(filename, "pipe:", 5) || 
3008
                   !strcmp( filename, "/dev/stdin" );
3009

    
3010
    /* get default parameters from command line */
3011
    memset(ap, 0, sizeof(*ap));
3012
    ap->sample_rate = audio_sample_rate;
3013
    ap->channels = audio_channels;
3014
    ap->time_base.den = frame_rate;
3015
    ap->time_base.num = frame_rate_base;
3016
    ap->width = frame_width + frame_padleft + frame_padright;
3017
    ap->height = frame_height + frame_padtop + frame_padbottom;
3018
    ap->image_format = image_format;
3019
    ap->pix_fmt = frame_pix_fmt;
3020
    ap->device  = grab_device;
3021
    ap->channel = video_channel;
3022
    ap->standard = video_standard;
3023
    ap->video_codec_id = video_codec_id;
3024
    ap->audio_codec_id = audio_codec_id;
3025
    if(pgmyuv_compatibility_hack)
3026
        ap->video_codec_id= CODEC_ID_PGMYUV;
3027

    
3028
    /* open the input file with generic libav function */
3029
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3030
    if (err < 0) {
3031
        print_error(filename, err);
3032
        exit(1);
3033
    }
3034
    
3035
    /* If not enough info to get the stream parameters, we decode the
3036
       first frames to get it. (used in mpeg case for example) */
3037
    ret = av_find_stream_info(ic);
3038
    if (ret < 0 && verbose >= 0) {
3039
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3040
        exit(1);
3041
    }
3042

    
3043
    timestamp = start_time;
3044
    /* add the stream start time */
3045
    if (ic->start_time != AV_NOPTS_VALUE)
3046
        timestamp += ic->start_time;
3047

    
3048
    /* if seeking requested, we execute it */
3049
    if (start_time != 0) {
3050
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3051
        if (ret < 0) {
3052
            fprintf(stderr, "%s: could not seek to position %0.3f\n", 
3053
                    filename, (double)timestamp / AV_TIME_BASE);
3054
        }
3055
        /* reset seek info */
3056
        start_time = 0;
3057
    }
3058

    
3059
    /* update the current parameters so that they match the one of the input stream */
3060
    for(i=0;i<ic->nb_streams;i++) {
3061
        AVCodecContext *enc = ic->streams[i]->codec;
3062
#if defined(HAVE_THREADS)
3063
        if(thread_count>1)
3064
            avcodec_thread_init(enc, thread_count);
3065
#endif
3066
        enc->thread_count= thread_count;
3067
        switch(enc->codec_type) {
3068
        case CODEC_TYPE_AUDIO:
3069
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3070
            audio_channels = enc->channels;
3071
            audio_sample_rate = enc->sample_rate;
3072
            if(audio_disable)
3073
                ic->streams[i]->discard= AVDISCARD_ALL;
3074
            break;
3075
        case CODEC_TYPE_VIDEO:
3076
            frame_height = enc->height;
3077
            frame_width = enc->width;
3078
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
3079
            frame_pix_fmt = enc->pix_fmt;
3080
            rfps      = ic->streams[i]->r_frame_rate.num;
3081
            rfps_base = ic->streams[i]->r_frame_rate.den;
3082
            enc->workaround_bugs = workaround_bugs;
3083
            enc->error_resilience = error_resilience; 
3084
            enc->error_concealment = error_concealment; 
3085
            enc->idct_algo = idct_algo;
3086
            enc->debug = debug;
3087
            enc->debug_mv = debug_mv;            
3088
            enc->lowres= lowres;
3089
            if(lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
3090
            if(bitexact)
3091
                enc->flags|= CODEC_FLAG_BITEXACT;
3092
            if(me_threshold)
3093
                enc->debug |= FF_DEBUG_MV;
3094
            if(gray_only)
3095
                enc->flags |= CODEC_FLAG_GRAY;
3096

    
3097
            if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) { 
3098

    
3099
                if (verbose >= 0)
3100
                    fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3101
                            i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3102

    
3103
                    (float)rfps / rfps_base, rfps, rfps_base);
3104
            }
3105
            /* update the current frame rate to match the stream frame rate */
3106
            frame_rate      = rfps;
3107
            frame_rate_base = rfps_base;
3108

    
3109
            enc->rate_emu = rate_emu;
3110
            if(video_disable)
3111
                ic->streams[i]->discard= AVDISCARD_ALL;
3112
            else if(video_discard)
3113
                ic->streams[i]->discard= video_discard;
3114
            break;
3115
        case CODEC_TYPE_DATA:
3116
            break;
3117
        case CODEC_TYPE_SUBTITLE:
3118
            break;
3119
        default:
3120
            av_abort();
3121
        }
3122
    }
3123
    
3124
    input_files[nb_input_files] = ic;
3125
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3126
    /* dump the file content */
3127
    if (verbose >= 0)
3128
        dump_format(ic, nb_input_files, filename, 0);
3129

    
3130
    nb_input_files++;
3131
    file_iformat = NULL;
3132
    file_oformat = NULL;
3133
    image_format = NULL;
3134

    
3135
    grab_device = NULL;
3136
    video_channel = 0;
3137
    
3138
    rate_emu = 0;
3139
}
3140

    
3141
static void opt_grab(const char *arg)
3142
{
3143
    file_iformat = av_find_input_format(arg);
3144
    opt_input_file("");
3145
}
3146

    
3147
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3148
{
3149
    int has_video, has_audio, i, j;
3150
    AVFormatContext *ic;
3151

    
3152
    has_video = 0;
3153
    has_audio = 0;
3154
    for(j=0;j<nb_input_files;j++) {
3155
        ic = input_files[j];
3156
        for(i=0;i<ic->nb_streams;i++) {
3157
            AVCodecContext *enc = ic->streams[i]->codec;
3158
            switch(enc->codec_type) {
3159
            case CODEC_TYPE_AUDIO:
3160
                has_audio = 1;
3161
                break;
3162
            case CODEC_TYPE_VIDEO:
3163
                has_video = 1;
3164
                break;
3165
            case CODEC_TYPE_DATA:
3166
            case CODEC_TYPE_SUBTITLE:
3167
                break;
3168
            default:
3169
                av_abort();
3170
            }
3171
        }
3172
    }
3173
    *has_video_ptr = has_video;
3174
    *has_audio_ptr = has_audio;
3175
}
3176

    
3177
static void new_video_stream(AVFormatContext *oc)
3178
{
3179
    AVStream *st;
3180
    AVCodecContext *video_enc;
3181
    int codec_id;
3182
    
3183
    st = av_new_stream(oc, oc->nb_streams);
3184
    if (!st) {
3185
        fprintf(stderr, "Could not alloc stream\n");
3186
        exit(1);
3187
    }
3188
#if defined(HAVE_THREADS)
3189
    if(thread_count>1)
3190
        avcodec_thread_init(st->codec, thread_count);
3191
#endif
3192
    
3193
    video_enc = st->codec;
3194
    
3195
    if(video_codec_tag)
3196
        video_enc->codec_tag= video_codec_tag;
3197
    
3198
    if(   (video_global_header&1)
3199
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER)))
3200
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3201
    if(video_global_header&2)
3202
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3203

    
3204
    if (video_stream_copy) {
3205
        st->stream_copy = 1;
3206
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3207
    } else {
3208
        char *p;
3209
        int i;
3210
        AVCodec *codec;
3211
        
3212
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3213
        if (video_codec_id != CODEC_ID_NONE)
3214
            codec_id = video_codec_id;
3215
                
3216
        video_enc->codec_id = codec_id;
3217
        codec = avcodec_find_encoder(codec_id);
3218
                
3219
        video_enc->bit_rate = video_bit_rate;
3220
        video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3221
        video_enc->time_base.den = frame_rate; 
3222
        video_enc->time_base.num = frame_rate_base; 
3223
        if(codec && codec->supported_framerates){
3224
            const AVRational *p= codec->supported_framerates;
3225
            AVRational req= (AVRational){frame_rate, frame_rate_base};
3226
            const AVRational *best=NULL;
3227
            AVRational best_error= (AVRational){INT_MAX, 1};
3228
            for(; p->den!=0; p++){
3229
                AVRational error= av_sub_q(req, *p);
3230
                if(error.num <0) error.num *= -1;
3231
                if(av_cmp_q(error, best_error) < 0){
3232
                    best_error= error;
3233
                    best= p;
3234
                }
3235
            }
3236
            video_enc->time_base.den= best->num;
3237
            video_enc->time_base.num= best->den;
3238
        }
3239
                
3240
        video_enc->width = frame_width + frame_padright + frame_padleft;
3241
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3242
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3243
        video_enc->pix_fmt = frame_pix_fmt;
3244

    
3245
        if(codec && codec->pix_fmts){
3246
            const enum PixelFormat *p= codec->pix_fmts;
3247
            for(; *p!=-1; p++){
3248
                if(*p == video_enc->pix_fmt)
3249
                    break;
3250
            }
3251
            if(*p == -1)
3252
                video_enc->pix_fmt = codec->pix_fmts[0];
3253
        }
3254

    
3255
        if (!intra_only)
3256
            video_enc->gop_size = gop_size;
3257
        else
3258
            video_enc->gop_size = 0;
3259
        if (video_qscale || same_quality) {
3260
            video_enc->flags |= CODEC_FLAG_QSCALE;
3261
            video_enc->global_quality= 
3262
                st->quality = FF_QP2LAMBDA * video_qscale;
3263
        }
3264

    
3265
        if(intra_matrix)
3266
            video_enc->intra_matrix = intra_matrix;
3267
        if(inter_matrix)
3268
            video_enc->inter_matrix = inter_matrix;
3269

    
3270
        if(bitexact)
3271
            video_enc->flags |= CODEC_FLAG_BITEXACT;
3272

    
3273
        video_enc->mb_decision = mb_decision;
3274
        video_enc->mb_cmp = mb_cmp;
3275
        video_enc->ildct_cmp = ildct_cmp;
3276
        video_enc->me_sub_cmp = sub_cmp;
3277
        video_enc->me_cmp = cmp;
3278
        video_enc->me_pre_cmp = pre_cmp;
3279
        video_enc->pre_me = pre_me;
3280
        video_enc->lumi_masking = lumi_mask;
3281
        video_enc->dark_masking = dark_mask;
3282
        video_enc->spatial_cplx_masking = scplx_mask;
3283
        video_enc->temporal_cplx_masking = tcplx_mask;
3284
        video_enc->p_masking = p_mask;
3285
        video_enc->quantizer_noise_shaping= qns;
3286
                
3287
        if (use_umv) {
3288
            video_enc->flags |= CODEC_FLAG_H263P_UMV;
3289
        }
3290
        if (use_ss) {
3291
            video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3292
        }
3293
        if (use_aic) {
3294
            video_enc->flags |= CODEC_FLAG_H263P_AIC;
3295
        }
3296
        if (use_aiv) {
3297
            video_enc->flags |= CODEC_FLAG_H263P_AIV;
3298
        }
3299
        if (use_4mv) {
3300
            video_enc->flags |= CODEC_FLAG_4MV;
3301
        }
3302
        if (use_obmc) {
3303
            video_enc->flags |= CODEC_FLAG_OBMC;
3304
        }
3305
        if (use_loop) {
3306
            video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3307
        }
3308
            
3309
        if(use_part) {
3310
            video_enc->flags |= CODEC_FLAG_PART;
3311
        }
3312
        if (use_alt_scan) {
3313
            video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3314
        }
3315
        if (use_trell) {
3316
            video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3317
        }
3318
        if (use_mv0) {
3319
            video_enc->flags |= CODEC_FLAG_MV0;
3320
        }
3321
        if (do_normalize_aqp) {
3322
            video_enc->flags |= CODEC_FLAG_NORMALIZE_AQP;
3323
        }
3324
        if (use_scan_offset) {
3325
            video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3326
        }
3327
        if (closed_gop) {
3328
            video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3329
        }
3330
        if (strict_gop) {
3331
            video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3332
        }
3333
        if (use_qpel) {
3334
            video_enc->flags |= CODEC_FLAG_QPEL;
3335
        }
3336
        if (use_qprd) {
3337
            video_enc->flags |= CODEC_FLAG_QP_RD;
3338
        }
3339
        if (use_cbprd) {
3340
            video_enc->flags |= CODEC_FLAG_CBP_RD;
3341
        }
3342
        if (b_frames) {
3343
            video_enc->max_b_frames = b_frames;
3344
            video_enc->b_frame_strategy = b_strategy;
3345
            video_enc->b_quant_factor = 2.0;
3346
        }
3347
        if (do_interlace_dct) {
3348
            video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3349
        }
3350
        if (do_interlace_me) {
3351
            video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3352
        }
3353
        if (no_output) {
3354
            video_enc->flags2 |= CODEC_FLAG2_NO_OUTPUT;
3355
        }
3356
        if (gray_only) {
3357
            video_enc->flags |= CODEC_FLAG_GRAY;
3358
        }
3359
        video_enc->qmin = video_qmin;
3360
        video_enc->qmax = video_qmax;
3361
        video_enc->lmin = video_lmin;
3362
        video_enc->lmax = video_lmax;
3363
        video_enc->rc_qsquish = video_qsquish;
3364
        video_enc->luma_elim_threshold = video_lelim;
3365
        video_enc->chroma_elim_threshold = video_celim;
3366
        video_enc->mb_lmin = video_mb_lmin;
3367
        video_enc->mb_lmax = video_mb_lmax;
3368
        video_enc->max_qdiff = video_qdiff;
3369
        video_enc->qblur = video_qblur;
3370
        video_enc->qcompress = video_qcomp;
3371
        video_enc->rc_eq = video_rc_eq;
3372
        video_enc->debug = debug;
3373
        video_enc->debug_mv = debug_mv;
3374
        video_enc->workaround_bugs = workaround_bugs;
3375
        video_enc->thread_count = thread_count;
3376
        p= video_rc_override_string;
3377
        for(i=0; p; i++){
3378
            int start, end, q;
3379
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3380
            if(e!=3){
3381
                fprintf(stderr, "error parsing rc_override\n");
3382
                exit(1);
3383
            }
3384
            video_enc->rc_override= 
3385
                av_realloc(video_enc->rc_override, 
3386
                           sizeof(RcOverride)*(i+1));
3387
            video_enc->rc_override[i].start_frame= start;
3388
            video_enc->rc_override[i].end_frame  = end;
3389
            if(q>0){
3390
                video_enc->rc_override[i].qscale= q;
3391
                video_enc->rc_override[i].quality_factor= 1.0;
3392
            }
3393
            else{
3394
                video_enc->rc_override[i].qscale= 0;
3395
                video_enc->rc_override[i].quality_factor= -q/100.0;
3396
            }
3397
            p= strchr(p, '/');
3398
            if(p) p++;
3399
        }
3400
        video_enc->rc_override_count=i;
3401

    
3402
        video_enc->rc_max_rate = video_rc_max_rate;
3403
        video_enc->rc_min_rate = video_rc_min_rate;
3404
        video_enc->rc_buffer_size = video_rc_buffer_size;
3405
        video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3406
        video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3407
        video_enc->rc_initial_cplx= video_rc_initial_cplx;
3408
        video_enc->i_quant_factor = video_i_qfactor;
3409
        video_enc->b_quant_factor = video_b_qfactor;
3410
        video_enc->i_quant_offset = video_i_qoffset;
3411
        video_enc->b_quant_offset = video_b_qoffset;
3412
        video_enc->intra_quant_bias = video_intra_quant_bias;
3413
        video_enc->inter_quant_bias = video_inter_quant_bias;
3414
        video_enc->dct_algo = dct_algo;
3415
        video_enc->idct_algo = idct_algo;
3416
        video_enc->me_threshold= me_threshold;
3417
        video_enc->mb_threshold= mb_threshold;
3418
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3419
        video_enc->strict_std_compliance = strict;
3420
        video_enc->error_rate = error_rate;
3421
        video_enc->noise_reduction= noise_reduction;
3422
        video_enc->scenechange_threshold= sc_threshold;
3423
        video_enc->me_range = me_range;
3424
        video_enc->coder_type= coder;
3425
        video_enc->context_model= context;
3426
        video_enc->prediction_method= predictor;
3427
        video_enc->profile= video_profile;
3428
        video_enc->level= video_level;
3429
        video_enc->nsse_weight= nsse_weight;
3430
        video_enc->me_subpel_quality= subpel_quality;
3431
        video_enc->me_penalty_compensation= me_penalty_compensation;
3432
        video_enc->frame_skip_threshold= frame_skip_threshold;
3433
        video_enc->frame_skip_factor= frame_skip_factor;
3434
        video_enc->frame_skip_exp= frame_skip_exp;
3435
        video_enc->frame_skip_cmp= frame_skip_cmp;
3436

    
3437
        if(packet_size){
3438
            video_enc->rtp_mode= 1;
3439
            video_enc->rtp_payload_size= packet_size;
3440
        }
3441
            
3442
        if (do_psnr)
3443
            video_enc->flags|= CODEC_FLAG_PSNR;
3444
            
3445
        video_enc->me_method = me_method;
3446

    
3447
        /* two pass mode */
3448
        if (do_pass) {
3449
            if (do_pass == 1) {
3450
                video_enc->flags |= CODEC_FLAG_PASS1;
3451
            } else {
3452
                video_enc->flags |= CODEC_FLAG_PASS2;
3453
            }
3454
        }
3455
    }
3456

    
3457
    /* reset some key parameters */
3458
    video_disable = 0;
3459
    video_codec_id = CODEC_ID_NONE;
3460
    video_stream_copy = 0;
3461
}
3462

    
3463
static void new_audio_stream(AVFormatContext *oc)
3464
{
3465
    AVStream *st;
3466
    AVCodecContext *audio_enc;
3467
    int codec_id;
3468
            
3469
    st = av_new_stream(oc, oc->nb_streams);
3470
    if (!st) {
3471
        fprintf(stderr, "Could not alloc stream\n");
3472
        exit(1);
3473
    }
3474
#if defined(HAVE_THREADS)
3475
    if(thread_count>1)
3476
        avcodec_thread_init(st->codec, thread_count);
3477
#endif
3478
    
3479
    audio_enc = st->codec;
3480
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3481
    
3482
    if(audio_codec_tag)
3483
        audio_enc->codec_tag= audio_codec_tag;
3484
    
3485
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) 
3486
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3487
    if (audio_stream_copy) {
3488
        st->stream_copy = 1;
3489
        audio_enc->channels = audio_channels;
3490
    } else {
3491
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3492
        if (audio_codec_id != CODEC_ID_NONE)
3493
            codec_id = audio_codec_id;
3494
        audio_enc->codec_id = codec_id;
3495
        
3496
        audio_enc->bit_rate = audio_bit_rate;
3497
        audio_enc->strict_std_compliance = strict;
3498
        audio_enc->thread_count = thread_count;
3499
        /* For audio codecs other than AC3 or DTS we limit */
3500
        /* the number of coded channels to stereo   */
3501
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3502
            && codec_id != CODEC_ID_DTS) {
3503
            audio_enc->channels = 2;
3504
        } else
3505
            audio_enc->channels = audio_channels;
3506
    }
3507
    audio_enc->sample_rate = audio_sample_rate;
3508
    if (audio_language) {
3509
        pstrcpy(st->language, sizeof(st->language), audio_language);
3510
        av_free(audio_language);
3511
        audio_language = NULL;
3512
    }
3513

    
3514
    /* reset some key parameters */
3515
    audio_disable = 0;
3516
    audio_codec_id = CODEC_ID_NONE;
3517
    audio_stream_copy = 0;
3518
}
3519

    
3520
static void opt_new_subtitle_stream(void)
3521
{
3522
    AVFormatContext *oc;
3523
    AVStream *st;
3524
    AVCodecContext *subtitle_enc;
3525
            
3526
    if (nb_output_files <= 0) {
3527
        fprintf(stderr, "At least one output file must be specified\n");
3528
        exit(1);
3529
    }
3530
    oc = output_files[nb_output_files - 1];
3531

    
3532
    st = av_new_stream(oc, oc->nb_streams);
3533
    if (!st) {
3534
        fprintf(stderr, "Could not alloc stream\n");
3535
        exit(1);
3536
    }
3537

    
3538
    subtitle_enc = st->codec;
3539
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3540
    if (subtitle_stream_copy) {
3541
        st->stream_copy = 1;
3542
    } else {
3543
        subtitle_enc->codec_id = subtitle_codec_id;
3544
    }
3545

    
3546
    if (subtitle_language) {
3547
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3548
        av_free(subtitle_language);
3549
        subtitle_language = NULL;
3550
    }
3551

    
3552
    subtitle_codec_id = CODEC_ID_NONE;
3553
    subtitle_stream_copy = 0;
3554
}
3555

    
3556
static void opt_new_audio_stream(void)
3557
{
3558
    AVFormatContext *oc;
3559
    if (nb_output_files <= 0) {
3560
        fprintf(stderr, "At least one output file must be specified\n");
3561
        exit(1);
3562
    }
3563
    oc = output_files[nb_output_files - 1];
3564
    new_audio_stream(oc);
3565
}
3566

    
3567
static void opt_new_video_stream(void)
3568
{
3569
    AVFormatContext *oc;
3570
    if (nb_output_files <= 0) {
3571
        fprintf(stderr, "At least one output file must be specified\n");
3572
        exit(1);
3573
    }
3574
    oc = output_files[nb_output_files - 1];
3575
    new_video_stream(oc);
3576
}
3577

    
3578
static void opt_output_file(const char *filename)
3579
{
3580
    AVFormatContext *oc;
3581
    int use_video, use_audio, input_has_video, input_has_audio;
3582
    AVFormatParameters params, *ap = &params;
3583

    
3584
    if (!strcmp(filename, "-"))
3585
        filename = "pipe:";
3586

    
3587
    oc = av_alloc_format_context();
3588

    
3589
    if (!file_oformat) {
3590
        file_oformat = guess_format(NULL, filename, NULL);
3591
        if (!file_oformat) {
3592
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3593
                    filename);
3594
            exit(1);
3595
        }
3596
    }
3597
    
3598
    oc->oformat = file_oformat;
3599
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3600

    
3601
    if (!strcmp(file_oformat->name, "ffm") && 
3602
        strstart(filename, "http:", NULL)) {
3603
        /* special case for files sent to ffserver: we get the stream
3604
           parameters from ffserver */
3605
        if (read_ffserver_streams(oc, filename) < 0) {
3606
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3607
            exit(1);
3608
        }
3609
    } else {
3610
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
3611
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
3612

    
3613
        /* disable if no corresponding type found and at least one
3614
           input file */
3615
        if (nb_input_files > 0) {
3616
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3617
            if (!input_has_video)
3618
                use_video = 0;
3619
            if (!input_has_audio)
3620
                use_audio = 0;
3621
        }
3622

    
3623
        /* manual disable */
3624
        if (audio_disable) {
3625
            use_audio = 0;
3626
        }
3627
        if (video_disable) {
3628
            use_video = 0;
3629
        }
3630
        
3631
        if (use_video) {
3632
            new_video_stream(oc);
3633
        }
3634
    
3635
        if (use_audio) {
3636
            new_audio_stream(oc);
3637
        }
3638

    
3639
        if (!oc->nb_streams) {
3640
            fprintf(stderr, "No audio or video streams available\n");
3641
            exit(1);
3642
        }
3643

    
3644
        oc->timestamp = rec_timestamp;
3645
            
3646
        if (str_title)
3647
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3648
        if (str_author)
3649
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3650
        if (str_copyright)
3651
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3652
        if (str_comment)
3653
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3654
    }
3655

    
3656
    output_files[nb_output_files++] = oc;
3657

    
3658
    /* check filename in case of an image number is expected */
3659
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3660
        if (filename_number_test(oc->filename) < 0) {
3661
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3662
            exit(1);
3663
        }
3664
    }
3665

    
3666
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3667
        /* test if it already exists to avoid loosing precious files */
3668
        if (!file_overwrite && 
3669
            (strchr(filename, ':') == NULL ||
3670
             strstart(filename, "file:", NULL))) {
3671
            if (url_exist(filename)) {
3672
                int c;
3673
                
3674
                if ( !using_stdin ) {
3675
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3676
                    fflush(stderr);
3677
                    c = getchar();
3678
                    if (toupper(c) != 'Y') {
3679
                        fprintf(stderr, "Not overwriting - exiting\n");
3680
                        exit(1);
3681
                    }
3682
                                }
3683
                                else {
3684
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3685
                    exit(1);
3686
                                }
3687
            }
3688
        }
3689
        
3690
        /* open the file */
3691
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3692
            fprintf(stderr, "Could not open '%s'\n", filename);
3693
            exit(1);
3694
        }
3695
    }
3696

    
3697
    memset(ap, 0, sizeof(*ap));
3698
    ap->image_format = image_format;
3699
    if (av_set_parameters(oc, ap) < 0) {
3700
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3701
                oc->filename);
3702
        exit(1);
3703
    }
3704

    
3705
    oc->packet_size= mux_packet_size;
3706
    oc->mux_rate= mux_rate;
3707
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3708
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3709
    oc->loop_output = loop_output;
3710

    
3711
    /* reset some options */
3712
    file_oformat = NULL;
3713
    file_iformat = NULL;
3714
    image_format = NULL;
3715
}
3716

    
3717
/* prepare dummy protocols for grab */
3718
static void prepare_grab(void)
3719
{
3720
    int has_video, has_audio, i, j;
3721
    AVFormatContext *oc;
3722
    AVFormatContext *ic;
3723
    AVFormatParameters vp1, *vp = &vp1;
3724
    AVFormatParameters ap1, *ap = &ap1;
3725
    
3726
    /* see if audio/video inputs are needed */
3727
    has_video = 0;
3728
    has_audio = 0;
3729
    memset(ap, 0, sizeof(*ap));
3730
    memset(vp, 0, sizeof(*vp));
3731
    vp->time_base.num= 1;
3732
    for(j=0;j<nb_output_files;j++) {
3733
        oc = output_files[j];
3734
        for(i=0;i<oc->nb_streams;i++) {
3735
            AVCodecContext *enc = oc->streams[i]->codec;
3736
            switch(enc->codec_type) {
3737
            case CODEC_TYPE_AUDIO:
3738
                if (enc->sample_rate > ap->sample_rate)
3739
                    ap->sample_rate = enc->sample_rate;
3740
                if (enc->channels > ap->channels)
3741
                    ap->channels = enc->channels;
3742
                has_audio = 1;
3743
                break;
3744
            case CODEC_TYPE_VIDEO:
3745
                if (enc->width > vp->width)
3746
                    vp->width = enc->width;
3747
                if (enc->height > vp->height)
3748
                    vp->height = enc->height;
3749
                
3750
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3751
                    vp->time_base = enc->time_base;
3752
                }
3753
                has_video = 1;
3754
                break;
3755
            default:
3756
                av_abort();
3757
            }
3758
        }
3759
    }
3760
    
3761
    if (has_video == 0 && has_audio == 0) {
3762
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3763
        exit(1);
3764
    }
3765
    
3766
    if (has_video) {
3767
        AVInputFormat *fmt1;
3768
        fmt1 = av_find_input_format(video_grab_format);
3769
        vp->device  = video_device;
3770
        vp->channel = video_channel;
3771
        vp->standard = video_standard;
3772
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3773
            fprintf(stderr, "Could not find video grab device\n");
3774
            exit(1);
3775
        }
3776
        /* If not enough info to get the stream parameters, we decode the
3777
           first frames to get it. */
3778
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3779
            fprintf(stderr, "Could not find video grab parameters\n");
3780
            exit(1);
3781
        }
3782
        /* by now video grab has one stream */
3783
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3784
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3785
        input_files[nb_input_files] = ic;
3786

    
3787
        if (verbose >= 0)
3788
            dump_format(ic, nb_input_files, "", 0);
3789

    
3790
        nb_input_files++;
3791
    }
3792
    if (has_audio && audio_grab_format) {
3793
        AVInputFormat *fmt1;
3794
        fmt1 = av_find_input_format(audio_grab_format);
3795
        ap->device = audio_device;
3796
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3797
            fprintf(stderr, "Could not find audio grab device\n");
3798
            exit(1);
3799
        }
3800
        input_files[nb_input_files] = ic;
3801

    
3802
        if (verbose >= 0)
3803
            dump_format(ic, nb_input_files, "", 0);
3804

    
3805
        nb_input_files++;
3806
    }
3807
}
3808

    
3809
/* same option as mencoder */
3810
static void opt_pass(const char *pass_str)
3811
{
3812
    int pass;
3813
    pass = atoi(pass_str);
3814
    if (pass != 1 && pass != 2) {
3815
        fprintf(stderr, "pass number can be only 1 or 2\n");
3816
        exit(1);
3817
    }
3818
    do_pass = pass;
3819
}
3820

    
3821
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3822
static int64_t getutime(void)
3823
{
3824
  return av_gettime();
3825
}
3826
#else
3827
static int64_t getutime(void)
3828
{
3829
    struct rusage rusage;
3830

    
3831
    getrusage(RUSAGE_SELF, &rusage);
3832
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3833
}
3834
#endif
3835

    
3836
extern int ffm_nopts;
3837

    
3838
static void opt_bitexact(void)
3839
{
3840
    bitexact=1;
3841
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3842
    ffm_nopts = 1;
3843
}
3844

    
3845
static void show_formats(void)
3846
{
3847
    AVInputFormat *ifmt;
3848
    AVOutputFormat *ofmt;
3849
    AVImageFormat *image_fmt;
3850
    URLProtocol *up;
3851
    AVCodec *p, *p2;
3852
    const char **pp, *last_name;
3853

    
3854
    printf("File formats:\n");
3855
    last_name= "000";
3856
    for(;;){
3857
        int decode=0;
3858
        int encode=0;
3859
        const char *name=NULL;
3860
        const char *long_name=NULL;
3861

    
3862
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3863
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3864
                strcmp(ofmt->name, last_name)>0){
3865
                name= ofmt->name;
3866
                long_name= ofmt->long_name;
3867
                encode=1;
3868
            }
3869
        }
3870
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3871
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3872
                strcmp(ifmt->name, last_name)>0){
3873
                name= ifmt->name;
3874
                long_name= ifmt->long_name;
3875
                encode=0;
3876
            }
3877
            if(name && strcmp(ifmt->name, name)==0)
3878
                decode=1;
3879
        }
3880
        if(name==NULL)
3881
            break;
3882
        last_name= name;
3883
        
3884
        printf(
3885
            " %s%s %-15s %s\n", 
3886
            decode ? "D":" ", 
3887
            encode ? "E":" ", 
3888
            name,
3889
            long_name ? long_name:" ");
3890
    }
3891
    printf("\n");
3892

    
3893
    printf("Image formats (filename extensions, if any, follow):\n");
3894
    for(image_fmt = first_image_format; image_fmt != NULL; 
3895
        image_fmt = image_fmt->next) {
3896
        printf(
3897
            " %s%s %-6s %s\n",
3898
            image_fmt->img_read  ? "D":" ",
3899
            image_fmt->img_write ? "E":" ",
3900
            image_fmt->name,
3901
            image_fmt->extensions ? image_fmt->extensions:" ");
3902
    }
3903
    printf("\n");
3904

    
3905
    printf("Codecs:\n");
3906
    last_name= "000";
3907
    for(;;){
3908
        int decode=0;
3909
        int encode=0;
3910
        int cap=0;
3911
        const char *type_str;
3912

    
3913
        p2=NULL;
3914
        for(p = first_avcodec; p != NULL; p = p->next) {
3915
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3916
                strcmp(p->name, last_name)>0){
3917
                p2= p;
3918
                decode= encode= cap=0;
3919
            }
3920
            if(p2 && strcmp(p->name, p2->name)==0){
3921
                if(p->decode) decode=1;
3922
                if(p->encode) encode=1;
3923
                cap |= p->capabilities;
3924
            }
3925
        }
3926
        if(p2==NULL)
3927
            break;
3928
        last_name= p2->name;
3929
        
3930
        switch(p2->type) {
3931
        case CODEC_TYPE_VIDEO:
3932
            type_str = "V";
3933
            break;
3934
        case CODEC_TYPE_AUDIO:
3935
            type_str = "A";
3936
            break;
3937
        case CODEC_TYPE_SUBTITLE:
3938
            type_str = "S";
3939
            break;
3940
        default:
3941
            type_str = "?";
3942
            break;
3943
        }
3944
        printf(
3945
            " %s%s%s%s%s%s %s", 
3946
            decode ? "D": (/*p2->decoder ? "d":*/" "), 
3947
            encode ? "E":" ", 
3948
            type_str,
3949
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3950
            cap & CODEC_CAP_DR1 ? "D":" ",
3951
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3952
            p2->name);
3953
       /* if(p2->decoder && decode==0)
3954
            printf(" use %s for decoding", p2->decoder->name);*/
3955
        printf("\n");
3956
    }
3957
    printf("\n");
3958

    
3959
    printf("Supported file protocols:\n");
3960
    for(up = first_protocol; up != NULL; up = up->next)
3961
        printf(" %s:", up->name);
3962
    printf("\n");
3963
    
3964
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3965
    printf("Motion estimation methods:\n");
3966
    pp = motion_str;
3967
    while (*pp) {
3968
        printf(" %s", *pp);
3969
        if ((pp - motion_str + 1) == ME_ZERO) 
3970
            printf("(fastest)");
3971
        else if ((pp - motion_str + 1) == ME_FULL) 
3972
            printf("(slowest)");
3973
        else if ((pp - motion_str + 1) == ME_EPZS) 
3974
            printf("(default)");
3975
        pp++;
3976
    }
3977
    printf("\n\n");
3978
    printf(
3979
"Note, the names of encoders and decoders dont always match, so there are\n"
3980
"several cases where the above table shows encoder only or decoder only entries\n"
3981
"even though both encoding and decoding are supported for example, the h263\n"
3982
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3983
"worse\n");
3984
    exit(1);
3985
}
3986

    
3987
void parse_matrix_coeffs(uint16_t *dest, const char *str)
3988
{
3989
    int i;
3990
    const char *p = str;
3991
    for(i = 0;; i++) {
3992
        dest[i] = atoi(p);
3993
        if(i == 63)
3994
            break;
3995
        p = strchr(p, ',');
3996
        if(!p) {
3997
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3998
            exit(1);
3999
        }
4000
        p++;
4001
    }
4002
}
4003

    
4004
void opt_inter_matrix(const char *arg)
4005
{
4006
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4007
    parse_matrix_coeffs(inter_matrix, arg);
4008
}
4009

    
4010
void opt_intra_matrix(const char *arg)
4011
{
4012
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4013
    parse_matrix_coeffs(intra_matrix, arg);
4014
}
4015

    
4016
static void opt_target(const char *arg)
4017
{
4018
    int norm = -1;
4019
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4020

    
4021
    if(!strncmp(arg, "pal-", 4)) {
4022
        norm = 0;
4023
        arg += 4;
4024
    } else if(!strncmp(arg, "ntsc-", 5)) {
4025
        norm = 1;
4026
        arg += 5;
4027
    } else if(!strncmp(arg, "film-", 5)) {
4028
        norm = 2;
4029
        arg += 5;
4030
    } else {
4031
        int fr;
4032
        /* Calculate FR via float to avoid int overflow */
4033
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
4034
        if(fr == 25000) {
4035
            norm = 0;
4036
        } else if((fr == 29970) || (fr == 23976)) {
4037
            norm = 1;
4038
        } else {
4039
            /* Try to determine PAL/NTSC by peeking in the input files */
4040
            if(nb_input_files) {
4041
                int i, j;
4042
                for(j = 0; j < nb_input_files; j++) {
4043
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4044
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4045
                        if(c->codec_type != CODEC_TYPE_VIDEO)
4046
                            continue;
4047
                        fr = c->time_base.den * 1000 / c->time_base.num;
4048
                        if(fr == 25000) {
4049
                            norm = 0;
4050
                            break;
4051
                        } else if((fr == 29970) || (fr == 23976)) {
4052
                            norm = 1;
4053
                            break;
4054
                        }
4055
                    }
4056
                    if(norm >= 0)
4057
                        break;
4058
                }
4059
            }
4060
        }
4061
        if(verbose && norm >= 0)
4062
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
4063
    }
4064

    
4065
    if(norm < 0) {
4066
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4067
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4068
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4069
        exit(1);
4070
    }
4071

    
4072
    if(!strcmp(arg, "vcd")) {
4073

    
4074
        opt_video_codec("mpeg1video");
4075
        opt_audio_codec("mp2");
4076
        opt_format("vcd");
4077

    
4078
        opt_frame_size(norm ? "352x240" : "352x288");
4079
        opt_frame_rate(frame_rates[norm]);
4080
        opt_gop_size(norm ? "18" : "15");
4081

    
4082
        video_bit_rate = 1150000;
4083
        video_rc_max_rate = 1150000;
4084
        video_rc_min_rate = 1150000;
4085
        video_rc_buffer_size = 40*1024*8;
4086

    
4087
        audio_bit_rate = 224000;
4088
        audio_sample_rate = 44100;
4089
        
4090
        mux_packet_size= 2324;
4091
        mux_rate= 2352 * 75 * 8;
4092

    
4093
        /* We have to offset the PTS, so that it is consistent with the SCR.
4094
           SCR starts at 36000, but the first two packs contain only padding
4095
           and the first pack from the other stream, respectively, may also have
4096
           been written before.
4097
           So the real data starts at SCR 36000+3*1200. */
4098
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4099
    } else if(!strcmp(arg, "svcd")) {
4100

    
4101
        opt_video_codec("mpeg2video");
4102
        opt_audio_codec("mp2");
4103
        opt_format("svcd");
4104

    
4105
        opt_frame_size(norm ? "480x480" : "480x576");
4106
        opt_frame_rate(frame_rates[norm]);
4107
        opt_gop_size(norm ? "18" : "15");
4108

    
4109
        video_bit_rate = 2040000;
4110
        video_rc_max_rate = 2516000;
4111
        video_rc_min_rate = 0; //1145000;
4112
        video_rc_buffer_size = 224*1024*8;
4113
        use_scan_offset = 1;
4114

    
4115
        audio_bit_rate = 224000;
4116
        audio_sample_rate = 44100;
4117

    
4118
        mux_packet_size= 2324;
4119

    
4120
    } else if(!strcmp(arg, "dvd")) {
4121

    
4122
        opt_video_codec("mpeg2video");
4123
        opt_audio_codec("ac3");
4124
        opt_format("dvd");
4125

    
4126
        opt_frame_size(norm ? "720x480" : "720x576");
4127
        opt_frame_rate(frame_rates[norm]);
4128
        opt_gop_size(norm ? "18" : "15");
4129

    
4130
        video_bit_rate = 6000000;
4131
        video_rc_max_rate = 9000000;
4132
        video_rc_min_rate = 0; //1500000;
4133
        video_rc_buffer_size = 224*1024*8;
4134

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

    
4138
        audio_bit_rate = 448000;
4139
        audio_sample_rate = 48000;
4140

    
4141
    } else if(!strcmp(arg, "dv")) {
4142

    
4143
        opt_format("dv");
4144

    
4145
        opt_frame_size(norm ? "720x480" : "720x576");
4146
        opt_frame_rate(frame_rates[norm]);
4147

    
4148
        audio_sample_rate = 48000;
4149
        audio_channels = 2;
4150

    
4151
    } else {
4152
        fprintf(stderr, "Unknown target: %s\n", arg);
4153
        exit(1);
4154
    }
4155
}
4156

    
4157
static void show_version(void)
4158
{
4159
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
4160
           "libavcodec  %d\n"
4161
           "libavformat %d\n", 
4162
           avcodec_build(), LIBAVFORMAT_BUILD);
4163
    exit(1);
4164
}
4165

    
4166
const OptionDef options[] = {
4167
    /* main options */
4168
    { "L", 0, {(void*)show_license}, "show license" },
4169
    { "h", 0, {(void*)show_help}, "show help" },
4170
    { "version", 0, {(void*)show_version}, "show version" },
4171
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
4172
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4173
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
4174
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4175
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4176
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4177
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4178
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
4179
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4180
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4181
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4182
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4183
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4184
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4185
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4186
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4187
    { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
4188
    { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
4189
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, 
4190
      "add timings for benchmarking" },
4191
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, 
4192
      "dump each input packet" },
4193
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, 
4194
      "when dumping packets, also dump the payload" },
4195
    { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" }, 
4196
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4197
    { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4198
    { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4199
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4200
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4201
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4202
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4203
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4204
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4205
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4206
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4207

    
4208
    /* video options */
4209
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4210
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4211
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4212
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4213
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4214
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4215
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4216
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4217
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4218
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4219
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4220
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4221
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4222
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4223
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4224
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4225
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4226
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4227
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4228
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4229
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4230
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4231
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4232
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4233
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4234
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4235
    { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4236
    { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4237
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4238
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4239
    { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
4240
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4241
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4242
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4243
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4244
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4245
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4246
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4247
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4248
    { "b_strategy", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&b_strategy}, "dynamic b frame selection strategy", "strategy" },
4249
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4250
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4251
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4252
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4253
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4254
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4255
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4256
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method", 
4257
      "method" },
4258
    { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo",  "algo" },
4259
    { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo",  "algo" },
4260
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
4261
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
4262
    { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience",  "n" },
4263
    { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment",  "bit_mask" },
4264
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4265
    { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
4266
    { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
4267
    { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
4268
    { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
4269
    { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
4270
    { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
4271
    { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
4272
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4273
    { "lelim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lelim}, "single coefficient elimination threshold for luminance (negative values also consider DC coefficient)", "elim" },
4274
    { "celim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_celim}, "single coefficient elimination threshold for chrominance (negative values also consider DC coefficient)", "elim" },
4275
    { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
4276
    { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
4277
    { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
4278
    { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
4279
    { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
4280
    { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
4281
    { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
4282
    { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
4283
    { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
4284
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4285
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4286
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4287
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4288
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality}, 
4289
      "use same video quality as source (implies VBR)" },
4290
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4291
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4292
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 
4293
      "deinterlace pictures" },
4294
    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 
4295
      "force interlaced dct support in encoder (MPEG2/MPEG4)" },
4296
    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 
4297
      "force interlaced me support in encoder (MPEG2/MPEG4)" },
4298
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4299
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 
4300
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4301
    { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
4302
    { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
4303
    { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
4304
    { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
4305
    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
4306
    { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
4307
    { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
4308
    { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
4309
    { "mv0", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_mv0}, "try to encode each MB with MV=<0,0> and choose the better one (has no effect if mbd=0)" },
4310
    { "naq", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_normalize_aqp}, "normalize adaptive quantization" },
4311
    { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
4312
    { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
4313
    { "noout", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&no_output}, "skip bitstream encoding" },
4314
    { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
4315
    { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
4316
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4317
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4318
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4319
    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
4320
    { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
4321
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4322
    { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4323
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4324
    { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
4325
    { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
4326
    { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
4327
    { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
4328
    { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
4329
    { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
4330
    { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
4331
    { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4332
    { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
4333
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4334
    { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4335
    { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4336
    { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4337
    { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
4338
    { "gray", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&gray_only }, "encode/decode grayscale" },
4339
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4340

    
4341
    /* audio options */
4342
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4343
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4344
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4345
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4346
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4347
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4348
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4349
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4350
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4351

    
4352
    /* subtitle options */
4353
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4354
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4355
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4356
    
4357
    /* grab options */
4358
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4359
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4360
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4361
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4362

    
4363
    /* G.2 grab options */ 
4364
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4365
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4366
 
4367
    /* muxer options */   
4368
    { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4369
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4370
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4371
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4372
    { NULL, },
4373
};
4374

    
4375
static void show_banner(void)
4376
{
4377
    fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4378
        LIBAVCODEC_BUILD);
4379
    fprintf(stderr, "  configuration: %s\n", FFMPEG_CONFIGURATION);
4380
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4381
#ifdef __GNUC__
4382
    fprintf(stderr, ", gcc: %s\n", __VERSION__);
4383
#else
4384
    fprintf(stderr, ", using a non-gcc compiler\n");
4385
#endif
4386
}
4387

    
4388
static void show_license(void)
4389
{
4390
    show_banner();
4391
#ifdef CONFIG_GPL
4392
    printf(
4393
    "This program is free software; you can redistribute it and/or modify\n"   
4394
    "it under the terms of the GNU General Public License as published by\n"
4395
    "the Free Software Foundation; either version 2 of the License, or\n"
4396
    "(at your option) any later version.\n"
4397
    "\n"
4398
    "This program is distributed in the hope that it will be useful,\n"
4399
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4400
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4401
    "GNU General Public License for more details.\n"
4402
    "\n"
4403
    "You should have received a copy of the GNU General Public License\n"
4404
    "along with this program; if not, write to the Free Software\n"
4405
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4406
    );
4407
#else
4408
    printf(
4409
    "This library is free software; you can redistribute it and/or\n"
4410
    "modify it under the terms of the GNU Lesser General Public\n"
4411
    "License as published by the Free Software Foundation; either\n"
4412
    "version 2 of the License, or (at your option) any later version.\n"
4413
    "\n"
4414
    "This library is distributed in the hope that it will be useful,\n"
4415
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4416
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4417
    "Lesser General Public License for more details.\n"
4418
    "\n"
4419
    "You should have received a copy of the GNU Lesser General Public\n"
4420
    "License along with this library; if not, write to the Free Software\n"
4421
    "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
4422
    );
4423
#endif
4424
    exit(1);
4425
}
4426

    
4427
static void show_help(void)
4428
{
4429
    show_banner();
4430
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4431
           "Hyper fast Audio and Video encoder\n");
4432
    printf("\n");
4433
    show_help_options(options, "Main options:\n",
4434
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4435
    show_help_options(options, "\nVideo options:\n",
4436
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4437
                      OPT_VIDEO);
4438
    show_help_options(options, "\nAdvanced Video options:\n",
4439
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4440
                      OPT_VIDEO | OPT_EXPERT);
4441
    show_help_options(options, "\nAudio options:\n",
4442
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4443
                      OPT_AUDIO);
4444
    show_help_options(options, "\nAdvanced Audio options:\n",
4445
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4446
                      OPT_AUDIO | OPT_EXPERT);
4447
    show_help_options(options, "\nSubtitle options:\n",
4448
                      OPT_SUBTITLE | OPT_GRAB, 
4449
                      OPT_SUBTITLE);
4450
    show_help_options(options, "\nAudio/Video grab options:\n",
4451
                      OPT_GRAB, 
4452
                      OPT_GRAB);
4453
    show_help_options(options, "\nAdvanced options:\n",
4454
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB, 
4455
                      OPT_EXPERT);
4456
    exit(1);
4457
}
4458

    
4459
void parse_arg_file(const char *filename)