Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 023857be

History | View | Annotate | Download (148 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
#include "opt.h"
25

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

    
43
#include "cmdutils.h"
44

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

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

    
52
/* select an input stream for an output stream */
53
typedef struct AVStreamMap {
54
    int file_index;
55
    int stream_index;
56
    int sync_file_index;
57
    int sync_stream_index;
58
} AVStreamMap;
59

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

    
66
extern const OptionDef options[];
67

    
68
static void show_help(void);
69
static void show_license(void);
70
static int opt_default(const char *opt, const char *arg);
71

    
72
#define MAX_FILES 20
73

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

    
78
static AVFormatContext *output_files[MAX_FILES];
79
static int nb_output_files = 0;
80

    
81
static AVStreamMap stream_maps[MAX_FILES];
82
static int nb_stream_maps;
83

    
84
static AVMetaDataMap meta_data_maps[MAX_FILES];
85
static int nb_meta_data_maps;
86

    
87
static AVInputFormat *file_iformat;
88
static AVOutputFormat *file_oformat;
89
static AVImageFormat *image_format;
90
static int frame_width  = 0;
91
static int frame_height = 0;
92
static float frame_aspect_ratio = 0;
93
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
94
static int frame_padtop  = 0;
95
static int frame_padbottom = 0;
96
static int frame_padleft  = 0;
97
static int frame_padright = 0;
98
static int padcolor[3] = {16,128,128}; /* default to black */
99
static int frame_topBand  = 0;
100
static int frame_bottomBand = 0;
101
static int frame_leftBand  = 0;
102
static int frame_rightBand = 0;
103
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
104
static int frame_rate = 25;
105
static int frame_rate_base = 1;
106
static int video_bit_rate = 200*1000;
107
static int video_bit_rate_tolerance = 4000*1000;
108
static float video_qscale = 0;
109
static int video_qmin = 2;
110
static int video_qmax = 31;
111
static int video_lmin = 2*FF_QP2LAMBDA;
112
static int video_lmax = 31*FF_QP2LAMBDA;
113
static int video_mb_lmin = 2*FF_QP2LAMBDA;
114
static int video_mb_lmax = 31*FF_QP2LAMBDA;
115
static int video_qdiff = 3;
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 pre_me = 0;
147
static int do_deinterlace = 0;
148
static int workaround_bugs = FF_BUG_AUTODETECT;
149
static int packet_size = 0;
150
static int error_rate = 0;
151
static int strict = 0;
152
static int top_field_first = -1;
153
static int sc_threshold = 0;
154
static int me_threshold = 0;
155
static int mb_threshold = 0;
156
static int intra_dc_precision = 8;
157
static int me_penalty_compensation= 256;
158
static int frame_skip_threshold= 0;
159
static int frame_skip_factor= 0;
160
static int frame_skip_exp= 0;
161
extern int loop_input; /* currently a hack */
162
static int loop_output = AVFMT_NOOUTPUTLOOP;
163
static int genpts = 0;
164
static int qp_hist = 0;
165

    
166
static int gop_size = 12;
167
static int intra_only = 0;
168
static int audio_sample_rate = 44100;
169
static int audio_bit_rate = 64000;
170
#define QSCALE_NONE -99999
171
static float audio_qscale = QSCALE_NONE;
172
static int audio_disable = 0;
173
static int audio_channels = 1;
174
static int audio_codec_id = CODEC_ID_NONE;
175
static int audio_codec_tag = 0;
176
static char *audio_language = NULL;
177

    
178
static int subtitle_codec_id = CODEC_ID_NONE;
179
static char *subtitle_language = NULL;
180

    
181
static int mux_rate= 0;
182
static int mux_packet_size= 0;
183
static float mux_preload= 0.5;
184
static float mux_max_delay= 0.7;
185

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

    
211
static int rate_emu = 0;
212

    
213
#ifdef CONFIG_BKTR
214
static char *video_grab_format = "bktr";
215
#else
216
#ifdef CONFIG_VIDEO4LINUX2
217
static char *video_grab_format = "video4linux2";
218
#else
219
static char *video_grab_format = "video4linux";
220
#endif
221
#endif
222
static char *video_device = NULL;
223
static char *grab_device = NULL;
224
static int  video_channel = 0;
225
static char *video_standard = "ntsc";
226

    
227
static char *audio_grab_format = "audio_device";
228
static char *audio_device = NULL;
229
static int audio_volume = 256;
230

    
231
static int using_stdin = 0;
232
static int using_vhook = 0;
233
static int verbose = 1;
234
static int thread_count= 1;
235
static int q_pressed = 0;
236
static int me_range = 0;
237
static int64_t video_size = 0;
238
static int64_t audio_size = 0;
239
static int64_t extra_size = 0;
240
static int nb_frames_dup = 0;
241
static int nb_frames_drop = 0;
242
static int input_sync;
243
static int limit_filesize = 0; //
244

    
245
static int pgmyuv_compatibility_hack=0;
246
static int dts_delta_threshold = 10;
247

    
248
const char **opt_names=NULL;
249
int opt_name_count=0;
250
AVCodecContext *avctx_opts;
251

    
252

    
253
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
254

    
255
struct AVInputStream;
256

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

    
274
    int video_crop;          /* video_resample and video_crop are mutually exclusive */
275
    int topBand;             /* cropping area sizes */
276
    int leftBand;
277

    
278
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
279
    int padtop;              /* padding area sizes */
280
    int padbottom;
281
    int padleft;
282
    int padright;
283

    
284
    /* audio only */
285
    int audio_resample;
286
    ReSampleContext *resample; /* for audio resampling */
287
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
288
    FILE *logfile;
289
} AVOutputStream;
290

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

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

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

    
316
#ifndef CONFIG_WIN32
317

    
318
/* init terminal so that we can grab keys */
319
static struct termios oldtty;
320

    
321
static void term_exit(void)
322
{
323
    tcsetattr (0, TCSANOW, &oldtty);
324
}
325

    
326
static volatile sig_atomic_t received_sigterm = 0;
327

    
328
static void
329
sigterm_handler(int sig)
330
{
331
    received_sigterm = sig;
332
    term_exit();
333
}
334

    
335
static void term_init(void)
336
{
337
    struct termios tty;
338

    
339
    tcgetattr (0, &tty);
340
    oldtty = tty;
341

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

    
351
    tcsetattr (0, TCSANOW, &tty);
352

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

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

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

    
385
        return n;
386
    }
387
    return -1;
388
}
389

    
390
static int decode_interrupt_cb(void)
391
{
392
    return q_pressed || (q_pressed = read_key() == 'q');
393
}
394

    
395
#else
396

    
397
static volatile int received_sigterm = 0;
398

    
399
/* no interactive support */
400
static void term_exit(void)
401
{
402
}
403

    
404
static void term_init(void)
405
{
406
}
407

    
408
static int read_key(void)
409
{
410
    return 0;
411
}
412

    
413
#endif
414

    
415
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
416
{
417
    int i, err;
418
    AVFormatContext *ic;
419

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

    
428
        // FIXME: a more elegant solution is needed
429
        st = av_mallocz(sizeof(AVStream));
430
        memcpy(st, ic->streams[i], sizeof(AVStream));
431
        st->codec = avcodec_alloc_context();
432
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
433
        s->streams[i] = st;
434
    }
435

    
436
    av_close_input_file(ic);
437
    return 0;
438
}
439

    
440
static double
441
get_sync_ipts(const AVOutputStream *ost)
442
{
443
    const AVInputStream *ist = ost->sync_ist;
444
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
445
}
446

    
447
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
448

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

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

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

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

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

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

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

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

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

    
534
        frame_bytes = enc->frame_size * 2 * enc->channels;
535

    
536
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
537
                     &ost->fifo.rptr) == 0) {
538
            AVPacket pkt;
539
            av_init_packet(&pkt);
540

    
541
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
542
                                       (short *)audio_buf);
543
            audio_size += ret;
544
            pkt.stream_index= ost->index;
545
            pkt.data= audio_out;
546
            pkt.size= ret;
547
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
548
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
549
            pkt.flags |= PKT_FLAG_KEY;
550
            av_interleaved_write_frame(s, &pkt);
551

    
552
            ost->sync_opts += enc->frame_size;
553
        }
554
    } else {
555
        AVPacket pkt;
556
        av_init_packet(&pkt);
557

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

    
560
        /* output a pcm frame */
561
        /* XXX: change encoding codec API to avoid this ? */
562
        switch(enc->codec->id) {
563
        case CODEC_ID_PCM_S32LE:
564
        case CODEC_ID_PCM_S32BE:
565
        case CODEC_ID_PCM_U32LE:
566
        case CODEC_ID_PCM_U32BE:
567
            size_out = size_out << 1;
568
            break;
569
        case CODEC_ID_PCM_S24LE:
570
        case CODEC_ID_PCM_S24BE:
571
        case CODEC_ID_PCM_U24LE:
572
        case CODEC_ID_PCM_U24BE:
573
        case CODEC_ID_PCM_S24DAUD:
574
            size_out = size_out / 2 * 3;
575
            break;
576
        case CODEC_ID_PCM_S16LE:
577
        case CODEC_ID_PCM_S16BE:
578
        case CODEC_ID_PCM_U16LE:
579
        case CODEC_ID_PCM_U16BE:
580
            break;
581
        default:
582
            size_out = size_out >> 1;
583
            break;
584
        }
585
        ret = avcodec_encode_audio(enc, audio_out, size_out,
586
                                   (short *)buftmp);
587
        audio_size += ret;
588
        pkt.stream_index= ost->index;
589
        pkt.data= audio_out;
590
        pkt.size= ret;
591
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
592
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
593
        pkt.flags |= PKT_FLAG_KEY;
594
        av_interleaved_write_frame(s, &pkt);
595
    }
596
}
597

    
598
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
599
{
600
    AVCodecContext *dec;
601
    AVPicture *picture2;
602
    AVPicture picture_tmp;
603
    uint8_t *buf = 0;
604

    
605
    dec = ist->st->codec;
606

    
607
    /* deinterlace : must be done before any resize */
608
    if (do_deinterlace || using_vhook) {
609
        int size;
610

    
611
        /* create temporary picture */
612
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
613
        buf = av_malloc(size);
614
        if (!buf)
615
            return;
616

    
617
        picture2 = &picture_tmp;
618
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
619

    
620
        if (do_deinterlace){
621
            if(avpicture_deinterlace(picture2, picture,
622
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
623
                /* if error, do not deinterlace */
624
                av_free(buf);
625
                buf = NULL;
626
                picture2 = picture;
627
            }
628
        } else {
629
            if (img_convert(picture2, dec->pix_fmt, picture,
630
                            dec->pix_fmt, dec->width, dec->height) < 0) {
631
                /* if error, do not copy */
632
                av_free(buf);
633
                buf = NULL;
634
                picture2 = picture;
635
            }
636
        }
637
    } else {
638
        picture2 = picture;
639
    }
640

    
641
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
642

    
643
    if (picture != picture2)
644
        *picture = *picture2;
645
    *bufp = buf;
646
}
647

    
648
/* we begin to correct av delay at this threshold */
649
#define AV_DELAY_MAX 0.100
650

    
651

    
652
/* Expects img to be yuv420 */
653
static void fill_pad_region(AVPicture* img, int height, int width,
654
        int padtop, int padbottom, int padleft, int padright, int *color) {
655

    
656
    int i, y, shift;
657
    uint8_t *optr;
658

    
659
    for (i = 0; i < 3; i++) {
660
        shift = (i == 0) ? 0 : 1;
661

    
662
        if (padtop || padleft) {
663
            memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
664
                            padleft) >> shift));
665
        }
666

    
667
        if (padleft || padright) {
668
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
669
                (img->linesize[i] - (padright >> shift));
670

    
671
            for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
672
                memset(optr, color[i], (padleft + padright) >> shift);
673
                optr += img->linesize[i];
674
            }
675
        }
676

    
677
        if (padbottom || padright) {
678
            optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
679
            memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
680
        }
681
    }
682
}
683

    
684
static void do_subtitle_out(AVFormatContext *s,
685
                            AVOutputStream *ost,
686
                            AVInputStream *ist,
687
                            AVSubtitle *sub,
688
                            int64_t pts)
689
{
690
    static uint8_t *subtitle_out = NULL;
691
    int subtitle_out_max_size = 65536;
692
    int subtitle_out_size, nb, i;
693
    AVCodecContext *enc;
694
    AVPacket pkt;
695

    
696
    if (pts == AV_NOPTS_VALUE) {
697
        fprintf(stderr, "Subtitle packets must have a pts\n");
698
        return;
699
    }
700

    
701
    enc = ost->st->codec;
702

    
703
    if (!subtitle_out) {
704
        subtitle_out = av_malloc(subtitle_out_max_size);
705
    }
706

    
707
    /* Note: DVB subtitle need one packet to draw them and one other
708
       packet to clear them */
709
    /* XXX: signal it in the codec context ? */
710
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
711
        nb = 2;
712
    else
713
        nb = 1;
714

    
715
    for(i = 0; i < nb; i++) {
716
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
717
                                                    subtitle_out_max_size, sub);
718

    
719
        av_init_packet(&pkt);
720
        pkt.stream_index = ost->index;
721
        pkt.data = subtitle_out;
722
        pkt.size = subtitle_out_size;
723
        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);
724
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
725
            /* XXX: the pts correction is handled here. Maybe handling
726
               it in the codec would be better */
727
            if (i == 0)
728
                pkt.pts += 90 * sub->start_display_time;
729
            else
730
                pkt.pts += 90 * sub->end_display_time;
731
        }
732
        av_interleaved_write_frame(s, &pkt);
733
    }
734
}
735

    
736
static int bit_buffer_size= 1024*256;
737
static uint8_t *bit_buffer= NULL;
738

    
739
static void do_video_out(AVFormatContext *s,
740
                         AVOutputStream *ost,
741
                         AVInputStream *ist,
742
                         AVFrame *in_picture,
743
                         int *frame_size)
744
{
745
    int nb_frames, i, ret;
746
    AVFrame *final_picture, *formatted_picture;
747
    AVFrame picture_format_temp, picture_crop_temp;
748
    uint8_t *buf = NULL, *buf1 = NULL;
749
    AVCodecContext *enc, *dec;
750
    enum PixelFormat target_pixfmt;
751

    
752
    avcodec_get_frame_defaults(&picture_format_temp);
753
    avcodec_get_frame_defaults(&picture_crop_temp);
754

    
755
    enc = ost->st->codec;
756
    dec = ist->st->codec;
757

    
758
    /* by default, we output a single frame */
759
    nb_frames = 1;
760

    
761
    *frame_size = 0;
762

    
763
    if(video_sync_method){
764
        double vdelta;
765
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
766
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
767
        if (vdelta < -1.1)
768
            nb_frames = 0;
769
        else if (vdelta > 1.1)
770
            nb_frames = lrintf(vdelta);
771
//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);
772
        if (nb_frames == 0){
773
            ++nb_frames_drop;
774
            if (verbose>2)
775
                fprintf(stderr, "*** drop!\n");
776
        }else if (nb_frames > 1) {
777
            nb_frames_dup += nb_frames;
778
            if (verbose>2)
779
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
780
        }
781
    }else
782
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
783

    
784
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
785
    if (nb_frames <= 0)
786
        return;
787

    
788
    /* convert pixel format if needed */
789
    target_pixfmt = ost->video_resample || ost->video_pad
790
        ? PIX_FMT_YUV420P : enc->pix_fmt;
791
    if (dec->pix_fmt != target_pixfmt) {
792
        int size;
793

    
794
        /* create temporary picture */
795
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
796
        buf = av_malloc(size);
797
        if (!buf)
798
            return;
799
        formatted_picture = &picture_format_temp;
800
        avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
801

    
802
        if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
803
                        (AVPicture *)in_picture, dec->pix_fmt,
804
                        dec->width, dec->height) < 0) {
805

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

    
809
            goto the_end;
810
        }
811
    } else {
812
        formatted_picture = in_picture;
813
    }
814

    
815
    /* XXX: resampling could be done before raw format conversion in
816
       some cases to go faster */
817
    /* XXX: only works for YUV420P */
818
    if (ost->video_resample) {
819
        final_picture = &ost->pict_tmp;
820
        img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
821

    
822
        if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
823
            fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
824
                    ost->padtop, ost->padbottom, ost->padleft, ost->padright,
825
                    padcolor);
826
        }
827

    
828
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
829
            int size;
830

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

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

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

    
847
                goto the_end;
848
            }
849
        }
850
    } else if (ost->video_crop) {
851
        if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)formatted_picture, enc->pix_fmt, ost->topBand, ost->leftBand) < 0) {
852
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
853
            goto the_end;
854
        }
855
        final_picture = &picture_crop_temp;
856
    } else if (ost->video_pad) {
857
        final_picture = &ost->pict_tmp;
858

    
859
        for (i = 0; i < 3; i++) {
860
            uint8_t *optr, *iptr;
861
            int shift = (i == 0) ? 0 : 1;
862
            int y, yheight;
863

    
864
            /* set offset to start writing image into */
865
            optr = final_picture->data[i] + (((final_picture->linesize[i] *
866
                            ost->padtop) + ost->padleft) >> shift);
867
            iptr = formatted_picture->data[i];
868

    
869
            yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
870
            for (y = 0; y < yheight; y++) {
871
                /* copy unpadded image row into padded image row */
872
                memcpy(optr, iptr, formatted_picture->linesize[i]);
873
                optr += final_picture->linesize[i];
874
                iptr += formatted_picture->linesize[i];
875
            }
876
        }
877

    
878
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
879
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
880
                padcolor);
881

    
882
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
883
            int size;
884

    
885
            av_free(buf);
886
            /* create temporary picture */
887
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
888
            buf = av_malloc(size);
889
            if (!buf)
890
                return;
891
            final_picture = &picture_format_temp;
892
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
893

    
894
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
895
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
896
                        enc->width, enc->height) < 0) {
897

    
898
                if (verbose >= 0)
899
                    fprintf(stderr, "pixel format conversion not handled\n");
900

    
901
                goto the_end;
902
            }
903
        }
904
    } else {
905
        final_picture = formatted_picture;
906
    }
907
    /* duplicates frame if needed */
908
    for(i=0;i<nb_frames;i++) {
909
        AVPacket pkt;
910
        av_init_packet(&pkt);
911
        pkt.stream_index= ost->index;
912

    
913
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
914
            /* raw pictures are written as AVPicture structure to
915
               avoid any copies. We support temorarily the older
916
               method. */
917
            AVFrame* old_frame = enc->coded_frame;
918
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
919
            pkt.data= (uint8_t *)final_picture;
920
            pkt.size=  sizeof(AVPicture);
921
            if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
922
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
923
            if(dec->coded_frame && dec->coded_frame->key_frame)
924
                pkt.flags |= PKT_FLAG_KEY;
925

    
926
            av_interleaved_write_frame(s, &pkt);
927
            enc->coded_frame = old_frame;
928
        } else {
929
            AVFrame big_picture;
930

    
931
            big_picture= *final_picture;
932
            /* better than nothing: use input picture interlaced
933
               settings */
934
            big_picture.interlaced_frame = in_picture->interlaced_frame;
935
            if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
936
                if(top_field_first == -1)
937
                    big_picture.top_field_first = in_picture->top_field_first;
938
                else
939
                    big_picture.top_field_first = top_field_first;
940
            }
941

    
942
            /* handles sameq here. This is not correct because it may
943
               not be a global option */
944
            if (same_quality) {
945
                big_picture.quality = ist->st->quality;
946
            }else
947
                big_picture.quality = ost->st->quality;
948
            if(!me_threshold)
949
                big_picture.pict_type = 0;
950
//            big_picture.pts = AV_NOPTS_VALUE;
951
            big_picture.pts= ost->sync_opts;
952
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
953
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
954
            ret = avcodec_encode_video(enc,
955
                                       bit_buffer, bit_buffer_size,
956
                                       &big_picture);
957
            //enc->frame_number = enc->real_pict_num;
958
            if(ret>0){
959
                pkt.data= bit_buffer;
960
                pkt.size= ret;
961
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
962
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
963
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
964
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
965
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
966

    
967
                if(enc->coded_frame && enc->coded_frame->key_frame)
968
                    pkt.flags |= PKT_FLAG_KEY;
969
                av_interleaved_write_frame(s, &pkt);
970
                *frame_size = ret;
971
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
972
                //        enc->frame_number-1, enc->real_pict_num, ret,
973
                //        enc->pict_type);
974
                /* if two pass, output log */
975
                if (ost->logfile && enc->stats_out) {
976
                    fprintf(ost->logfile, "%s", enc->stats_out);
977
                }
978
            }
979
        }
980
        ost->sync_opts++;
981
        ost->frame_number++;
982
    }
983
 the_end:
984
    av_free(buf);
985
    av_free(buf1);
986
}
987

    
988
static double psnr(double d){
989
    if(d==0) return INFINITY;
990
    return -10.0*log(d)/log(10.0);
991
}
992

    
993
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
994
                           int frame_size)
995
{
996
    static FILE *fvstats=NULL;
997
    char filename[40];
998
    time_t today2;
999
    struct tm *today;
1000
    AVCodecContext *enc;
1001
    int frame_number;
1002
    int64_t ti;
1003
    double ti1, bitrate, avg_bitrate;
1004

    
1005
    if (!fvstats) {
1006
        today2 = time(NULL);
1007
        today = localtime(&today2);
1008
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
1009
                                               today->tm_min,
1010
                                               today->tm_sec);
1011
        fvstats = fopen(filename,"w");
1012
        if (!fvstats) {
1013
            perror("fopen");
1014
            exit(1);
1015
        }
1016
    }
1017

    
1018
    ti = MAXINT64;
1019
    enc = ost->st->codec;
1020
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1021
        frame_number = ost->frame_number;
1022
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1023
        if (enc->flags&CODEC_FLAG_PSNR)
1024
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1025

    
1026
        fprintf(fvstats,"f_size= %6d ", frame_size);
1027
        /* compute pts value */
1028
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1029
        if (ti1 < 0.01)
1030
            ti1 = 0.01;
1031

    
1032
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1033
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1034
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1035
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1036
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1037
    }
1038
}
1039

    
1040
static void print_report(AVFormatContext **output_files,
1041
                         AVOutputStream **ost_table, int nb_ostreams,
1042
                         int is_last_report)
1043
{
1044
    char buf[1024];
1045
    AVOutputStream *ost;
1046
    AVFormatContext *oc, *os;
1047
    int64_t total_size;
1048
    AVCodecContext *enc;
1049
    int frame_number, vid, i;
1050
    double bitrate, ti1, pts;
1051
    static int64_t last_time = -1;
1052
    static int qp_histogram[52];
1053

    
1054
    if (!is_last_report) {
1055
        int64_t cur_time;
1056
        /* display the report every 0.5 seconds */
1057
        cur_time = av_gettime();
1058
        if (last_time == -1) {
1059
            last_time = cur_time;
1060
            return;
1061
        }
1062
        if ((cur_time - last_time) < 500000)
1063
            return;
1064
        last_time = cur_time;
1065
    }
1066

    
1067

    
1068
    oc = output_files[0];
1069

    
1070
    total_size = url_ftell(&oc->pb);
1071

    
1072
    buf[0] = '\0';
1073
    ti1 = 1e10;
1074
    vid = 0;
1075
    for(i=0;i<nb_ostreams;i++) {
1076
        ost = ost_table[i];
1077
        os = output_files[ost->file_index];
1078
        enc = ost->st->codec;
1079
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1080
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1081
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1082
        }
1083
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1084
            frame_number = ost->frame_number;
1085
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
1086
                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1087
            if(is_last_report)
1088
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1089
            if(qp_hist && enc->coded_frame){
1090
                int j;
1091
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1092
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1093
                    qp_histogram[qp]++;
1094
                for(j=0; j<32; j++)
1095
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1096
            }
1097
            if (enc->flags&CODEC_FLAG_PSNR){
1098
                int j;
1099
                double error, error_sum=0;
1100
                double scale, scale_sum=0;
1101
                char type[3]= {'Y','U','V'};
1102
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1103
                for(j=0; j<3; j++){
1104
                    if(is_last_report){
1105
                        error= enc->error[j];
1106
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1107
                    }else{
1108
                        error= enc->coded_frame->error[j];
1109
                        scale= enc->width*enc->height*255.0*255.0;
1110
                    }
1111
                    if(j) scale/=4;
1112
                    error_sum += error;
1113
                    scale_sum += scale;
1114
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1115
                }
1116
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1117
            }
1118
            vid = 1;
1119
        }
1120
        /* compute min output value */
1121
        pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1122
        if ((pts < ti1) && (pts > 0))
1123
            ti1 = pts;
1124
    }
1125
    if (ti1 < 0.01)
1126
        ti1 = 0.01;
1127

    
1128
    if (verbose || is_last_report) {
1129
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1130

    
1131
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1132
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1133
            (double)total_size / 1024, ti1, bitrate);
1134

    
1135
        if (verbose > 1)
1136
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1137
                  nb_frames_dup, nb_frames_drop);
1138

    
1139
        if (verbose >= 0)
1140
            fprintf(stderr, "%s    \r", buf);
1141

    
1142
        fflush(stderr);
1143
    }
1144

    
1145
    if (is_last_report && verbose >= 0){
1146
        int64_t raw= audio_size + video_size + extra_size;
1147
        fprintf(stderr, "\n");
1148
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1149
                video_size/1024.0,
1150
                audio_size/1024.0,
1151
                extra_size/1024.0,
1152
                100.0*(total_size - raw)/raw
1153
        );
1154
    }
1155
}
1156

    
1157
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1158
static int output_packet(AVInputStream *ist, int ist_index,
1159
                         AVOutputStream **ost_table, int nb_ostreams,
1160
                         const AVPacket *pkt)
1161
{
1162
    AVFormatContext *os;
1163
    AVOutputStream *ost;
1164
    uint8_t *ptr;
1165
    int len, ret, i;
1166
    uint8_t *data_buf;
1167
    int data_size, got_picture;
1168
    AVFrame picture;
1169
    void *buffer_to_free;
1170
    static unsigned int samples_size= 0;
1171
    static short *samples= NULL;
1172
    AVSubtitle subtitle, *subtitle_to_free;
1173
    int got_subtitle;
1174

    
1175
    if(!pkt){
1176
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1177
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1178
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1179
    } else {
1180
//        assert(ist->pts == ist->next_pts);
1181
    }
1182

    
1183
    if (pkt == NULL) {
1184
        /* EOF handling */
1185
        ptr = NULL;
1186
        len = 0;
1187
        goto handle_eof;
1188
    }
1189

    
1190
    len = pkt->size;
1191
    ptr = pkt->data;
1192
    while (len > 0) {
1193
    handle_eof:
1194
        /* decode the packet if needed */
1195
        data_buf = NULL; /* fail safe */
1196
        data_size = 0;
1197
        subtitle_to_free = NULL;
1198
        if (ist->decoding_needed) {
1199
            switch(ist->st->codec->codec_type) {
1200
            case CODEC_TYPE_AUDIO:{
1201
                if(pkt)
1202
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1203
                    /* XXX: could avoid copy if PCM 16 bits with same
1204
                       endianness as CPU */
1205
                ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1206
                                           ptr, len);
1207
                if (ret < 0)
1208
                    goto fail_decode;
1209
                ptr += ret;
1210
                len -= ret;
1211
                /* Some bug in mpeg audio decoder gives */
1212
                /* data_size < 0, it seems they are overflows */
1213
                if (data_size <= 0) {
1214
                    /* no audio frame */
1215
                    continue;
1216
                }
1217
                data_buf = (uint8_t *)samples;
1218
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1219
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1220
                break;}
1221
            case CODEC_TYPE_VIDEO:
1222
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1223
                    /* XXX: allocate picture correctly */
1224
                    avcodec_get_frame_defaults(&picture);
1225

    
1226
                    ret = avcodec_decode_video(ist->st->codec,
1227
                                               &picture, &got_picture, ptr, len);
1228
                    ist->st->quality= picture.quality;
1229
                    if (ret < 0)
1230
                        goto fail_decode;
1231
                    if (!got_picture) {
1232
                        /* no picture yet */
1233
                        goto discard_packet;
1234
                    }
1235
                    if (ist->st->codec->time_base.num != 0) {
1236
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1237
                                          ist->st->codec->time_base.num) /
1238
                            ist->st->codec->time_base.den;
1239
                    }
1240
                    len = 0;
1241
                    break;
1242
            case CODEC_TYPE_SUBTITLE:
1243
                ret = avcodec_decode_subtitle(ist->st->codec,
1244
                                              &subtitle, &got_subtitle, ptr, len);
1245
                if (ret < 0)
1246
                    goto fail_decode;
1247
                if (!got_subtitle) {
1248
                    goto discard_packet;
1249
                }
1250
                subtitle_to_free = &subtitle;
1251
                len = 0;
1252
                break;
1253
            default:
1254
                goto fail_decode;
1255
            }
1256
        } else {
1257
                switch(ist->st->codec->codec_type) {
1258
                case CODEC_TYPE_AUDIO:
1259
                    ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1260
                        (ist->st->codec->sample_rate * ist->st->codec->channels);
1261
                    break;
1262
                case CODEC_TYPE_VIDEO:
1263
                    if (ist->st->codec->time_base.num != 0) {
1264
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1265
                                          ist->st->codec->time_base.num) /
1266
                            ist->st->codec->time_base.den;
1267
                    }
1268
                    break;
1269
                }
1270
                data_buf = ptr;
1271
                data_size = len;
1272
                ret = len;
1273
                len = 0;
1274
            }
1275

    
1276
            buffer_to_free = NULL;
1277
            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1278
                pre_process_video_frame(ist, (AVPicture *)&picture,
1279
                                        &buffer_to_free);
1280
            }
1281

    
1282
            // preprocess audio (volume)
1283
            if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1284
                if (audio_volume != 256) {
1285
                    short *volp;
1286
                    volp = samples;
1287
                    for(i=0;i<(data_size / sizeof(short));i++) {
1288
                        int v = ((*volp) * audio_volume + 128) >> 8;
1289
                        if (v < -32768) v = -32768;
1290
                        if (v >  32767) v = 32767;
1291
                        *volp++ = v;
1292
                    }
1293
                }
1294
            }
1295

    
1296
            /* frame rate emulation */
1297
            if (ist->st->codec->rate_emu) {
1298
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1299
                int64_t now = av_gettime() - ist->start;
1300
                if (pts > now)
1301
                    usleep(pts - now);
1302

    
1303
                ist->frame++;
1304
            }
1305

    
1306
#if 0
1307
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1308
               is the one of the next displayed one */
1309
            /* XXX: add mpeg4 too ? */
1310
            if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1311
                if (ist->st->codec->pict_type != B_TYPE) {
1312
                    int64_t tmp;
1313
                    tmp = ist->last_ip_pts;
1314
                    ist->last_ip_pts  = ist->frac_pts.val;
1315
                    ist->frac_pts.val = tmp;
1316
                }
1317
            }
1318
#endif
1319
            /* if output time reached then transcode raw format,
1320
               encode packets and output them */
1321
            if (start_time == 0 || ist->pts >= start_time)
1322
                for(i=0;i<nb_ostreams;i++) {
1323
                    int frame_size;
1324

    
1325
                    ost = ost_table[i];
1326
                    if (ost->source_index == ist_index) {
1327
                        os = output_files[ost->file_index];
1328

    
1329
#if 0
1330
                        printf("%d: got pts=%0.3f %0.3f\n", i,
1331
                               (double)pkt->pts / AV_TIME_BASE,
1332
                               ((double)ist->pts / AV_TIME_BASE) -
1333
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1334
#endif
1335
                        /* set the input output pts pairs */
1336
                        //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1337

    
1338
                        if (ost->encoding_needed) {
1339
                            switch(ost->st->codec->codec_type) {
1340
                            case CODEC_TYPE_AUDIO:
1341
                                do_audio_out(os, ost, ist, data_buf, data_size);
1342
                                break;
1343
                            case CODEC_TYPE_VIDEO:
1344
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1345
                                    video_size += frame_size;
1346
                                    if (do_vstats && frame_size)
1347
                                        do_video_stats(os, ost, frame_size);
1348
                                break;
1349
                            case CODEC_TYPE_SUBTITLE:
1350
                                do_subtitle_out(os, ost, ist, &subtitle,
1351
                                                pkt->pts);
1352
                                break;
1353
                            default:
1354
                                av_abort();
1355
                            }
1356
                        } else {
1357
                            AVFrame avframe; //FIXME/XXX remove this
1358
                            AVPacket opkt;
1359
                            av_init_packet(&opkt);
1360

    
1361
                            /* no reencoding needed : output the packet directly */
1362
                            /* force the input stream PTS */
1363

    
1364
                            avcodec_get_frame_defaults(&avframe);
1365
                            ost->st->codec->coded_frame= &avframe;
1366
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1367

    
1368
                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1369
                                audio_size += data_size;
1370
                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1371
                                video_size += data_size;
1372
                                ost->sync_opts++;
1373
                            }
1374

    
1375
                            opkt.stream_index= ost->index;
1376
                            if(pkt->pts != AV_NOPTS_VALUE)
1377
                                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);
1378
                            else
1379
                                opkt.pts= AV_NOPTS_VALUE;
1380

    
1381
                            {
1382
                                int64_t dts;
1383
                                if (pkt->dts == AV_NOPTS_VALUE)
1384
                                    dts = ist->next_pts;
1385
                                else
1386
                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1387
                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1388
                            }
1389
                            opkt.flags= pkt->flags;
1390
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1391
                                opkt.destruct= av_destruct_packet;
1392
                            av_interleaved_write_frame(os, &opkt);
1393
                            ost->st->codec->frame_number++;
1394
                            ost->frame_number++;
1395
                            av_free_packet(&opkt);
1396
                        }
1397
                    }
1398
                }
1399
            av_free(buffer_to_free);
1400
            /* XXX: allocate the subtitles in the codec ? */
1401
            if (subtitle_to_free) {
1402
                if (subtitle_to_free->rects != NULL) {
1403
                    for (i = 0; i < subtitle_to_free->num_rects; i++) {
1404
                        av_free(subtitle_to_free->rects[i].bitmap);
1405
                        av_free(subtitle_to_free->rects[i].rgba_palette);
1406
                    }
1407
                    av_freep(&subtitle_to_free->rects);
1408
                }
1409
                subtitle_to_free->num_rects = 0;
1410
                subtitle_to_free = NULL;
1411
            }
1412
        }
1413
 discard_packet:
1414
    if (pkt == NULL) {
1415
        /* EOF handling */
1416

    
1417
        for(i=0;i<nb_ostreams;i++) {
1418
            ost = ost_table[i];
1419
            if (ost->source_index == ist_index) {
1420
                AVCodecContext *enc= ost->st->codec;
1421
                os = output_files[ost->file_index];
1422

    
1423
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1424
                    continue;
1425
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1426
                    continue;
1427

    
1428
                if (ost->encoding_needed) {
1429
                    for(;;) {
1430
                        AVPacket pkt;
1431
                        av_init_packet(&pkt);
1432
                        pkt.stream_index= ost->index;
1433

    
1434
                        switch(ost->st->codec->codec_type) {
1435
                        case CODEC_TYPE_AUDIO:
1436
                            ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1437
                            audio_size += ret;
1438
                            pkt.flags |= PKT_FLAG_KEY;
1439
                            break;
1440
                        case CODEC_TYPE_VIDEO:
1441
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1442
                            video_size += ret;
1443
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1444
                                pkt.flags |= PKT_FLAG_KEY;
1445
                            if (ost->logfile && enc->stats_out) {
1446
                                fprintf(ost->logfile, "%s", enc->stats_out);
1447
                            }
1448
                            break;
1449
                        default:
1450
                            ret=-1;
1451
                        }
1452

    
1453
                        if(ret<=0)
1454
                            break;
1455
                        pkt.data= bit_buffer;
1456
                        pkt.size= ret;
1457
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1458
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1459
                        av_interleaved_write_frame(os, &pkt);
1460
                    }
1461
                }
1462
            }
1463
        }
1464
    }
1465

    
1466
    return 0;
1467
 fail_decode:
1468
    return -1;
1469
}
1470

    
1471

    
1472
/*
1473
 * The following code is the main loop of the file converter
1474
 */
1475
static int av_encode(AVFormatContext **output_files,
1476
                     int nb_output_files,
1477
                     AVFormatContext **input_files,
1478
                     int nb_input_files,
1479
                     AVStreamMap *stream_maps, int nb_stream_maps)
1480
{
1481
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1482
    AVFormatContext *is, *os;
1483
    AVCodecContext *codec, *icodec;
1484
    AVOutputStream *ost, **ost_table = NULL;
1485
    AVInputStream *ist, **ist_table = NULL;
1486
    AVInputFile *file_table;
1487
    AVFormatContext *stream_no_data;
1488
    int key;
1489

    
1490
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1491
    if (!file_table)
1492
        goto fail;
1493

    
1494
    /* input stream init */
1495
    j = 0;
1496
    for(i=0;i<nb_input_files;i++) {
1497
        is = input_files[i];
1498
        file_table[i].ist_index = j;
1499
        file_table[i].nb_streams = is->nb_streams;
1500
        j += is->nb_streams;
1501
    }
1502
    nb_istreams = j;
1503

    
1504
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1505
    if (!ist_table)
1506
        goto fail;
1507

    
1508
    for(i=0;i<nb_istreams;i++) {
1509
        ist = av_mallocz(sizeof(AVInputStream));
1510
        if (!ist)
1511
            goto fail;
1512
        ist_table[i] = ist;
1513
    }
1514
    j = 0;
1515
    for(i=0;i<nb_input_files;i++) {
1516
        is = input_files[i];
1517
        for(k=0;k<is->nb_streams;k++) {
1518
            ist = ist_table[j++];
1519
            ist->st = is->streams[k];
1520
            ist->file_index = i;
1521
            ist->index = k;
1522
            ist->discard = 1; /* the stream is discarded by default
1523
                                 (changed later) */
1524

    
1525
            if (ist->st->codec->rate_emu) {
1526
                ist->start = av_gettime();
1527
                ist->frame = 0;
1528
            }
1529
        }
1530
    }
1531

    
1532
    /* output stream init */
1533
    nb_ostreams = 0;
1534
    for(i=0;i<nb_output_files;i++) {
1535
        os = output_files[i];
1536
        nb_ostreams += os->nb_streams;
1537
    }
1538
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1539
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1540
        exit(1);
1541
    }
1542

    
1543
    /* Sanity check the mapping args -- do the input files & streams exist? */
1544
    for(i=0;i<nb_stream_maps;i++) {
1545
        int fi = stream_maps[i].file_index;
1546
        int si = stream_maps[i].stream_index;
1547

    
1548
        if (fi < 0 || fi > nb_input_files - 1 ||
1549
            si < 0 || si > file_table[fi].nb_streams - 1) {
1550
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1551
            exit(1);
1552
        }
1553
        fi = stream_maps[i].sync_file_index;
1554
        si = stream_maps[i].sync_stream_index;
1555
        if (fi < 0 || fi > nb_input_files - 1 ||
1556
            si < 0 || si > file_table[fi].nb_streams - 1) {
1557
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1558
            exit(1);
1559
        }
1560
    }
1561

    
1562
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1563
    if (!ost_table)
1564
        goto fail;
1565
    for(i=0;i<nb_ostreams;i++) {
1566
        ost = av_mallocz(sizeof(AVOutputStream));
1567
        if (!ost)
1568
            goto fail;
1569
        ost_table[i] = ost;
1570
    }
1571

    
1572
    n = 0;
1573
    for(k=0;k<nb_output_files;k++) {
1574
        os = output_files[k];
1575
        for(i=0;i<os->nb_streams;i++) {
1576
            int found;
1577
            ost = ost_table[n++];
1578
            ost->file_index = k;
1579
            ost->index = i;
1580
            ost->st = os->streams[i];
1581
            if (nb_stream_maps > 0) {
1582
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1583
                    stream_maps[n-1].stream_index;
1584

    
1585
                /* Sanity check that the stream types match */
1586
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1587
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1588
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1589
                        ost->file_index, ost->index);
1590
                    exit(1);
1591
                }
1592

    
1593
            } else {
1594
                /* get corresponding input stream index : we select the first one with the right type */
1595
                found = 0;
1596
                for(j=0;j<nb_istreams;j++) {
1597
                    ist = ist_table[j];
1598
                    if (ist->discard &&
1599
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1600
                        ost->source_index = j;
1601
                        found = 1;
1602
                        break;
1603
                    }
1604
                }
1605

    
1606
                if (!found) {
1607
                    /* try again and reuse existing stream */
1608
                    for(j=0;j<nb_istreams;j++) {
1609
                        ist = ist_table[j];
1610
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1611
                            ost->source_index = j;
1612
                            found = 1;
1613
                        }
1614
                    }
1615
                    if (!found) {
1616
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1617
                                ost->file_index, ost->index);
1618
                        exit(1);
1619
                    }
1620
                }
1621
            }
1622
            ist = ist_table[ost->source_index];
1623
            ist->discard = 0;
1624
            ost->sync_ist = (nb_stream_maps > 0) ?
1625
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1626
                         stream_maps[n-1].sync_stream_index] : ist;
1627
        }
1628
    }
1629

    
1630
    /* for each output stream, we compute the right encoding parameters */
1631
    for(i=0;i<nb_ostreams;i++) {
1632
        ost = ost_table[i];
1633
        ist = ist_table[ost->source_index];
1634

    
1635
        codec = ost->st->codec;
1636
        icodec = ist->st->codec;
1637

    
1638
        if (ost->st->stream_copy) {
1639
            /* if stream_copy is selected, no need to decode or encode */
1640
            codec->codec_id = icodec->codec_id;
1641
            codec->codec_type = icodec->codec_type;
1642
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1643
            codec->bit_rate = icodec->bit_rate;
1644
            codec->extradata= icodec->extradata;
1645
            codec->extradata_size= icodec->extradata_size;
1646
            codec->time_base = icodec->time_base;
1647
            switch(codec->codec_type) {
1648
            case CODEC_TYPE_AUDIO:
1649
                codec->sample_rate = icodec->sample_rate;
1650
                codec->channels = icodec->channels;
1651
                codec->frame_size = icodec->frame_size;
1652
                codec->block_align= icodec->block_align;
1653
                break;
1654
            case CODEC_TYPE_VIDEO:
1655
                codec->pix_fmt = icodec->pix_fmt;
1656
                codec->width = icodec->width;
1657
                codec->height = icodec->height;
1658
                codec->has_b_frames = icodec->has_b_frames;
1659
                break;
1660
            case CODEC_TYPE_SUBTITLE:
1661
                break;
1662
            default:
1663
                av_abort();
1664
            }
1665
        } else {
1666
            switch(codec->codec_type) {
1667
            case CODEC_TYPE_AUDIO:
1668
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1669
                    goto fail;
1670

    
1671
                if (codec->channels == icodec->channels &&
1672
                    codec->sample_rate == icodec->sample_rate) {
1673
                    ost->audio_resample = 0;
1674
                } else {
1675
                    if (codec->channels != icodec->channels &&
1676
                        (icodec->codec_id == CODEC_ID_AC3 ||
1677
                         icodec->codec_id == CODEC_ID_DTS)) {
1678
                        /* Special case for 5:1 AC3 and DTS input */
1679
                        /* and mono or stereo output      */
1680
                        /* Request specific number of channels */
1681
                        icodec->channels = codec->channels;
1682
                        if (codec->sample_rate == icodec->sample_rate)
1683
                            ost->audio_resample = 0;
1684
                        else {
1685
                            ost->audio_resample = 1;
1686
                        }
1687
                    } else {
1688
                        ost->audio_resample = 1;
1689
                    }
1690
                }
1691
                if(audio_sync_method>1)
1692
                    ost->audio_resample = 1;
1693

    
1694
                if(ost->audio_resample){
1695
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1696
                                                    codec->sample_rate, icodec->sample_rate);
1697
                    if(!ost->resample){
1698
                        printf("Can't resample.  Aborting.\n");
1699
                        av_abort();
1700
                    }
1701
                }
1702
                ist->decoding_needed = 1;
1703
                ost->encoding_needed = 1;
1704
                break;
1705
            case CODEC_TYPE_VIDEO:
1706
                if (codec->width == icodec->width &&
1707
                    codec->height == icodec->height &&
1708
                    frame_topBand == 0 &&
1709
                    frame_bottomBand == 0 &&
1710
                    frame_leftBand == 0 &&
1711
                    frame_rightBand == 0 &&
1712
                    frame_padtop == 0 &&
1713
                    frame_padbottom == 0 &&
1714
                    frame_padleft == 0 &&
1715
                    frame_padright == 0)
1716
                {
1717
                    ost->video_resample = 0;
1718
                    ost->video_crop = 0;
1719
                    ost->video_pad = 0;
1720
                } else if ((codec->width == icodec->width -
1721
                                (frame_leftBand + frame_rightBand)) &&
1722
                        (codec->height == icodec->height -
1723
                                (frame_topBand  + frame_bottomBand)) &&
1724
                                (frame_rightBand + frame_leftBand + frame_topBand + frame_bottomBand)) {
1725
                    ost->video_resample = 0;
1726
                    ost->video_crop = 1;
1727
                    ost->topBand = frame_topBand;
1728
                    ost->leftBand = frame_leftBand;
1729
                } else if ((codec->width == icodec->width +
1730
                                (frame_padleft + frame_padright)) &&
1731
                        (codec->height == icodec->height +
1732
                                (frame_padtop + frame_padbottom)) &&
1733
                                (frame_padright + frame_padleft + frame_padtop + frame_padbottom)) {
1734
                    ost->video_resample = 0;
1735
                    ost->video_crop = 0;
1736
                    ost->video_pad = 1;
1737
                    ost->padtop = frame_padtop;
1738
                    ost->padleft = frame_padleft;
1739
                    ost->padbottom = frame_padbottom;
1740
                    ost->padright = frame_padright;
1741
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1742
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1743
                                codec->width, codec->height ) )
1744
                        goto fail;
1745
                } else {
1746
                    ost->video_resample = 1;
1747
                    ost->video_crop = 0; // cropping is handled as part of resample
1748
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1749
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1750
                                         codec->width, codec->height ) )
1751
                        goto fail;
1752

    
1753
                    ost->img_resample_ctx = img_resample_full_init(
1754
                                      codec->width, codec->height,
1755
                                      icodec->width, icodec->height,
1756
                                      frame_topBand, frame_bottomBand,
1757
                            frame_leftBand, frame_rightBand,
1758
                            frame_padtop, frame_padbottom,
1759
                            frame_padleft, frame_padright);
1760

    
1761
                    ost->padtop = frame_padtop;
1762
                    ost->padleft = frame_padleft;
1763
                    ost->padbottom = frame_padbottom;
1764
                    ost->padright = frame_padright;
1765

    
1766
                }
1767
                ost->encoding_needed = 1;
1768
                ist->decoding_needed = 1;
1769
                break;
1770
            case CODEC_TYPE_SUBTITLE:
1771
                ost->encoding_needed = 1;
1772
                ist->decoding_needed = 1;
1773
                break;
1774
            default:
1775
                av_abort();
1776
                break;
1777
            }
1778
            /* two pass mode */
1779
            if (ost->encoding_needed &&
1780
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1781
                char logfilename[1024];
1782
                FILE *f;
1783
                int size;
1784
                char *logbuffer;
1785

    
1786
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1787
                         pass_logfilename ?
1788
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1789
                if (codec->flags & CODEC_FLAG_PASS1) {
1790
                    f = fopen(logfilename, "w");
1791
                    if (!f) {
1792
                        perror(logfilename);
1793
                        exit(1);
1794
                    }
1795
                    ost->logfile = f;
1796
                } else {
1797
                    /* read the log file */
1798
                    f = fopen(logfilename, "r");
1799
                    if (!f) {
1800
                        perror(logfilename);
1801
                        exit(1);
1802
                    }
1803
                    fseek(f, 0, SEEK_END);
1804
                    size = ftell(f);
1805
                    fseek(f, 0, SEEK_SET);
1806
                    logbuffer = av_malloc(size + 1);
1807
                    if (!logbuffer) {
1808
                        fprintf(stderr, "Could not allocate log buffer\n");
1809
                        exit(1);
1810
                    }
1811
                    size = fread(logbuffer, 1, size, f);
1812
                    fclose(f);
1813
                    logbuffer[size] = '\0';
1814
                    codec->stats_in = logbuffer;
1815
                }
1816
            }
1817
        }
1818
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1819
            int size= codec->width * codec->height;
1820
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1821
        }
1822
    }
1823

    
1824
    if (!bit_buffer)
1825
        bit_buffer = av_malloc(bit_buffer_size);
1826
    if (!bit_buffer)
1827
        goto fail;
1828

    
1829
    /* dump the file output parameters - cannot be done before in case
1830
       of stream copy */
1831
    for(i=0;i<nb_output_files;i++) {
1832
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1833
    }
1834

    
1835
    /* dump the stream mapping */
1836
    if (verbose >= 0) {
1837
        fprintf(stderr, "Stream mapping:\n");
1838
        for(i=0;i<nb_ostreams;i++) {
1839
            ost = ost_table[i];
1840
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1841
                    ist_table[ost->source_index]->file_index,
1842
                    ist_table[ost->source_index]->index,
1843
                    ost->file_index,
1844
                    ost->index);
1845
            if (ost->sync_ist != ist_table[ost->source_index])
1846
                fprintf(stderr, " [sync #%d.%d]",
1847
                        ost->sync_ist->file_index,
1848
                        ost->sync_ist->index);
1849
            fprintf(stderr, "\n");
1850
        }
1851
    }
1852

    
1853
    /* open each encoder */
1854
    for(i=0;i<nb_ostreams;i++) {
1855
        ost = ost_table[i];
1856
        if (ost->encoding_needed) {
1857
            AVCodec *codec;
1858
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1859
            if (!codec) {
1860
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1861
                        ost->file_index, ost->index);
1862
                exit(1);
1863
            }
1864
            if (avcodec_open(ost->st->codec, codec) < 0) {
1865
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1866
                        ost->file_index, ost->index);
1867
                exit(1);
1868
            }
1869
            extra_size += ost->st->codec->extradata_size;
1870
        }
1871
    }
1872

    
1873
    /* open each decoder */
1874
    for(i=0;i<nb_istreams;i++) {
1875
        ist = ist_table[i];
1876
        if (ist->decoding_needed) {
1877
            AVCodec *codec;
1878
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1879
            if (!codec) {
1880
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1881
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1882
                exit(1);
1883
            }
1884
            if (avcodec_open(ist->st->codec, codec) < 0) {
1885
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1886
                        ist->file_index, ist->index);
1887
                exit(1);
1888
            }
1889
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1890
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1891
        }
1892
    }
1893

    
1894
    /* init pts */
1895
    for(i=0;i<nb_istreams;i++) {
1896
        ist = ist_table[i];
1897
        is = input_files[ist->file_index];
1898
        ist->pts = 0;
1899
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1900
        if(ist->st->start_time == AV_NOPTS_VALUE)
1901
            ist->next_pts=0;
1902
        if(input_files_ts_offset[ist->file_index])
1903
            ist->next_pts= AV_NOPTS_VALUE;
1904
        ist->is_start = 1;
1905
    }
1906

    
1907
    /* compute buffer size max (should use a complete heuristic) */
1908
    for(i=0;i<nb_input_files;i++) {
1909
        file_table[i].buffer_size_max = 2048;
1910
    }
1911

    
1912
    /* set meta data information from input file if required */
1913
    for (i=0;i<nb_meta_data_maps;i++) {
1914
        AVFormatContext *out_file;
1915
        AVFormatContext *in_file;
1916

    
1917
        int out_file_index = meta_data_maps[i].out_file;
1918
        int in_file_index = meta_data_maps[i].in_file;
1919
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1920
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1921
            ret = -EINVAL;
1922
            goto fail;
1923
        }
1924
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1925
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1926
            ret = -EINVAL;
1927
            goto fail;
1928
        }
1929

    
1930
        out_file = output_files[out_file_index];
1931
        in_file = input_files[in_file_index];
1932

    
1933
        strcpy(out_file->title, in_file->title);
1934
        strcpy(out_file->author, in_file->author);
1935
        strcpy(out_file->copyright, in_file->copyright);
1936
        strcpy(out_file->comment, in_file->comment);
1937
        strcpy(out_file->album, in_file->album);
1938
        out_file->year = in_file->year;
1939
        out_file->track = in_file->track;
1940
        strcpy(out_file->genre, in_file->genre);
1941
    }
1942

    
1943
    /* open files and write file headers */
1944
    for(i=0;i<nb_output_files;i++) {
1945
        os = output_files[i];
1946
        if (av_write_header(os) < 0) {
1947
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1948
            ret = -EINVAL;
1949
            goto fail;
1950
        }
1951
    }
1952

    
1953
#ifndef CONFIG_WIN32
1954
    if ( !using_stdin && verbose >= 0) {
1955
        fprintf(stderr, "Press [q] to stop encoding\n");
1956
        url_set_interrupt_cb(decode_interrupt_cb);
1957
    }
1958
#endif
1959
    term_init();
1960

    
1961
    stream_no_data = 0;
1962
    key = -1;
1963

    
1964
    for(; received_sigterm == 0;) {
1965
        int file_index, ist_index;
1966
        AVPacket pkt;
1967
        double ipts_min;
1968
        double opts_min;
1969

    
1970
    redo:
1971
        ipts_min= 1e100;
1972
        opts_min= 1e100;
1973
        /* if 'q' pressed, exits */
1974
        if (!using_stdin) {
1975
            if (q_pressed)
1976
                break;
1977
            /* read_key() returns 0 on EOF */
1978
            key = read_key();
1979
            if (key == 'q')
1980
                break;
1981
        }
1982

    
1983
        /* select the stream that we must read now by looking at the
1984
           smallest output pts */
1985
        file_index = -1;
1986
        for(i=0;i<nb_ostreams;i++) {
1987
            double ipts, opts;
1988
            ost = ost_table[i];
1989
            os = output_files[ost->file_index];
1990
            ist = ist_table[ost->source_index];
1991
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1992
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1993
            else
1994
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1995
            ipts = (double)ist->pts;
1996
            if (!file_table[ist->file_index].eof_reached){
1997
                if(ipts < ipts_min) {
1998
                    ipts_min = ipts;
1999
                    if(input_sync ) file_index = ist->file_index;
2000
                }
2001
                if(opts < opts_min) {
2002
                    opts_min = opts;
2003
                    if(!input_sync) file_index = ist->file_index;
2004
                }
2005
            }
2006
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2007
                file_index= -1;
2008
                break;
2009
            }
2010
        }
2011
        /* if none, if is finished */
2012
        if (file_index < 0) {
2013
            break;
2014
        }
2015

    
2016
        /* finish if recording time exhausted */
2017
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2018
            break;
2019

    
2020
        /* finish if limit size exhausted */
2021
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
2022
            break;
2023

    
2024
        /* read a frame from it and output it in the fifo */
2025
        is = input_files[file_index];
2026
        if (av_read_frame(is, &pkt) < 0) {
2027
            file_table[file_index].eof_reached = 1;
2028
            if (opt_shortest) break; else continue; //
2029
        }
2030

    
2031
        if (!pkt.size) {
2032
            stream_no_data = is;
2033
        } else {
2034
            stream_no_data = 0;
2035
        }
2036
        if (do_pkt_dump) {
2037
            av_pkt_dump(stdout, &pkt, do_hex_dump);
2038
        }
2039
        /* the following test is needed in case new streams appear
2040
           dynamically in stream : we ignore them */
2041
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2042
            goto discard_packet;
2043
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2044
        ist = ist_table[ist_index];
2045
        if (ist->discard)
2046
            goto discard_packet;
2047

    
2048
//        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);
2049
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2050
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
2051
            if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
2052
                input_files_ts_offset[ist->file_index]-= delta;
2053
                if (verbose > 2)
2054
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2055
                for(i=0; i<file_table[file_index].nb_streams; i++){
2056
                    int index= file_table[file_index].ist_index + i;
2057
                    ist_table[index]->next_pts += delta;
2058
                    ist_table[index]->is_start=1;
2059
                }
2060
            }
2061
        }
2062

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

    
2066
            if (verbose >= 0)
2067
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2068
                        ist->file_index, ist->index);
2069

    
2070
            av_free_packet(&pkt);
2071
            goto redo;
2072
        }
2073

    
2074
    discard_packet:
2075
        av_free_packet(&pkt);
2076

    
2077
        /* dump report by using the output first video and audio streams */
2078
        print_report(output_files, ost_table, nb_ostreams, 0);
2079
    }
2080

    
2081
    /* at the end of stream, we must flush the decoder buffers */
2082
    for(i=0;i<nb_istreams;i++) {
2083
        ist = ist_table[i];
2084
        if (ist->decoding_needed) {
2085
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2086
        }
2087
    }
2088

    
2089
    term_exit();
2090

    
2091
    /* write the trailer if needed and close file */
2092
    for(i=0;i<nb_output_files;i++) {
2093
        os = output_files[i];
2094
        av_write_trailer(os);
2095
    }
2096

    
2097
    /* dump report by using the first video and audio streams */
2098
    print_report(output_files, ost_table, nb_ostreams, 1);
2099

    
2100
    /* close each encoder */
2101
    for(i=0;i<nb_ostreams;i++) {
2102
        ost = ost_table[i];
2103
        if (ost->encoding_needed) {
2104
            av_freep(&ost->st->codec->stats_in);
2105
            avcodec_close(ost->st->codec);
2106
        }
2107
    }
2108

    
2109
    /* close each decoder */
2110
    for(i=0;i<nb_istreams;i++) {
2111
        ist = ist_table[i];
2112
        if (ist->decoding_needed) {
2113
            avcodec_close(ist->st->codec);
2114
        }
2115
    }
2116

    
2117
    /* finished ! */
2118

    
2119
    ret = 0;
2120
 fail1:
2121
    av_freep(&bit_buffer);
2122
    av_free(file_table);
2123

    
2124
    if (ist_table) {
2125
        for(i=0;i<nb_istreams;i++) {
2126
            ist = ist_table[i];
2127
            av_free(ist);
2128
        }
2129
        av_free(ist_table);
2130
    }
2131
    if (ost_table) {
2132
        for(i=0;i<nb_ostreams;i++) {
2133
            ost = ost_table[i];
2134
            if (ost) {
2135
                if (ost->logfile) {
2136
                    fclose(ost->logfile);
2137
                    ost->logfile = NULL;
2138
                }
2139
                fifo_free(&ost->fifo); /* works even if fifo is not
2140
                                          initialized but set to zero */
2141
                av_free(ost->pict_tmp.data[0]);
2142
                if (ost->video_resample)
2143
                    img_resample_close(ost->img_resample_ctx);
2144
                if (ost->audio_resample)
2145
                    audio_resample_close(ost->resample);
2146
                av_free(ost);
2147
            }
2148
        }
2149
        av_free(ost_table);
2150
    }
2151
    return ret;
2152
 fail:
2153
    ret = -ENOMEM;
2154
    goto fail1;
2155
}
2156

    
2157
#if 0
2158
int file_read(const char *filename)
2159
{
2160
    URLContext *h;
2161
    unsigned char buffer[1024];
2162
    int len, i;
2163

2164
    if (url_open(&h, filename, O_RDONLY) < 0) {
2165
        printf("could not open '%s'\n", filename);
2166
        return -1;
2167
    }
2168
    for(;;) {
2169
        len = url_read(h, buffer, sizeof(buffer));
2170
        if (len <= 0)
2171
            break;
2172
        for(i=0;i<len;i++) putchar(buffer[i]);
2173
    }
2174
    url_close(h);
2175
    return 0;
2176
}
2177
#endif
2178

    
2179
static void opt_image_format(const char *arg)
2180
{
2181
    AVImageFormat *f;
2182

    
2183
    for(f = first_image_format; f != NULL; f = f->next) {
2184
        if (!strcmp(arg, f->name))
2185
            break;
2186
    }
2187
    if (!f) {
2188
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2189
        exit(1);
2190
    }
2191
    image_format = f;
2192
}
2193

    
2194
static void opt_format(const char *arg)
2195
{
2196
    /* compatibility stuff for pgmyuv */
2197
    if (!strcmp(arg, "pgmyuv")) {
2198
        pgmyuv_compatibility_hack=1;
2199
//        opt_image_format(arg);
2200
        arg = "image2";
2201
    }
2202

    
2203
    file_iformat = av_find_input_format(arg);
2204
    file_oformat = guess_format(arg, NULL, NULL);
2205
    if (!file_iformat && !file_oformat) {
2206
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2207
        exit(1);
2208
    }
2209
}
2210

    
2211
static void opt_video_bitrate(const char *arg)
2212
{
2213
    video_bit_rate = atoi(arg) * 1000;
2214
}
2215

    
2216
static void opt_video_bitrate_tolerance(const char *arg)
2217
{
2218
    video_bit_rate_tolerance = atoi(arg) * 1000;
2219
}
2220

    
2221
static void opt_video_bitrate_max(const char *arg)
2222
{
2223
    video_rc_max_rate = atoi(arg) * 1000;
2224
}
2225

    
2226
static void opt_video_bitrate_min(const char *arg)
2227
{
2228
    video_rc_min_rate = atoi(arg) * 1000;
2229
}
2230

    
2231
static void opt_video_buffer_size(const char *arg)
2232
{
2233
    video_rc_buffer_size = atoi(arg) * 8*1024;
2234
}
2235

    
2236
static void opt_video_rc_eq(char *arg)
2237
{
2238
    video_rc_eq = arg;
2239
}
2240

    
2241
static void opt_video_rc_override_string(char *arg)
2242
{
2243
    video_rc_override_string = arg;
2244
}
2245

    
2246

    
2247
static void opt_workaround_bugs(const char *arg)
2248
{
2249
    workaround_bugs = atoi(arg);
2250
}
2251

    
2252
static void opt_me_threshold(const char *arg)
2253
{
2254
    me_threshold = atoi(arg);
2255
}
2256

    
2257
static void opt_mb_threshold(const char *arg)
2258
{
2259
    mb_threshold = atoi(arg);
2260
}
2261

    
2262
static void opt_verbose(const char *arg)
2263
{
2264
    verbose = atoi(arg);
2265
    av_log_set_level(atoi(arg));
2266
}
2267

    
2268
static void opt_frame_rate(const char *arg)
2269
{
2270
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2271
        fprintf(stderr, "Incorrect frame rate\n");
2272
        exit(1);
2273
    }
2274
}
2275

    
2276
static void opt_frame_crop_top(const char *arg)
2277
{
2278
    frame_topBand = atoi(arg);
2279
    if (frame_topBand < 0) {
2280
        fprintf(stderr, "Incorrect top crop size\n");
2281
        exit(1);
2282
    }
2283
    if ((frame_topBand % 2) != 0) {
2284
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2285
        exit(1);
2286
    }
2287
    if ((frame_topBand) >= frame_height){
2288
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2289
        exit(1);
2290
    }
2291
    frame_height -= frame_topBand;
2292
}
2293

    
2294
static void opt_frame_crop_bottom(const char *arg)
2295
{
2296
    frame_bottomBand = atoi(arg);
2297
    if (frame_bottomBand < 0) {
2298
        fprintf(stderr, "Incorrect bottom crop size\n");
2299
        exit(1);
2300
    }
2301
    if ((frame_bottomBand % 2) != 0) {
2302
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2303
        exit(1);
2304
    }
2305
    if ((frame_bottomBand) >= frame_height){
2306
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2307
        exit(1);
2308
    }
2309
    frame_height -= frame_bottomBand;
2310
}
2311

    
2312
static void opt_frame_crop_left(const char *arg)
2313
{
2314
    frame_leftBand = atoi(arg);
2315
    if (frame_leftBand < 0) {
2316
        fprintf(stderr, "Incorrect left crop size\n");
2317
        exit(1);
2318
    }
2319
    if ((frame_leftBand % 2) != 0) {
2320
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2321
        exit(1);
2322
    }
2323
    if ((frame_leftBand) >= frame_width){
2324
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2325
        exit(1);
2326
    }
2327
    frame_width -= frame_leftBand;
2328
}
2329

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

    
2348
static void opt_frame_size(const char *arg)
2349
{
2350
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2351
        fprintf(stderr, "Incorrect frame size\n");
2352
        exit(1);
2353
    }
2354
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2355
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2356
        exit(1);
2357
    }
2358
}
2359

    
2360

    
2361
#define SCALEBITS 10
2362
#define ONE_HALF  (1 << (SCALEBITS - 1))
2363
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2364

    
2365
#define RGB_TO_Y(r, g, b) \
2366
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2367
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2368

    
2369
#define RGB_TO_U(r1, g1, b1, shift)\
2370
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2371
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2372

    
2373
#define RGB_TO_V(r1, g1, b1, shift)\
2374
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2375
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2376

    
2377
static void opt_pad_color(const char *arg) {
2378
    /* Input is expected to be six hex digits similar to
2379
       how colors are expressed in html tags (but without the #) */
2380
    int rgb = strtol(arg, NULL, 16);
2381
    int r,g,b;
2382

    
2383
    r = (rgb >> 16);
2384
    g = ((rgb >> 8) & 255);
2385
    b = (rgb & 255);
2386

    
2387
    padcolor[0] = RGB_TO_Y(r,g,b);
2388
    padcolor[1] = RGB_TO_U(r,g,b,0);
2389
    padcolor[2] = RGB_TO_V(r,g,b,0);
2390
}
2391

    
2392
static void opt_frame_pad_top(const char *arg)
2393
{
2394
    frame_padtop = atoi(arg);
2395
    if (frame_padtop < 0) {
2396
        fprintf(stderr, "Incorrect top pad size\n");
2397
        exit(1);
2398
    }
2399
    if ((frame_padtop % 2) != 0) {
2400
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2401
        exit(1);
2402
    }
2403
}
2404

    
2405
static void opt_frame_pad_bottom(const char *arg)
2406
{
2407
    frame_padbottom = atoi(arg);
2408
    if (frame_padbottom < 0) {
2409
        fprintf(stderr, "Incorrect bottom pad size\n");
2410
        exit(1);
2411
    }
2412
    if ((frame_padbottom % 2) != 0) {
2413
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2414
        exit(1);
2415
    }
2416
}
2417

    
2418

    
2419
static void opt_frame_pad_left(const char *arg)
2420
{
2421
    frame_padleft = atoi(arg);
2422
    if (frame_padleft < 0) {
2423
        fprintf(stderr, "Incorrect left pad size\n");
2424
        exit(1);
2425
    }
2426
    if ((frame_padleft % 2) != 0) {
2427
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2428
        exit(1);
2429
    }
2430
}
2431

    
2432

    
2433
static void opt_frame_pad_right(const char *arg)
2434
{
2435
    frame_padright = atoi(arg);
2436
    if (frame_padright < 0) {
2437
        fprintf(stderr, "Incorrect right pad size\n");
2438
        exit(1);
2439
    }
2440
    if ((frame_padright % 2) != 0) {
2441
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2442
        exit(1);
2443
    }
2444
}
2445

    
2446

    
2447
static void opt_frame_pix_fmt(const char *arg)
2448
{
2449
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2450
}
2451

    
2452
static void opt_frame_aspect_ratio(const char *arg)
2453
{
2454
    int x = 0, y = 0;
2455
    double ar = 0;
2456
    const char *p;
2457

    
2458
    p = strchr(arg, ':');
2459
    if (p) {
2460
        x = strtol(arg, (char **)&arg, 10);
2461
        if (arg == p)
2462
            y = strtol(arg+1, (char **)&arg, 10);
2463
        if (x > 0 && y > 0)
2464
            ar = (double)x / (double)y;
2465
    } else
2466
        ar = strtod(arg, (char **)&arg);
2467

    
2468
    if (!ar) {
2469
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2470
        exit(1);
2471
    }
2472
    frame_aspect_ratio = ar;
2473
}
2474

    
2475
static void opt_gop_size(const char *arg)
2476
{
2477
    gop_size = atoi(arg);
2478
}
2479

    
2480
static void opt_b_frames(const char *arg)
2481
{
2482
    b_frames = atoi(arg);
2483
    if (b_frames > FF_MAX_B_FRAMES) {
2484
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2485
        exit(1);
2486
    } else if (b_frames < 1) {
2487
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2488
        exit(1);
2489
    }
2490
}
2491

    
2492
static void opt_pre_me(const char *arg)
2493
{
2494
    pre_me = atoi(arg);
2495
}
2496

    
2497
static void opt_qscale(const char *arg)
2498
{
2499
    video_qscale = atof(arg);
2500
    if (video_qscale < 0.01 ||
2501
        video_qscale > 255) {
2502
        fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2503
        exit(1);
2504
    }
2505
}
2506

    
2507
static void opt_qsquish(const char *arg)
2508
{
2509
    video_qsquish = atof(arg);
2510
    if (video_qsquish < 0.0 ||
2511
        video_qsquish > 99.0) {
2512
        fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2513
        exit(1);
2514
    }
2515
}
2516

    
2517
static void opt_lmax(const char *arg)
2518
{
2519
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2520
}
2521

    
2522
static void opt_lmin(const char *arg)
2523
{
2524
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2525
}
2526

    
2527
static void opt_qmin(const char *arg)
2528
{
2529
    video_qmin = atoi(arg);
2530
    if (video_qmin < 1 ||
2531
        video_qmin > 51) {
2532
        fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2533
        exit(1);
2534
    }
2535
}
2536

    
2537
static void opt_qmax(const char *arg)
2538
{
2539
    video_qmax = atoi(arg);
2540
    if (video_qmax < 1 ||
2541
        video_qmax > 51) {
2542
        fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2543
        exit(1);
2544
    }
2545
}
2546

    
2547
static void opt_mb_lmin(const char *arg)
2548
{
2549
    video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2550
    if (video_mb_lmin < 1 ||
2551
        video_mb_lmin > FF_LAMBDA_MAX) {
2552
        fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2553
        exit(1);
2554
    }
2555
}
2556

    
2557
static void opt_mb_lmax(const char *arg)
2558
{
2559
    video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2560
    if (video_mb_lmax < 1 ||
2561
        video_mb_lmax > FF_LAMBDA_MAX) {
2562
        fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2563
        exit(1);
2564
    }
2565
}
2566

    
2567
static void opt_qdiff(const char *arg)
2568
{
2569
    video_qdiff = atoi(arg);
2570
    if (video_qdiff < 0 ||
2571
        video_qdiff > 31) {
2572
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2573
        exit(1);
2574
    }
2575
}
2576

    
2577
static void opt_qblur(const char *arg)
2578
{
2579
    video_qblur = atof(arg);
2580
}
2581

    
2582
static void opt_qcomp(const char *arg)
2583
{
2584
    video_qcomp = atof(arg);
2585
}
2586

    
2587
static void opt_rc_initial_cplx(const char *arg)
2588
{
2589
    video_rc_initial_cplx = atof(arg);
2590
}
2591
static void opt_b_qfactor(const char *arg)
2592
{
2593
    video_b_qfactor = atof(arg);
2594
}
2595
static void opt_i_qfactor(const char *arg)
2596
{
2597
    video_i_qfactor = atof(arg);
2598
}
2599
static void opt_b_qoffset(const char *arg)
2600
{
2601
    video_b_qoffset = atof(arg);
2602
}
2603
static void opt_i_qoffset(const char *arg)
2604
{
2605
    video_i_qoffset = atof(arg);
2606
}
2607

    
2608
static void opt_ibias(const char *arg)
2609
{
2610
    video_intra_quant_bias = atoi(arg);
2611
}
2612
static void opt_pbias(const char *arg)
2613
{
2614
    video_inter_quant_bias = atoi(arg);
2615
}
2616

    
2617
static void opt_packet_size(const char *arg)
2618
{
2619
    packet_size= atoi(arg);
2620
}
2621

    
2622
static void opt_error_rate(const char *arg)
2623
{
2624
    error_rate= atoi(arg);
2625
}
2626

    
2627
static void opt_strict(const char *arg)
2628
{
2629
    strict= atoi(arg);
2630
}
2631

    
2632
static void opt_top_field_first(const char *arg)
2633
{
2634
    top_field_first= atoi(arg);
2635
}
2636

    
2637
static void opt_sc_threshold(const char *arg)
2638
{
2639
    sc_threshold= atoi(arg);
2640
}
2641

    
2642
static void opt_me_range(const char *arg)
2643
{
2644
    me_range = atoi(arg);
2645
}
2646

    
2647
static void opt_thread_count(const char *arg)
2648
{
2649
    thread_count= atoi(arg);
2650
#if !defined(HAVE_THREADS)
2651
    if (verbose >= 0)
2652
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2653
#endif
2654
}
2655

    
2656
static void opt_audio_bitrate(const char *arg)
2657
{
2658
    audio_bit_rate = atoi(arg) * 1000;
2659
}
2660

    
2661
static void opt_audio_rate(const char *arg)
2662
{
2663
    audio_sample_rate = atoi(arg);
2664
}
2665

    
2666
static void opt_audio_channels(const char *arg)
2667
{
2668
    audio_channels = atoi(arg);
2669
}
2670

    
2671
static void opt_video_device(const char *arg)
2672
{
2673
    video_device = av_strdup(arg);
2674
}
2675

    
2676
static void opt_grab_device(const char *arg)
2677
{
2678
    grab_device = av_strdup(arg);
2679
}
2680

    
2681
static void opt_video_channel(const char *arg)
2682
{
2683
    video_channel = strtol(arg, NULL, 0);
2684
}
2685

    
2686
static void opt_video_standard(const char *arg)
2687
{
2688
    video_standard = av_strdup(arg);
2689
}
2690

    
2691
static void opt_audio_device(const char *arg)
2692
{
2693
    audio_device = av_strdup(arg);
2694
}
2695

    
2696
static void opt_codec(int *pstream_copy, int *pcodec_id,
2697
                      int codec_type, const char *arg)
2698
{
2699
    AVCodec *p;
2700

    
2701
    if (!strcmp(arg, "copy")) {
2702
        *pstream_copy = 1;
2703
    } else {
2704
        p = first_avcodec;
2705
        while (p) {
2706
            if (!strcmp(p->name, arg) && p->type == codec_type)
2707
                break;
2708
            p = p->next;
2709
        }
2710
        if (p == NULL) {
2711
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2712
            exit(1);
2713
        } else {
2714
            *pcodec_id = p->id;
2715
        }
2716
    }
2717
}
2718

    
2719
static void opt_audio_codec(const char *arg)
2720
{
2721
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2722
}
2723

    
2724
static void opt_audio_tag(const char *arg)
2725
{
2726
    char *tail;
2727
    audio_codec_tag= strtol(arg, &tail, 0);
2728

    
2729
    if(!tail || *tail)
2730
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2731
}
2732

    
2733
static void opt_video_tag(const char *arg)
2734
{
2735
    char *tail;
2736
    video_codec_tag= strtol(arg, &tail, 0);
2737

    
2738
    if(!tail || *tail)
2739
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2740
}
2741

    
2742
static void add_frame_hooker(const char *arg)
2743
{
2744
    int argc = 0;
2745
    char *argv[64];
2746
    int i;
2747
    char *args = av_strdup(arg);
2748

    
2749
    using_vhook = 1;
2750

    
2751
    argv[0] = strtok(args, " ");
2752
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2753
    }
2754

    
2755
    i = frame_hook_add(argc, argv);
2756

    
2757
    if (i != 0) {
2758
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2759
        exit(1);
2760
    }
2761
}
2762

    
2763
const char *motion_str[] = {
2764
    "zero",
2765
    "full",
2766
    "log",
2767
    "phods",
2768
    "epzs",
2769
    "x1",
2770
    "hex",
2771
    "umh",
2772
    "iter",
2773
    NULL,
2774
};
2775

    
2776
static void opt_motion_estimation(const char *arg)
2777
{
2778
    const char **p;
2779
    p = motion_str;
2780
    for(;;) {
2781
        if (!*p) {
2782
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2783
            exit(1);
2784
        }
2785
        if (!strcmp(*p, arg))
2786
            break;
2787
        p++;
2788
    }
2789
    me_method = (p - motion_str) + 1;
2790
}
2791

    
2792
static void opt_video_codec(const char *arg)
2793
{
2794
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2795
}
2796

    
2797
static void opt_subtitle_codec(const char *arg)
2798
{
2799
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2800
}
2801

    
2802
static void opt_map(const char *arg)
2803
{
2804
    AVStreamMap *m;
2805
    const char *p;
2806

    
2807
    p = arg;
2808
    m = &stream_maps[nb_stream_maps++];
2809

    
2810
    m->file_index = strtol(arg, (char **)&p, 0);
2811
    if (*p)
2812
        p++;
2813

    
2814
    m->stream_index = strtol(p, (char **)&p, 0);
2815
    if (*p) {
2816
        p++;
2817
        m->sync_file_index = strtol(p, (char **)&p, 0);
2818
        if (*p)
2819
            p++;
2820
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2821
    } else {
2822
        m->sync_file_index = m->file_index;
2823
        m->sync_stream_index = m->stream_index;
2824
    }
2825
}
2826

    
2827
static void opt_map_meta_data(const char *arg)
2828
{
2829
    AVMetaDataMap *m;
2830
    const char *p;
2831

    
2832
    p = arg;
2833
    m = &meta_data_maps[nb_meta_data_maps++];
2834

    
2835
    m->out_file = strtol(arg, (char **)&p, 0);
2836
    if (*p)
2837
        p++;
2838

    
2839
    m->in_file = strtol(p, (char **)&p, 0);
2840
}
2841

    
2842
static void opt_recording_time(const char *arg)
2843
{
2844
    recording_time = parse_date(arg, 1);
2845
}
2846

    
2847
static void opt_start_time(const char *arg)
2848
{
2849
    start_time = parse_date(arg, 1);
2850
}
2851

    
2852
static void opt_rec_timestamp(const char *arg)
2853
{
2854
    rec_timestamp = parse_date(arg, 0) / 1000000;
2855
}
2856

    
2857
static void opt_input_ts_offset(const char *arg)
2858
{
2859
    input_ts_offset = parse_date(arg, 1);
2860
}
2861

    
2862
static void opt_input_file(const char *filename)
2863
{
2864
    AVFormatContext *ic;
2865
    AVFormatParameters params, *ap = &params;
2866
    int err, i, ret, rfps, rfps_base;
2867
    int64_t timestamp;
2868

    
2869
    if (!strcmp(filename, "-"))
2870
        filename = "pipe:";
2871

    
2872
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2873
                   !strcmp( filename, "/dev/stdin" );
2874

    
2875
    /* get default parameters from command line */
2876
    memset(ap, 0, sizeof(*ap));
2877
    ap->sample_rate = audio_sample_rate;
2878
    ap->channels = audio_channels;
2879
    ap->time_base.den = frame_rate;
2880
    ap->time_base.num = frame_rate_base;
2881
    ap->width = frame_width + frame_padleft + frame_padright;
2882
    ap->height = frame_height + frame_padtop + frame_padbottom;
2883
    ap->image_format = image_format;
2884
    ap->pix_fmt = frame_pix_fmt;
2885
    ap->device  = grab_device;
2886
    ap->channel = video_channel;
2887
    ap->standard = video_standard;
2888
    ap->video_codec_id = video_codec_id;
2889
    ap->audio_codec_id = audio_codec_id;
2890
    if(pgmyuv_compatibility_hack)
2891
        ap->video_codec_id= CODEC_ID_PGMYUV;
2892

    
2893
    /* open the input file with generic libav function */
2894
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2895
    if (err < 0) {
2896
        print_error(filename, err);
2897
        exit(1);
2898
    }
2899

    
2900
    if(genpts)
2901
        ic->flags|= AVFMT_FLAG_GENPTS;
2902

    
2903
    /* If not enough info to get the stream parameters, we decode the
2904
       first frames to get it. (used in mpeg case for example) */
2905
    ret = av_find_stream_info(ic);
2906
    if (ret < 0 && verbose >= 0) {
2907
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2908
        exit(1);
2909
    }
2910

    
2911
    timestamp = start_time;
2912
    /* add the stream start time */
2913
    if (ic->start_time != AV_NOPTS_VALUE)
2914
        timestamp += ic->start_time;
2915

    
2916
    /* if seeking requested, we execute it */
2917
    if (start_time != 0) {
2918
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2919
        if (ret < 0) {
2920
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2921
                    filename, (double)timestamp / AV_TIME_BASE);
2922
        }
2923
        /* reset seek info */
2924
        start_time = 0;
2925
    }
2926

    
2927
    /* update the current parameters so that they match the one of the input stream */
2928
    for(i=0;i<ic->nb_streams;i++) {
2929
        int j;
2930
        AVCodecContext *enc = ic->streams[i]->codec;
2931
#if defined(HAVE_THREADS)
2932
        if(thread_count>1)
2933
            avcodec_thread_init(enc, thread_count);
2934
#endif
2935
        enc->thread_count= thread_count;
2936
        switch(enc->codec_type) {
2937
        case CODEC_TYPE_AUDIO:
2938
            for(j=0; j<opt_name_count; j++){
2939
                AVOption *opt;
2940
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2941
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2942
                    av_set_double(enc, opt_names[j], d);
2943
            }
2944
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2945
            audio_channels = enc->channels;
2946
            audio_sample_rate = enc->sample_rate;
2947
            if(audio_disable)
2948
                ic->streams[i]->discard= AVDISCARD_ALL;
2949
            break;
2950
        case CODEC_TYPE_VIDEO:
2951
            for(j=0; j<opt_name_count; j++){
2952
                AVOption *opt;
2953
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2954
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2955
                    av_set_double(enc, opt_names[j], d);
2956
            }
2957
            frame_height = enc->height;
2958
            frame_width = enc->width;
2959
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2960
            frame_pix_fmt = enc->pix_fmt;
2961
            rfps      = ic->streams[i]->r_frame_rate.num;
2962
            rfps_base = ic->streams[i]->r_frame_rate.den;
2963
            enc->workaround_bugs = workaround_bugs;
2964
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2965
            if(me_threshold)
2966
                enc->debug |= FF_DEBUG_MV;
2967

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

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

    
2974
                    (float)rfps / rfps_base, rfps, rfps_base);
2975
            }
2976
            /* update the current frame rate to match the stream frame rate */
2977
            frame_rate      = rfps;
2978
            frame_rate_base = rfps_base;
2979

    
2980
            enc->rate_emu = rate_emu;
2981
            if(video_disable)
2982
                ic->streams[i]->discard= AVDISCARD_ALL;
2983
            else if(video_discard)
2984
                ic->streams[i]->discard= video_discard;
2985
            break;
2986
        case CODEC_TYPE_DATA:
2987
            break;
2988
        case CODEC_TYPE_SUBTITLE:
2989
            break;
2990
        case CODEC_TYPE_UNKNOWN:
2991
            break;
2992
        default:
2993
            av_abort();
2994
        }
2995
    }
2996

    
2997
    input_files[nb_input_files] = ic;
2998
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2999
    /* dump the file content */
3000
    if (verbose >= 0)
3001
        dump_format(ic, nb_input_files, filename, 0);
3002

    
3003
    nb_input_files++;
3004
    file_iformat = NULL;
3005
    file_oformat = NULL;
3006
    image_format = NULL;
3007

    
3008
    grab_device = NULL;
3009
    video_channel = 0;
3010

    
3011
    rate_emu = 0;
3012
}
3013

    
3014
static void opt_grab(const char *arg)
3015
{
3016
    file_iformat = av_find_input_format(arg);
3017
    opt_input_file("");
3018
}
3019

    
3020
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3021
{
3022
    int has_video, has_audio, i, j;
3023
    AVFormatContext *ic;
3024

    
3025
    has_video = 0;
3026
    has_audio = 0;
3027
    for(j=0;j<nb_input_files;j++) {
3028
        ic = input_files[j];
3029
        for(i=0;i<ic->nb_streams;i++) {
3030
            AVCodecContext *enc = ic->streams[i]->codec;
3031
            switch(enc->codec_type) {
3032
            case CODEC_TYPE_AUDIO:
3033
                has_audio = 1;
3034
                break;
3035
            case CODEC_TYPE_VIDEO:
3036
                has_video = 1;
3037
                break;
3038
            case CODEC_TYPE_DATA:
3039
            case CODEC_TYPE_UNKNOWN:
3040
            case CODEC_TYPE_SUBTITLE:
3041
                break;
3042
            default:
3043
                av_abort();
3044
            }
3045
        }
3046
    }
3047
    *has_video_ptr = has_video;
3048
    *has_audio_ptr = has_audio;
3049
}
3050

    
3051
static void new_video_stream(AVFormatContext *oc)
3052
{
3053
    AVStream *st;
3054
    AVCodecContext *video_enc;
3055
    int codec_id;
3056

    
3057
    st = av_new_stream(oc, oc->nb_streams);
3058
    if (!st) {
3059
        fprintf(stderr, "Could not alloc stream\n");
3060
        exit(1);
3061
    }
3062
#if defined(HAVE_THREADS)
3063
    if(thread_count>1)
3064
        avcodec_thread_init(st->codec, thread_count);
3065
#endif
3066

    
3067
    video_enc = st->codec;
3068

    
3069
    if(video_codec_tag)
3070
        video_enc->codec_tag= video_codec_tag;
3071

    
3072
    if(   (video_global_header&1)
3073
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3074
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3075
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3076
    }
3077
    if(video_global_header&2){
3078
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3079
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3080
    }
3081

    
3082
    if (video_stream_copy) {
3083
        st->stream_copy = 1;
3084
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3085
    } else {
3086
        char *p;
3087
        int i;
3088
        AVCodec *codec;
3089

    
3090
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3091
        if (video_codec_id != CODEC_ID_NONE)
3092
            codec_id = video_codec_id;
3093

    
3094
        video_enc->codec_id = codec_id;
3095
        codec = avcodec_find_encoder(codec_id);
3096

    
3097
        for(i=0; i<opt_name_count; i++){
3098
             AVOption *opt;
3099
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3100
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3101
                 av_set_double(video_enc, opt_names[i], d);
3102
        }
3103

    
3104
        video_enc->bit_rate = video_bit_rate;
3105
        video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3106
        video_enc->time_base.den = frame_rate;
3107
        video_enc->time_base.num = frame_rate_base;
3108
        if(codec && codec->supported_framerates){
3109
            const AVRational *p= codec->supported_framerates;
3110
            AVRational req= (AVRational){frame_rate, frame_rate_base};
3111
            const AVRational *best=NULL;
3112
            AVRational best_error= (AVRational){INT_MAX, 1};
3113
            for(; p->den!=0; p++){
3114
                AVRational error= av_sub_q(req, *p);
3115
                if(error.num <0) error.num *= -1;
3116
                if(av_cmp_q(error, best_error) < 0){
3117
                    best_error= error;
3118
                    best= p;
3119
                }
3120
            }
3121
            video_enc->time_base.den= best->num;
3122
            video_enc->time_base.num= best->den;
3123
        }
3124

    
3125
        video_enc->width = frame_width + frame_padright + frame_padleft;
3126
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3127
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3128
        video_enc->pix_fmt = frame_pix_fmt;
3129

    
3130
        if(codec && codec->pix_fmts){
3131
            const enum PixelFormat *p= codec->pix_fmts;
3132
            for(; *p!=-1; p++){
3133
                if(*p == video_enc->pix_fmt)
3134
                    break;
3135
            }
3136
            if(*p == -1)
3137
                video_enc->pix_fmt = codec->pix_fmts[0];
3138
        }
3139

    
3140
        if (!intra_only)
3141
            video_enc->gop_size = gop_size;
3142
        else
3143
            video_enc->gop_size = 0;
3144
        if (video_qscale || same_quality) {
3145
            video_enc->flags |= CODEC_FLAG_QSCALE;
3146
            video_enc->global_quality=
3147
                st->quality = FF_QP2LAMBDA * video_qscale;
3148
        }
3149

    
3150
        if(intra_matrix)
3151
            video_enc->intra_matrix = intra_matrix;
3152
        if(inter_matrix)
3153
            video_enc->inter_matrix = inter_matrix;
3154

    
3155
        video_enc->pre_me = pre_me;
3156

    
3157
        if (b_frames) {
3158
            video_enc->max_b_frames = b_frames;
3159
            video_enc->b_quant_factor = 2.0;
3160
        }
3161
        video_enc->qmin = video_qmin;
3162
        video_enc->qmax = video_qmax;
3163
        video_enc->lmin = video_lmin;
3164
        video_enc->lmax = video_lmax;
3165
        video_enc->rc_qsquish = video_qsquish;
3166
        video_enc->mb_lmin = video_mb_lmin;
3167
        video_enc->mb_lmax = video_mb_lmax;
3168
        video_enc->max_qdiff = video_qdiff;
3169
        video_enc->qblur = video_qblur;
3170
        video_enc->qcompress = video_qcomp;
3171
        video_enc->rc_eq = video_rc_eq;
3172
        video_enc->workaround_bugs = workaround_bugs;
3173
        video_enc->thread_count = thread_count;
3174
        p= video_rc_override_string;
3175
        for(i=0; p; i++){
3176
            int start, end, q;
3177
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3178
            if(e!=3){
3179
                fprintf(stderr, "error parsing rc_override\n");
3180
                exit(1);
3181
            }
3182
            video_enc->rc_override=
3183
                av_realloc(video_enc->rc_override,
3184
                           sizeof(RcOverride)*(i+1));
3185
            video_enc->rc_override[i].start_frame= start;
3186
            video_enc->rc_override[i].end_frame  = end;
3187
            if(q>0){
3188
                video_enc->rc_override[i].qscale= q;
3189
                video_enc->rc_override[i].quality_factor= 1.0;
3190
            }
3191
            else{
3192
                video_enc->rc_override[i].qscale= 0;
3193
                video_enc->rc_override[i].quality_factor= -q/100.0;
3194
            }
3195
            p= strchr(p, '/');
3196
            if(p) p++;
3197
        }
3198
        video_enc->rc_override_count=i;
3199

    
3200
        video_enc->rc_max_rate = video_rc_max_rate;
3201
        video_enc->rc_min_rate = video_rc_min_rate;
3202
        video_enc->rc_buffer_size = video_rc_buffer_size;
3203
        video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3204
        video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3205
        video_enc->rc_initial_cplx= video_rc_initial_cplx;
3206
        video_enc->i_quant_factor = video_i_qfactor;
3207
        video_enc->b_quant_factor = video_b_qfactor;
3208
        video_enc->i_quant_offset = video_i_qoffset;
3209
        video_enc->b_quant_offset = video_b_qoffset;
3210
        video_enc->intra_quant_bias = video_intra_quant_bias;
3211
        video_enc->inter_quant_bias = video_inter_quant_bias;
3212
        video_enc->me_threshold= me_threshold;
3213
        video_enc->mb_threshold= mb_threshold;
3214
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3215
        video_enc->strict_std_compliance = strict;
3216
        video_enc->error_rate = error_rate;
3217
        video_enc->scenechange_threshold= sc_threshold;
3218
        video_enc->me_range = me_range;
3219
        video_enc->me_penalty_compensation= me_penalty_compensation;
3220
        video_enc->frame_skip_threshold= frame_skip_threshold;
3221
        video_enc->frame_skip_factor= frame_skip_factor;
3222
        video_enc->frame_skip_exp= frame_skip_exp;
3223

    
3224
        if(packet_size){
3225
            video_enc->rtp_mode= 1;
3226
            video_enc->rtp_payload_size= packet_size;
3227
        }
3228

    
3229
        if (do_psnr)
3230
            video_enc->flags|= CODEC_FLAG_PSNR;
3231

    
3232
        video_enc->me_method = me_method;
3233

    
3234
        /* two pass mode */
3235
        if (do_pass) {
3236
            if (do_pass == 1) {
3237
                video_enc->flags |= CODEC_FLAG_PASS1;
3238
            } else {
3239
                video_enc->flags |= CODEC_FLAG_PASS2;
3240
            }
3241
        }
3242
    }
3243

    
3244
    /* reset some key parameters */
3245
    video_disable = 0;
3246
    video_codec_id = CODEC_ID_NONE;
3247
    video_stream_copy = 0;
3248
}
3249

    
3250
static void new_audio_stream(AVFormatContext *oc)
3251
{
3252
    AVStream *st;
3253
    AVCodecContext *audio_enc;
3254
    int codec_id, i;
3255

    
3256
    st = av_new_stream(oc, oc->nb_streams);
3257
    if (!st) {
3258
        fprintf(stderr, "Could not alloc stream\n");
3259
        exit(1);
3260
    }
3261
#if defined(HAVE_THREADS)
3262
    if(thread_count>1)
3263
        avcodec_thread_init(st->codec, thread_count);
3264
#endif
3265

    
3266
    audio_enc = st->codec;
3267
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3268

    
3269
    if(audio_codec_tag)
3270
        audio_enc->codec_tag= audio_codec_tag;
3271

    
3272
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3273
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3274
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3275
    }
3276
    if (audio_stream_copy) {
3277
        st->stream_copy = 1;
3278
        audio_enc->channels = audio_channels;
3279
    } else {
3280
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3281

    
3282
        for(i=0; i<opt_name_count; i++){
3283
            AVOption *opt;
3284
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
3285
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3286
                av_set_double(audio_enc, opt_names[i], d);
3287
        }
3288

    
3289
        if (audio_codec_id != CODEC_ID_NONE)
3290
            codec_id = audio_codec_id;
3291
        audio_enc->codec_id = codec_id;
3292

    
3293
        audio_enc->bit_rate = audio_bit_rate;
3294
        if (audio_qscale > QSCALE_NONE) {
3295
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3296
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3297
        }
3298
        audio_enc->strict_std_compliance = strict;
3299
        audio_enc->thread_count = thread_count;
3300
        /* For audio codecs other than AC3 or DTS we limit */
3301
        /* the number of coded channels to stereo   */
3302
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3303
            && codec_id != CODEC_ID_DTS) {
3304
            audio_enc->channels = 2;
3305
        } else
3306
            audio_enc->channels = audio_channels;
3307
    }
3308
    audio_enc->sample_rate = audio_sample_rate;
3309
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3310
    if (audio_language) {
3311
        pstrcpy(st->language, sizeof(st->language), audio_language);
3312
        av_free(audio_language);
3313
        audio_language = NULL;
3314
    }
3315

    
3316
    /* reset some key parameters */
3317
    audio_disable = 0;
3318
    audio_codec_id = CODEC_ID_NONE;
3319
    audio_stream_copy = 0;
3320
}
3321

    
3322
static void opt_new_subtitle_stream(void)
3323
{
3324
    AVFormatContext *oc;
3325
    AVStream *st;
3326
    AVCodecContext *subtitle_enc;
3327
    int i;
3328

    
3329
    if (nb_output_files <= 0) {
3330
        fprintf(stderr, "At least one output file must be specified\n");
3331
        exit(1);
3332
    }
3333
    oc = output_files[nb_output_files - 1];
3334

    
3335
    st = av_new_stream(oc, oc->nb_streams);
3336
    if (!st) {
3337
        fprintf(stderr, "Could not alloc stream\n");
3338
        exit(1);
3339
    }
3340

    
3341
    subtitle_enc = st->codec;
3342
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3343
    if (subtitle_stream_copy) {
3344
        st->stream_copy = 1;
3345
    } else {
3346
        for(i=0; i<opt_name_count; i++){
3347
             AVOption *opt;
3348
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3349
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3350
                 av_set_double(subtitle_enc, opt_names[i], d);
3351
        }
3352
        subtitle_enc->codec_id = subtitle_codec_id;
3353
    }
3354

    
3355
    if (subtitle_language) {
3356
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3357
        av_free(subtitle_language);
3358
        subtitle_language = NULL;
3359
    }
3360

    
3361
    subtitle_codec_id = CODEC_ID_NONE;
3362
    subtitle_stream_copy = 0;
3363
}
3364

    
3365
static void opt_new_audio_stream(void)
3366
{
3367
    AVFormatContext *oc;
3368
    if (nb_output_files <= 0) {
3369
        fprintf(stderr, "At least one output file must be specified\n");
3370
        exit(1);
3371
    }
3372
    oc = output_files[nb_output_files - 1];
3373
    new_audio_stream(oc);
3374
}
3375

    
3376
static void opt_new_video_stream(void)
3377
{
3378
    AVFormatContext *oc;
3379
    if (nb_output_files <= 0) {
3380
        fprintf(stderr, "At least one output file must be specified\n");
3381
        exit(1);
3382
    }
3383
    oc = output_files[nb_output_files - 1];
3384
    new_video_stream(oc);
3385
}
3386

    
3387
static void opt_output_file(const char *filename)
3388
{
3389
    AVFormatContext *oc;
3390
    int use_video, use_audio, input_has_video, input_has_audio;
3391
    AVFormatParameters params, *ap = &params;
3392

    
3393
    if (!strcmp(filename, "-"))
3394
        filename = "pipe:";
3395

    
3396
    oc = av_alloc_format_context();
3397

    
3398
    if (!file_oformat) {
3399
        file_oformat = guess_format(NULL, filename, NULL);
3400
        if (!file_oformat) {
3401
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3402
                    filename);
3403
            exit(1);
3404
        }
3405
    }
3406

    
3407
    oc->oformat = file_oformat;
3408
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3409

    
3410
    if (!strcmp(file_oformat->name, "ffm") &&
3411
        strstart(filename, "http:", NULL)) {
3412
        /* special case for files sent to ffserver: we get the stream
3413
           parameters from ffserver */
3414
        if (read_ffserver_streams(oc, filename) < 0) {
3415
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3416
            exit(1);
3417
        }
3418
    } else {
3419
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3420
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3421

    
3422
        /* disable if no corresponding type found and at least one
3423
           input file */
3424
        if (nb_input_files > 0) {
3425
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3426
            if (!input_has_video)
3427
                use_video = 0;
3428
            if (!input_has_audio)
3429
                use_audio = 0;
3430
        }
3431

    
3432
        /* manual disable */
3433
        if (audio_disable) {
3434
            use_audio = 0;
3435
        }
3436
        if (video_disable) {
3437
            use_video = 0;
3438
        }
3439

    
3440
        if (use_video) {
3441
            new_video_stream(oc);
3442
        }
3443

    
3444
        if (use_audio) {
3445
            new_audio_stream(oc);
3446
        }
3447

    
3448
        if (!oc->nb_streams) {
3449
            fprintf(stderr, "No audio or video streams available\n");
3450
            exit(1);
3451
        }
3452

    
3453
        oc->timestamp = rec_timestamp;
3454

    
3455
        if (str_title)
3456
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3457
        if (str_author)
3458
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3459
        if (str_copyright)
3460
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3461
        if (str_comment)
3462
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3463
    }
3464

    
3465
    output_files[nb_output_files++] = oc;
3466

    
3467
    /* check filename in case of an image number is expected */
3468
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3469
        if (filename_number_test(oc->filename) < 0) {
3470
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3471
            exit(1);
3472
        }
3473
    }
3474

    
3475
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3476
        /* test if it already exists to avoid loosing precious files */
3477
        if (!file_overwrite &&
3478
            (strchr(filename, ':') == NULL ||
3479
             strstart(filename, "file:", NULL))) {
3480
            if (url_exist(filename)) {
3481
                int c;
3482

    
3483
                if ( !using_stdin ) {
3484
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3485
                    fflush(stderr);
3486
                    c = getchar();
3487
                    if (toupper(c) != 'Y') {
3488
                        fprintf(stderr, "Not overwriting - exiting\n");
3489
                        exit(1);
3490
                    }
3491
                                }
3492
                                else {
3493
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3494
                    exit(1);
3495
                                }
3496
            }
3497
        }
3498

    
3499
        /* open the file */
3500
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3501
            fprintf(stderr, "Could not open '%s'\n", filename);
3502
            exit(1);
3503
        }
3504
    }
3505

    
3506
    memset(ap, 0, sizeof(*ap));
3507
    ap->image_format = image_format;
3508
    if (av_set_parameters(oc, ap) < 0) {
3509
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3510
                oc->filename);
3511
        exit(1);
3512
    }
3513

    
3514
    oc->packet_size= mux_packet_size;
3515
    oc->mux_rate= mux_rate;
3516
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3517
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3518
    oc->loop_output = loop_output;
3519

    
3520
    /* reset some options */
3521
    file_oformat = NULL;
3522
    file_iformat = NULL;
3523
    image_format = NULL;
3524
}
3525

    
3526
/* prepare dummy protocols for grab */
3527
static void prepare_grab(void)
3528
{
3529
    int has_video, has_audio, i, j;
3530
    AVFormatContext *oc;
3531
    AVFormatContext *ic;
3532
    AVFormatParameters vp1, *vp = &vp1;
3533
    AVFormatParameters ap1, *ap = &ap1;
3534

    
3535
    /* see if audio/video inputs are needed */
3536
    has_video = 0;
3537
    has_audio = 0;
3538
    memset(ap, 0, sizeof(*ap));
3539
    memset(vp, 0, sizeof(*vp));
3540
    vp->time_base.num= 1;
3541
    for(j=0;j<nb_output_files;j++) {
3542
        oc = output_files[j];
3543
        for(i=0;i<oc->nb_streams;i++) {
3544
            AVCodecContext *enc = oc->streams[i]->codec;
3545
            switch(enc->codec_type) {
3546
            case CODEC_TYPE_AUDIO:
3547
                if (enc->sample_rate > ap->sample_rate)
3548
                    ap->sample_rate = enc->sample_rate;
3549
                if (enc->channels > ap->channels)
3550
                    ap->channels = enc->channels;
3551
                has_audio = 1;
3552
                break;
3553
            case CODEC_TYPE_VIDEO:
3554
                if (enc->width > vp->width)
3555
                    vp->width = enc->width;
3556
                if (enc->height > vp->height)
3557
                    vp->height = enc->height;
3558

    
3559
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3560
                    vp->time_base = enc->time_base;
3561
                }
3562
                has_video = 1;
3563
                break;
3564
            default:
3565
                av_abort();
3566
            }
3567
        }
3568
    }
3569

    
3570
    if (has_video == 0 && has_audio == 0) {
3571
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3572
        exit(1);
3573
    }
3574

    
3575
    if (has_video) {
3576
        AVInputFormat *fmt1;
3577
        fmt1 = av_find_input_format(video_grab_format);
3578
        vp->device  = video_device;
3579
        vp->channel = video_channel;
3580
        vp->standard = video_standard;
3581
        vp->pix_fmt = frame_pix_fmt;
3582
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3583
            fprintf(stderr, "Could not find video grab device\n");
3584
            exit(1);
3585
        }
3586
        /* If not enough info to get the stream parameters, we decode the
3587
           first frames to get it. */
3588
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3589
            fprintf(stderr, "Could not find video grab parameters\n");
3590
            exit(1);
3591
        }
3592
        /* by now video grab has one stream */
3593
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3594
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3595
        input_files[nb_input_files] = ic;
3596

    
3597
        if (verbose >= 0)
3598
            dump_format(ic, nb_input_files, "", 0);
3599

    
3600
        nb_input_files++;
3601
    }
3602
    if (has_audio && audio_grab_format) {
3603
        AVInputFormat *fmt1;
3604
        fmt1 = av_find_input_format(audio_grab_format);
3605
        ap->device = audio_device;
3606
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3607
            fprintf(stderr, "Could not find audio grab device\n");
3608
            exit(1);
3609
        }
3610
        input_files[nb_input_files] = ic;
3611

    
3612
        if (verbose >= 0)
3613
            dump_format(ic, nb_input_files, "", 0);
3614

    
3615
        nb_input_files++;
3616
    }
3617
}
3618

    
3619
/* same option as mencoder */
3620
static void opt_pass(const char *pass_str)
3621
{
3622
    int pass;
3623
    pass = atoi(pass_str);
3624
    if (pass != 1 && pass != 2) {
3625
        fprintf(stderr, "pass number can be only 1 or 2\n");
3626
        exit(1);
3627
    }
3628
    do_pass = pass;
3629
}
3630

    
3631
#if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3632
static int64_t getutime(void)
3633
{
3634
  return av_gettime();
3635
}
3636
#else
3637
static int64_t getutime(void)
3638
{
3639
    struct rusage rusage;
3640

    
3641
    getrusage(RUSAGE_SELF, &rusage);
3642
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3643
}
3644
#endif
3645

    
3646
extern int ffm_nopts;
3647

    
3648
static void show_formats(void)
3649
{
3650
    AVInputFormat *ifmt;
3651
    AVOutputFormat *ofmt;
3652
    AVImageFormat *image_fmt;
3653
    URLProtocol *up;
3654
    AVCodec *p, *p2;
3655
    const char **pp, *last_name;
3656

    
3657
    printf("File formats:\n");
3658
    last_name= "000";
3659
    for(;;){
3660
        int decode=0;
3661
        int encode=0;
3662
        const char *name=NULL;
3663
        const char *long_name=NULL;
3664

    
3665
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3666
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3667
                strcmp(ofmt->name, last_name)>0){
3668
                name= ofmt->name;
3669
                long_name= ofmt->long_name;
3670
                encode=1;
3671
            }
3672
        }
3673
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3674
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3675
                strcmp(ifmt->name, last_name)>0){
3676
                name= ifmt->name;
3677
                long_name= ifmt->long_name;
3678
                encode=0;
3679
            }
3680
            if(name && strcmp(ifmt->name, name)==0)
3681
                decode=1;
3682
        }
3683
        if(name==NULL)
3684
            break;
3685
        last_name= name;
3686

    
3687
        printf(
3688
            " %s%s %-15s %s\n",
3689
            decode ? "D":" ",
3690
            encode ? "E":" ",
3691
            name,
3692
            long_name ? long_name:" ");
3693
    }
3694
    printf("\n");
3695

    
3696
    printf("Image formats (filename extensions, if any, follow):\n");
3697
    for(image_fmt = first_image_format; image_fmt != NULL;
3698
        image_fmt = image_fmt->next) {
3699
        printf(
3700
            " %s%s %-6s %s\n",
3701
            image_fmt->img_read  ? "D":" ",
3702
            image_fmt->img_write ? "E":" ",
3703
            image_fmt->name,
3704
            image_fmt->extensions ? image_fmt->extensions:" ");
3705
    }
3706
    printf("\n");
3707

    
3708
    printf("Codecs:\n");
3709
    last_name= "000";
3710
    for(;;){
3711
        int decode=0;
3712
        int encode=0;
3713
        int cap=0;
3714
        const char *type_str;
3715

    
3716
        p2=NULL;
3717
        for(p = first_avcodec; p != NULL; p = p->next) {
3718
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3719
                strcmp(p->name, last_name)>0){
3720
                p2= p;
3721
                decode= encode= cap=0;
3722
            }
3723
            if(p2 && strcmp(p->name, p2->name)==0){
3724
                if(p->decode) decode=1;
3725
                if(p->encode) encode=1;
3726
                cap |= p->capabilities;
3727
            }
3728
        }
3729
        if(p2==NULL)
3730
            break;
3731
        last_name= p2->name;
3732

    
3733
        switch(p2->type) {
3734
        case CODEC_TYPE_VIDEO:
3735
            type_str = "V";
3736
            break;
3737
        case CODEC_TYPE_AUDIO:
3738
            type_str = "A";
3739
            break;
3740
        case CODEC_TYPE_SUBTITLE:
3741
            type_str = "S";
3742
            break;
3743
        default:
3744
            type_str = "?";
3745
            break;
3746
        }
3747
        printf(
3748
            " %s%s%s%s%s%s %s",
3749
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3750
            encode ? "E":" ",
3751
            type_str,
3752
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3753
            cap & CODEC_CAP_DR1 ? "D":" ",
3754
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3755
            p2->name);
3756
       /* if(p2->decoder && decode==0)
3757
            printf(" use %s for decoding", p2->decoder->name);*/
3758
        printf("\n");
3759
    }
3760
    printf("\n");
3761

    
3762
    printf("Supported file protocols:\n");
3763
    for(up = first_protocol; up != NULL; up = up->next)
3764
        printf(" %s:", up->name);
3765
    printf("\n");
3766

    
3767
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3768
    printf("Motion estimation methods:\n");
3769
    pp = motion_str;
3770
    while (*pp) {
3771
        printf(" %s", *pp);
3772
        if ((pp - motion_str + 1) == ME_ZERO)
3773
            printf("(fastest)");
3774
        else if ((pp - motion_str + 1) == ME_FULL)
3775
            printf("(slowest)");
3776
        else if ((pp - motion_str + 1) == ME_EPZS)
3777
            printf("(default)");
3778
        pp++;
3779
    }
3780
    printf("\n\n");
3781
    printf(
3782
"Note, the names of encoders and decoders dont always match, so there are\n"
3783
"several cases where the above table shows encoder only or decoder only entries\n"
3784
"even though both encoding and decoding are supported for example, the h263\n"
3785
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3786
"worse\n");
3787
    exit(1);
3788
}
3789

    
3790
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3791
{
3792
    int i;
3793
    const char *p = str;
3794
    for(i = 0;; i++) {
3795
        dest[i] = atoi(p);
3796
        if(i == 63)
3797
            break;
3798
        p = strchr(p, ',');
3799
        if(!p) {
3800
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3801
            exit(1);
3802
        }
3803
        p++;
3804
    }
3805
}
3806

    
3807
static void opt_inter_matrix(const char *arg)
3808
{
3809
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3810
    parse_matrix_coeffs(inter_matrix, arg);
3811
}
3812

    
3813
static void opt_intra_matrix(const char *arg)
3814
{
3815
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3816
    parse_matrix_coeffs(intra_matrix, arg);
3817
}
3818

    
3819
static void opt_target(const char *arg)
3820
{
3821
    int norm = -1;
3822
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3823

    
3824
    if(!strncmp(arg, "pal-", 4)) {
3825
        norm = 0;
3826
        arg += 4;
3827
    } else if(!strncmp(arg, "ntsc-", 5)) {
3828
        norm = 1;
3829
        arg += 5;
3830
    } else if(!strncmp(arg, "film-", 5)) {
3831
        norm = 2;
3832
        arg += 5;
3833
    } else {
3834
        int fr;
3835
        /* Calculate FR via float to avoid int overflow */
3836
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3837
        if(fr == 25000) {
3838
            norm = 0;
3839
        } else if((fr == 29970) || (fr == 23976)) {
3840
            norm = 1;
3841
        } else {
3842
            /* Try to determine PAL/NTSC by peeking in the input files */
3843
            if(nb_input_files) {
3844
                int i, j;
3845
                for(j = 0; j < nb_input_files; j++) {
3846
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3847
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3848
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3849
                            continue;
3850
                        fr = c->time_base.den * 1000 / c->time_base.num;
3851
                        if(fr == 25000) {
3852
                            norm = 0;
3853
                            break;
3854
                        } else if((fr == 29970) || (fr == 23976)) {
3855
                            norm = 1;
3856
                            break;
3857
                        }
3858
                    }
3859
                    if(norm >= 0)
3860
                        break;
3861
                }
3862
            }
3863
        }
3864
        if(verbose && norm >= 0)
3865
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3866
    }
3867

    
3868
    if(norm < 0) {
3869
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3870
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3871
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3872
        exit(1);
3873
    }
3874

    
3875
    if(!strcmp(arg, "vcd")) {
3876

    
3877
        opt_video_codec("mpeg1video");
3878
        opt_audio_codec("mp2");
3879
        opt_format("vcd");
3880

    
3881
        opt_frame_size(norm ? "352x240" : "352x288");
3882
        opt_frame_rate(frame_rates[norm]);
3883
        opt_gop_size(norm ? "18" : "15");
3884

    
3885
        video_bit_rate = 1150000;
3886
        video_rc_max_rate = 1150000;
3887
        video_rc_min_rate = 1150000;
3888
        video_rc_buffer_size = 40*1024*8;
3889

    
3890
        audio_bit_rate = 224000;
3891
        audio_sample_rate = 44100;
3892

    
3893
        mux_packet_size= 2324;
3894
        mux_rate= 2352 * 75 * 8;
3895

    
3896
        /* We have to offset the PTS, so that it is consistent with the SCR.
3897
           SCR starts at 36000, but the first two packs contain only padding
3898
           and the first pack from the other stream, respectively, may also have
3899
           been written before.
3900
           So the real data starts at SCR 36000+3*1200. */
3901
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3902
    } else if(!strcmp(arg, "svcd")) {
3903

    
3904
        opt_video_codec("mpeg2video");
3905
        opt_audio_codec("mp2");
3906
        opt_format("svcd");
3907

    
3908
        opt_frame_size(norm ? "480x480" : "480x576");
3909
        opt_frame_rate(frame_rates[norm]);
3910
        opt_gop_size(norm ? "18" : "15");
3911

    
3912
        video_bit_rate = 2040000;
3913
        video_rc_max_rate = 2516000;
3914
        video_rc_min_rate = 0; //1145000;
3915
        video_rc_buffer_size = 224*1024*8;
3916
        opt_default("flags", "+SCAN_OFFSET");
3917

    
3918

    
3919
        audio_bit_rate = 224000;
3920
        audio_sample_rate = 44100;
3921

    
3922
        mux_packet_size= 2324;
3923

    
3924
    } else if(!strcmp(arg, "dvd")) {
3925

    
3926
        opt_video_codec("mpeg2video");
3927
        opt_audio_codec("ac3");
3928
        opt_format("dvd");
3929

    
3930
        opt_frame_size(norm ? "720x480" : "720x576");
3931
        opt_frame_rate(frame_rates[norm]);
3932
        opt_gop_size(norm ? "18" : "15");
3933

    
3934
        video_bit_rate = 6000000;
3935
        video_rc_max_rate = 9000000;
3936
        video_rc_min_rate = 0; //1500000;
3937
        video_rc_buffer_size = 224*1024*8;
3938

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

    
3942
        audio_bit_rate = 448000;
3943
        audio_sample_rate = 48000;
3944

    
3945
    } else if(!strcmp(arg, "dv")) {
3946

    
3947
        opt_format("dv");
3948

    
3949
        opt_frame_size(norm ? "720x480" : "720x576");
3950
        opt_frame_rate(frame_rates[norm]);
3951

    
3952
        audio_sample_rate = 48000;
3953
        audio_channels = 2;
3954

    
3955
    } else {
3956
        fprintf(stderr, "Unknown target: %s\n", arg);
3957
        exit(1);
3958
    }
3959
}
3960

    
3961
static void show_version(void)
3962
{
3963
    /* TODO: add function interface to avutil and avformat */
3964
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3965
           "libavutil   %d\n"
3966
           "libavcodec  %d\n"
3967
           "libavformat %d\n",
3968
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3969
    exit(1);
3970
}
3971

    
3972
static int opt_default(const char *opt, const char *arg){
3973
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3974
    if(!o)
3975
        return -1;
3976

    
3977
//    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3978

    
3979
    //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3980
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3981
    opt_names[opt_name_count++]= o->name;
3982

    
3983
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3984
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3985
        ffm_nopts = 1;
3986

    
3987
    if(avctx_opts->debug)
3988
        av_log_set_level(AV_LOG_DEBUG);
3989
    return 0;
3990
}
3991

    
3992
const OptionDef options[] = {
3993
    /* main options */
3994
    { "L", 0, {(void*)show_license}, "show license" },
3995
    { "h", 0, {(void*)show_help}, "show help" },
3996
    { "version", 0, {(void*)show_version}, "show version" },
3997
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3998
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3999
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
4000
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4001
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4002
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4003
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4004
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
4005
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4006
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4007
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4008
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4009
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4010
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4011
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4012
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4013
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4014
      "add timings for benchmarking" },
4015
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4016
      "dump each input packet" },
4017
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4018
      "when dumping packets, also dump the payload" },
4019
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4020
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4021
    { "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)", "" },
4022
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4023
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4024
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4025
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4026
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4027
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4028
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4029
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4030
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
4031

    
4032
    /* video options */
4033
    { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4034
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4035
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4036
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4037
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4038
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4039
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4040
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4041
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4042
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4043
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4044
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4045
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4046
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4047
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4048
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4049
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4050
    { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4051
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4052
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4053
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4054
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4055
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4056
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4057
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4058
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4059
    { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4060
    { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4061
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4062
    { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4063
    { "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" },
4064
    { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4065
    { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4066
    { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4067
    { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4068
    { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4069
    { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4070
    { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4071
    { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4072
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4073
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4074
    { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4075
    { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4076
    { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4077
    { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4078
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4079
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4080
      "method" },
4081
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
4082
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
4083
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4084
    { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4085
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4086
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4087
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4088
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4089
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4090
      "use same video quality as source (implies VBR)" },
4091
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4092
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4093
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4094
      "deinterlace pictures" },
4095
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4096
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4097
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4098
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4099
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4100
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4101
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4102
    { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4103
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4104
    { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4105
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4106
    { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4107
    { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4108
    { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4109
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4110
    { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4111
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4112

    
4113
    /* audio options */
4114
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4115
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4116
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4117
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4118
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4119
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4120
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4121
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4122
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4123
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4124

    
4125
    /* subtitle options */
4126
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4127
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4128
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4129

    
4130
    /* grab options */
4131
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4132
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4133
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4134
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4135

    
4136
    /* G.2 grab options */
4137
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4138
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4139

    
4140
    /* muxer options */
4141
    { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4142
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4143
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4144
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4145
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4146
    { NULL, },
4147
};
4148

    
4149
static void show_banner(void)
4150
{
4151
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4152
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
4153
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4154
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4155
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4156
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4157
#ifdef __GNUC__
4158
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
4159
#else
4160
    fprintf(stderr, ", using a non-gcc compiler\n");
4161
#endif
4162
}
4163

    
4164
static void show_license(void)
4165
{
4166
    show_banner();
4167
#ifdef CONFIG_GPL
4168
    printf(
4169
    "This program is free software; you can redistribute it and/or modify\n"
4170
    "it under the terms of the GNU General Public License as published by\n"
4171
    "the Free Software Foundation; either version 2 of the License, or\n"
4172
    "(at your option) any later version.\n"
4173
    "\n"
4174
    "This program is distributed in the hope that it will be useful,\n"
4175
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4176
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4177
    "GNU General Public License for more details.\n"
4178
    "\n"
4179
    "You should have received a copy of the GNU General Public License\n"
4180
    "along with this program; if not, write to the Free Software\n"
4181
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4182
    );
4183
#else
4184
    printf(
4185
    "This library is free software; you can redistribute it and/or\n"
4186
    "modify it under the terms of the GNU Lesser General Public\n"
4187
    "License as published by the Free Software Foundation; either\n"
4188
    "version 2 of the License, or (at your option) any later version.\n"
4189
    "\n"
4190
    "This library is distributed in the hope that it will be useful,\n"
4191
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4192
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4193
    "Lesser General Public License for more details.\n"
4194
    "\n"
4195
    "You should have received a copy of the GNU Lesser General Public\n"
4196
    "License along with this library; if not, write to the Free Software\n"
4197
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4198
    );
4199
#endif
4200
    exit(1);
4201
}
4202

    
4203
static void show_help(void)
4204
{
4205
    show_banner();
4206
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4207
           "Hyper fast Audio and Video encoder\n");
4208
    printf("\n");
4209
    show_help_options(options, "Main options:\n",
4210
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4211
    show_help_options(options, "\nVideo options:\n",
4212
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4213
                      OPT_VIDEO);
4214
    show_help_options(options, "\nAdvanced Video options:\n",
4215
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4216
                      OPT_VIDEO | OPT_EXPERT);
4217
    show_help_options(options, "\nAudio options:\n",
4218
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4219
                      OPT_AUDIO);
4220
    show_help_options(options, "\nAdvanced Audio options:\n",
4221
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4222
                      OPT_AUDIO | OPT_EXPERT);
4223
    show_help_options(options, "\nSubtitle options:\n",
4224
                      OPT_SUBTITLE | OPT_GRAB,
4225
                      OPT_SUBTITLE);
4226
    show_help_options(options, "\nAudio/Video grab options:\n",
4227
                      OPT_GRAB,
4228
                      OPT_GRAB);
4229
    show_help_options(options, "\nAdvanced options:\n",
4230
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4231
                      OPT_EXPERT);
4232
    av_opt_show(avctx_opts, NULL);
4233

    
4234
    exit(1);
4235
}
4236

    
4237
void parse_arg_file(const char *filename)
4238
{
4239
    opt_output_file(filename);
4240
}
4241

    
4242
int main(int argc, char **argv)
4243
{
4244
    int i;
4245
    int64_t ti;
4246

    
4247
    av_register_all();
4248

    
4249
    avctx_opts= avcodec_alloc_context();
4250

    
4251
    if (argc <= 1)
4252
        show_help();
4253
    else
4254
        show_banner();
4255

    
4256
    /* parse options */
4257
    parse_options(argc, argv, options);
4258

    
4259
    /* file converter / grab */
4260
    if (nb_output_files <= 0) {
4261
        fprintf(stderr, "Must supply at least one output file\n");
4262
        exit(1);
4263
    }
4264

    
4265
    if (nb_input_files == 0) {
4266
        input_sync = 1;
4267
        prepare_grab();
4268
    }
4269

    
4270
    ti = getutime();
4271
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
4272
              stream_maps, nb_stream_maps);
4273
    ti = getutime() - ti;
4274
    if (do_benchmark) {
4275
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4276
    }
4277

    
4278
    /* close files */
4279
    for(i=0;i<nb_output_files;i++) {
4280
        /* maybe av_close_output_file ??? */
4281
        AVFormatContext *s = output_files[i];
4282
        int j;
4283
        if (!(s->oformat->flags & AVFMT_NOFILE))
4284
            url_fclose(&s->pb);
4285
        for(j=0;j<s->nb_streams;j++)
4286
            av_free(s->streams[j]);
4287
        av_free(s);
4288
    }
4289
    for(i=0;i<nb_input_files;i++)
4290
        av_close_input_file(input_files[i]);
4291

    
4292
    av_free_static();
4293

    
4294
    if(intra_matrix)
4295
        av_free(intra_matrix);
4296
    if(inter_matrix)
4297
        av_free(inter_matrix);
4298

    
4299
#ifdef POWERPC_PERFORMANCE_REPORT
4300
    extern void powerpc_display_perf_report(void);
4301
    powerpc_display_perf_report();
4302
#endif /* POWERPC_PERFORMANCE_REPORT */
4303

    
4304
#ifndef CONFIG_WIN32
4305
    if (received_sigterm) {
4306
        fprintf(stderr,
4307
            "Received signal %d: terminating.\n",
4308
            (int) received_sigterm);
4309
        exit (255);
4310
    }
4311
#endif
4312
    exit(0); /* not all OS-es handle main() return value */
4313
    return 0;
4314
}