Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ f038fe8b

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
static char *video_grab_format = "video4linux";
217
#endif
218
static char *video_device = NULL;
219
static char *grab_device = NULL;
220
static int  video_channel = 0;
221
static char *video_standard = "ntsc";
222

    
223
static char *audio_grab_format = "audio_device";
224
static char *audio_device = NULL;
225
static int audio_volume = 256;
226

    
227
static int using_stdin = 0;
228
static int using_vhook = 0;
229
static int verbose = 1;
230
static int thread_count= 1;
231
static int q_pressed = 0;
232
static int me_range = 0;
233
static int64_t video_size = 0;
234
static int64_t audio_size = 0;
235
static int64_t extra_size = 0;
236
static int nb_frames_dup = 0;
237
static int nb_frames_drop = 0;
238
static int input_sync;
239
static int limit_filesize = 0; //
240

    
241
static int pgmyuv_compatibility_hack=0;
242

    
243
const char **opt_names=NULL;
244
int opt_name_count=0;
245
AVCodecContext *avctx_opts;
246

    
247

    
248
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
249

    
250
struct AVInputStream;
251

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

    
269
    int video_crop;          /* video_resample and video_crop are mutually exclusive */
270
    int topBand;             /* cropping area sizes */
271
    int leftBand;
272

    
273
    int video_pad;           /* video_resample and video_pad are mutually exclusive */
274
    int padtop;              /* padding area sizes */
275
    int padbottom;
276
    int padleft;
277
    int padright;
278

    
279
    /* audio only */
280
    int audio_resample;
281
    ReSampleContext *resample; /* for audio resampling */
282
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
283
    FILE *logfile;
284
} AVOutputStream;
285

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

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

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

    
311
#ifndef CONFIG_WIN32
312

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

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

    
321
static volatile sig_atomic_t received_sigterm = 0;
322

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

    
330
static void term_init(void)
331
{
332
    struct termios tty;
333

    
334
    tcgetattr (0, &tty);
335
    oldtty = tty;
336

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

    
346
    tcsetattr (0, TCSANOW, &tty);
347

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

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

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

    
380
        return n;
381
    }
382
    return -1;
383
}
384

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

    
390
#else
391

    
392
static volatile int received_sigterm = 0;
393

    
394
/* no interactive support */
395
static void term_exit(void)
396
{
397
}
398

    
399
static void term_init(void)
400
{
401
}
402

    
403
static int read_key(void)
404
{
405
    return 0;
406
}
407

    
408
#endif
409

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

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

    
423
        // FIXME: a more elegant solution is needed
424
        st = av_mallocz(sizeof(AVStream));
425
        memcpy(st, ic->streams[i], sizeof(AVStream));
426
        st->codec = avcodec_alloc_context();
427
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
428
        s->streams[i] = st;
429
    }
430

    
431
    av_close_input_file(ic);
432
    return 0;
433
}
434

    
435
static double
436
get_sync_ipts(const AVOutputStream *ost)
437
{
438
    const AVInputStream *ist = ost->sync_ist;
439
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
440
}
441

    
442
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
443

    
444
static void do_audio_out(AVFormatContext *s,
445
                         AVOutputStream *ost,
446
                         AVInputStream *ist,
447
                         unsigned char *buf, int size)
448
{
449
    uint8_t *buftmp;
450
    static uint8_t *audio_buf = NULL;
451
    static uint8_t *audio_out = NULL;
452
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
453

    
454
    int size_out, frame_bytes, ret;
455
    AVCodecContext *enc= ost->st->codec;
456

    
457
    /* SC: dynamic allocation of buffers */
458
    if (!audio_buf)
459
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
460
    if (!audio_out)
461
        audio_out = av_malloc(audio_out_size);
462
    if (!audio_buf || !audio_out)
463
        return;               /* Should signal an error ! */
464

    
465
    if(audio_sync_method){
466
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
467
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
468
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
469
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
470

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

    
487
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
488
                        ist->is_start=0;
489
                    else
490
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
491

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

    
512
    if (ost->audio_resample) {
513
        buftmp = audio_buf;
514
        size_out = audio_resample(ost->resample,
515
                                  (short *)buftmp, (short *)buf,
516
                                  size / (ist->st->codec->channels * 2));
517
        size_out = size_out * enc->channels * 2;
518
    } else {
519
        buftmp = buf;
520
        size_out = size;
521
    }
522

    
523
    /* now encode as many frames as possible */
524
    if (enc->frame_size > 1) {
525
        /* output resampled raw samples */
526
        fifo_write(&ost->fifo, buftmp, size_out,
527
                   &ost->fifo.wptr);
528

    
529
        frame_bytes = enc->frame_size * 2 * enc->channels;
530

    
531
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
532
                     &ost->fifo.rptr) == 0) {
533
            AVPacket pkt;
534
            av_init_packet(&pkt);
535

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

    
547
            ost->sync_opts += enc->frame_size;
548
        }
549
    } else {
550
        AVPacket pkt;
551
        av_init_packet(&pkt);
552

    
553
        ost->sync_opts += size_out / (2 * enc->channels);
554

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

    
593
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
594
{
595
    AVCodecContext *dec;
596
    AVPicture *picture2;
597
    AVPicture picture_tmp;
598
    uint8_t *buf = 0;
599

    
600
    dec = ist->st->codec;
601

    
602
    /* deinterlace : must be done before any resize */
603
    if (do_deinterlace || using_vhook) {
604
        int size;
605

    
606
        /* create temporary picture */
607
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
608
        buf = av_malloc(size);
609
        if (!buf)
610
            return;
611

    
612
        picture2 = &picture_tmp;
613
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
614

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

    
636
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
637

    
638
    if (picture != picture2)
639
        *picture = *picture2;
640
    *bufp = buf;
641
}
642

    
643
/* we begin to correct av delay at this threshold */
644
#define AV_DELAY_MAX 0.100
645

    
646

    
647
/* Expects img to be yuv420 */
648
static void fill_pad_region(AVPicture* img, int height, int width,
649
        int padtop, int padbottom, int padleft, int padright, int *color) {
650

    
651
    int i, y, shift;
652
    uint8_t *optr;
653

    
654
    for (i = 0; i < 3; i++) {
655
        shift = (i == 0) ? 0 : 1;
656

    
657
        if (padtop || padleft) {
658
            memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
659
                            padleft) >> shift));
660
        }
661

    
662
        if (padleft || padright) {
663
            optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
664
                (img->linesize[i] - (padright >> shift));
665

    
666
            for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
667
                memset(optr, color[i], (padleft + padright) >> shift);
668
                optr += img->linesize[i];
669
            }
670
        }
671

    
672
        if (padbottom || padright) {
673
            optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
674
            memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
675
        }
676
    }
677
}
678

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

    
691
    if (pts == AV_NOPTS_VALUE) {
692
        fprintf(stderr, "Subtitle packets must have a pts\n");
693
        return;
694
    }
695

    
696
    enc = ost->st->codec;
697

    
698
    if (!subtitle_out) {
699
        subtitle_out = av_malloc(subtitle_out_max_size);
700
    }
701

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

    
710
    for(i = 0; i < nb; i++) {
711
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
712
                                                    subtitle_out_max_size, sub);
713

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

    
731
static int bit_buffer_size= 1024*256;
732
static uint8_t *bit_buffer= NULL;
733

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

    
747
    avcodec_get_frame_defaults(&picture_format_temp);
748
    avcodec_get_frame_defaults(&picture_crop_temp);
749

    
750
    enc = ost->st->codec;
751
    dec = ist->st->codec;
752

    
753
    /* by default, we output a single frame */
754
    nb_frames = 1;
755

    
756
    *frame_size = 0;
757

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

    
779
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
780
    if (nb_frames <= 0)
781
        return;
782

    
783
    /* convert pixel format if needed */
784
    target_pixfmt = ost->video_resample || ost->video_pad
785
        ? PIX_FMT_YUV420P : enc->pix_fmt;
786
    if (dec->pix_fmt != target_pixfmt) {
787
        int size;
788

    
789
        /* create temporary picture */
790
        size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
791
        buf = av_malloc(size);
792
        if (!buf)
793
            return;
794
        formatted_picture = &picture_format_temp;
795
        avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
796

    
797
        if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
798
                        (AVPicture *)in_picture, dec->pix_fmt,
799
                        dec->width, dec->height) < 0) {
800

    
801
            if (verbose >= 0)
802
                fprintf(stderr, "pixel format conversion not handled\n");
803

    
804
            goto the_end;
805
        }
806
    } else {
807
        formatted_picture = in_picture;
808
    }
809

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

    
817
        if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
818
            fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
819
                    ost->padtop, ost->padbottom, ost->padleft, ost->padright,
820
                    padcolor);
821
        }
822

    
823
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
824
            int size;
825

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

    
835
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
836
                            (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
837
                            enc->width, enc->height) < 0) {
838

    
839
                if (verbose >= 0)
840
                    fprintf(stderr, "pixel format conversion not handled\n");
841

    
842
                goto the_end;
843
            }
844
        }
845
    } else if (ost->video_crop) {
846
        picture_crop_temp.data[0] = formatted_picture->data[0] +
847
                (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
848

    
849
        picture_crop_temp.data[1] = formatted_picture->data[1] +
850
                ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
851
                (ost->leftBand >> 1);
852

    
853
        picture_crop_temp.data[2] = formatted_picture->data[2] +
854
                ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
855
                (ost->leftBand >> 1);
856

    
857
        picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
858
        picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
859
        picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
860
        final_picture = &picture_crop_temp;
861
    } else if (ost->video_pad) {
862
        final_picture = &ost->pict_tmp;
863

    
864
        for (i = 0; i < 3; i++) {
865
            uint8_t *optr, *iptr;
866
            int shift = (i == 0) ? 0 : 1;
867
            int y, yheight;
868

    
869
            /* set offset to start writing image into */
870
            optr = final_picture->data[i] + (((final_picture->linesize[i] *
871
                            ost->padtop) + ost->padleft) >> shift);
872
            iptr = formatted_picture->data[i];
873

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

    
883
        fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
884
                ost->padtop, ost->padbottom, ost->padleft, ost->padright,
885
                padcolor);
886

    
887
        if (enc->pix_fmt != PIX_FMT_YUV420P) {
888
            int size;
889

    
890
            av_free(buf);
891
            /* create temporary picture */
892
            size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
893
            buf = av_malloc(size);
894
            if (!buf)
895
                return;
896
            final_picture = &picture_format_temp;
897
            avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
898

    
899
            if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
900
                        (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
901
                        enc->width, enc->height) < 0) {
902

    
903
                if (verbose >= 0)
904
                    fprintf(stderr, "pixel format conversion not handled\n");
905

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

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

    
931
            av_interleaved_write_frame(s, &pkt);
932
            enc->coded_frame = old_frame;
933
        } else {
934
            AVFrame big_picture;
935

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

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

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

    
993
static double psnr(double d){
994
    if(d==0) return INFINITY;
995
    return -10.0*log(d)/log(10.0);
996
}
997

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

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

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

    
1031
        fprintf(fvstats,"f_size= %6d ", frame_size);
1032
        /* compute pts value */
1033
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1034
        if (ti1 < 0.01)
1035
            ti1 = 0.01;
1036

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

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

    
1059
    if (!is_last_report) {
1060
        int64_t cur_time;
1061
        /* display the report every 0.5 seconds */
1062
        cur_time = av_gettime();
1063
        if (last_time == -1) {
1064
            last_time = cur_time;
1065
            return;
1066
        }
1067
        if ((cur_time - last_time) < 500000)
1068
            return;
1069
        last_time = cur_time;
1070
    }
1071

    
1072

    
1073
    oc = output_files[0];
1074

    
1075
    total_size = url_ftell(&oc->pb);
1076

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

    
1133
    if (verbose || is_last_report) {
1134
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1135

    
1136
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1137
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1138
            (double)total_size / 1024, ti1, bitrate);
1139

    
1140
        if (verbose > 1)
1141
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1142
                  nb_frames_dup, nb_frames_drop);
1143

    
1144
        if (verbose >= 0)
1145
            fprintf(stderr, "%s    \r", buf);
1146

    
1147
        fflush(stderr);
1148
    }
1149

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

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

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

    
1188
    if (pkt == NULL) {
1189
        /* EOF handling */
1190
        ptr = NULL;
1191
        len = 0;
1192
        goto handle_eof;
1193
    }
1194

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

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

    
1281
            buffer_to_free = NULL;
1282
            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1283
                pre_process_video_frame(ist, (AVPicture *)&picture,
1284
                                        &buffer_to_free);
1285
            }
1286

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

    
1301
            /* frame rate emulation */
1302
            if (ist->st->codec->rate_emu) {
1303
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1304
                int64_t now = av_gettime() - ist->start;
1305
                if (pts > now)
1306
                    usleep(pts - now);
1307

    
1308
                ist->frame++;
1309
            }
1310

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

    
1330
                    ost = ost_table[i];
1331
                    if (ost->source_index == ist_index) {
1332
                        os = output_files[ost->file_index];
1333

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

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

    
1366
                            /* no reencoding needed : output the packet directly */
1367
                            /* force the input stream PTS */
1368

    
1369
                            avcodec_get_frame_defaults(&avframe);
1370
                            ost->st->codec->coded_frame= &avframe;
1371
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1372

    
1373
                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1374
                                audio_size += data_size;
1375
                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1376
                                video_size += data_size;
1377
                                ost->sync_opts++;
1378
                            }
1379

    
1380
                            opkt.stream_index= ost->index;
1381
                            if(pkt->pts != AV_NOPTS_VALUE)
1382
                                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);
1383
                            else
1384
                                opkt.pts= AV_NOPTS_VALUE;
1385

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

    
1422
        for(i=0;i<nb_ostreams;i++) {
1423
            ost = ost_table[i];
1424
            if (ost->source_index == ist_index) {
1425
                AVCodecContext *enc= ost->st->codec;
1426
                os = output_files[ost->file_index];
1427

    
1428
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1429
                    continue;
1430
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1431
                    continue;
1432

    
1433
                if (ost->encoding_needed) {
1434
                    for(;;) {
1435
                        AVPacket pkt;
1436
                        av_init_packet(&pkt);
1437
                        pkt.stream_index= ost->index;
1438

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

    
1458
                        if(ret<=0)
1459
                            break;
1460
                        pkt.data= bit_buffer;
1461
                        pkt.size= ret;
1462
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1463
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1464
                        av_interleaved_write_frame(os, &pkt);
1465
                    }
1466
                }
1467
            }
1468
        }
1469
    }
1470

    
1471
    return 0;
1472
 fail_decode:
1473
    return -1;
1474
}
1475

    
1476

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

    
1495
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1496
    if (!file_table)
1497
        goto fail;
1498

    
1499
    /* input stream init */
1500
    j = 0;
1501
    for(i=0;i<nb_input_files;i++) {
1502
        is = input_files[i];
1503
        file_table[i].ist_index = j;
1504
        file_table[i].nb_streams = is->nb_streams;
1505
        j += is->nb_streams;
1506
    }
1507
    nb_istreams = j;
1508

    
1509
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1510
    if (!ist_table)
1511
        goto fail;
1512

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

    
1530
            if (ist->st->codec->rate_emu) {
1531
                ist->start = av_gettime();
1532
                ist->frame = 0;
1533
            }
1534
        }
1535
    }
1536

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

    
1548
    /* Sanity check the mapping args -- do the input files & streams exist? */
1549
    for(i=0;i<nb_stream_maps;i++) {
1550
        int fi = stream_maps[i].file_index;
1551
        int si = stream_maps[i].stream_index;
1552

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

    
1567
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1568
    if (!ost_table)
1569
        goto fail;
1570
    for(i=0;i<nb_ostreams;i++) {
1571
        ost = av_mallocz(sizeof(AVOutputStream));
1572
        if (!ost)
1573
            goto fail;
1574
        ost_table[i] = ost;
1575
    }
1576

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

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

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

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

    
1635
    /* for each output stream, we compute the right encoding parameters */
1636
    for(i=0;i<nb_ostreams;i++) {
1637
        ost = ost_table[i];
1638
        ist = ist_table[ost->source_index];
1639

    
1640
        codec = ost->st->codec;
1641
        icodec = ist->st->codec;
1642

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

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

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

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

    
1764
                    ost->padtop = frame_padtop;
1765
                    ost->padleft = frame_padleft;
1766
                    ost->padbottom = frame_padbottom;
1767
                    ost->padright = frame_padright;
1768

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

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

    
1827
    if (!bit_buffer)
1828
        bit_buffer = av_malloc(bit_buffer_size);
1829
    if (!bit_buffer)
1830
        goto fail;
1831

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

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

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

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

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

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

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

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

    
1933
        out_file = output_files[out_file_index];
1934
        in_file = input_files[in_file_index];
1935

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

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

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

    
1964
    stream_no_data = 0;
1965
    key = -1;
1966

    
1967
    for(; received_sigterm == 0;) {
1968
        int file_index, ist_index;
1969
        AVPacket pkt;
1970
        double ipts_min;
1971
        double opts_min;
1972

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

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

    
2019
        /* finish if recording time exhausted */
2020
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2021
            break;
2022

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

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

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

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

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

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

    
2073
            av_free_packet(&pkt);
2074
            goto redo;
2075
        }
2076

    
2077
    discard_packet:
2078
        av_free_packet(&pkt);
2079

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

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

    
2092
    term_exit();
2093

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

    
2100
    /* dump report by using the first video and audio streams */
2101
    print_report(output_files, ost_table, nb_ostreams, 1);
2102

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

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

    
2120
    /* finished ! */
2121

    
2122
    ret = 0;
2123
 fail1:
2124
    av_freep(&bit_buffer);
2125
    av_free(file_table);
2126

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

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

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

    
2182
static void opt_image_format(const char *arg)
2183
{
2184
    AVImageFormat *f;
2185

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

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

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

    
2214
static void opt_video_bitrate(const char *arg)
2215
{
2216
    video_bit_rate = atoi(arg) * 1000;
2217
}
2218

    
2219
static void opt_video_bitrate_tolerance(const char *arg)
2220
{
2221
    video_bit_rate_tolerance = atoi(arg) * 1000;
2222
}
2223

    
2224
static void opt_video_bitrate_max(const char *arg)
2225
{
2226
    video_rc_max_rate = atoi(arg) * 1000;
2227
}
2228

    
2229
static void opt_video_bitrate_min(const char *arg)
2230
{
2231
    video_rc_min_rate = atoi(arg) * 1000;
2232
}
2233

    
2234
static void opt_video_buffer_size(const char *arg)
2235
{
2236
    video_rc_buffer_size = atoi(arg) * 8*1024;
2237
}
2238

    
2239
static void opt_video_rc_eq(char *arg)
2240
{
2241
    video_rc_eq = arg;
2242
}
2243

    
2244
static void opt_video_rc_override_string(char *arg)
2245
{
2246
    video_rc_override_string = arg;
2247
}
2248

    
2249

    
2250
static void opt_workaround_bugs(const char *arg)
2251
{
2252
    workaround_bugs = atoi(arg);
2253
}
2254

    
2255
static void opt_me_threshold(const char *arg)
2256
{
2257
    me_threshold = atoi(arg);
2258
}
2259

    
2260
static void opt_mb_threshold(const char *arg)
2261
{
2262
    mb_threshold = atoi(arg);
2263
}
2264

    
2265
static void opt_verbose(const char *arg)
2266
{
2267
    verbose = atoi(arg);
2268
    av_log_set_level(atoi(arg));
2269
}
2270

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

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

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

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

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

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

    
2363

    
2364
#define SCALEBITS 10
2365
#define ONE_HALF  (1 << (SCALEBITS - 1))
2366
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2367

    
2368
#define RGB_TO_Y(r, g, b) \
2369
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2370
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2371

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

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

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

    
2386
    r = (rgb >> 16);
2387
    g = ((rgb >> 8) & 255);
2388
    b = (rgb & 255);
2389

    
2390
    padcolor[0] = RGB_TO_Y(r,g,b);
2391
    padcolor[1] = RGB_TO_U(r,g,b,0);
2392
    padcolor[2] = RGB_TO_V(r,g,b,0);
2393
}
2394

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

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

    
2421

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

    
2435

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

    
2449

    
2450
static void opt_frame_pix_fmt(const char *arg)
2451
{
2452
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2453
}
2454

    
2455
static void opt_frame_aspect_ratio(const char *arg)
2456
{
2457
    int x = 0, y = 0;
2458
    double ar = 0;
2459
    const char *p;
2460

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

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

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

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

    
2495
static void opt_pre_me(const char *arg)
2496
{
2497
    pre_me = atoi(arg);
2498
}
2499

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

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

    
2520
static void opt_lmax(const char *arg)
2521
{
2522
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2523
}
2524

    
2525
static void opt_lmin(const char *arg)
2526
{
2527
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2528
}
2529

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

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

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

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

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

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

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

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

    
2611
static void opt_ibias(const char *arg)
2612
{
2613
    video_intra_quant_bias = atoi(arg);
2614
}
2615
static void opt_pbias(const char *arg)
2616
{
2617
    video_inter_quant_bias = atoi(arg);
2618
}
2619

    
2620
static void opt_packet_size(const char *arg)
2621
{
2622
    packet_size= atoi(arg);
2623
}
2624

    
2625
static void opt_error_rate(const char *arg)
2626
{
2627
    error_rate= atoi(arg);
2628
}
2629

    
2630
static void opt_strict(const char *arg)
2631
{
2632
    strict= atoi(arg);
2633
}
2634

    
2635
static void opt_top_field_first(const char *arg)
2636
{
2637
    top_field_first= atoi(arg);
2638
}
2639

    
2640
static void opt_sc_threshold(const char *arg)
2641
{
2642
    sc_threshold= atoi(arg);
2643
}
2644

    
2645
static void opt_me_range(const char *arg)
2646
{
2647
    me_range = atoi(arg);
2648
}
2649

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

    
2659
static void opt_audio_bitrate(const char *arg)
2660
{
2661
    audio_bit_rate = atoi(arg) * 1000;
2662
}
2663

    
2664
static void opt_audio_rate(const char *arg)
2665
{
2666
    audio_sample_rate = atoi(arg);
2667
}
2668

    
2669
static void opt_audio_channels(const char *arg)
2670
{
2671
    audio_channels = atoi(arg);
2672
}
2673

    
2674
static void opt_video_device(const char *arg)
2675
{
2676
    video_device = av_strdup(arg);
2677
}
2678

    
2679
static void opt_grab_device(const char *arg)
2680
{
2681
    grab_device = av_strdup(arg);
2682
}
2683

    
2684
static void opt_video_channel(const char *arg)
2685
{
2686
    video_channel = strtol(arg, NULL, 0);
2687
}
2688

    
2689
static void opt_video_standard(const char *arg)
2690
{
2691
    video_standard = av_strdup(arg);
2692
}
2693

    
2694
static void opt_audio_device(const char *arg)
2695
{
2696
    audio_device = av_strdup(arg);
2697
}
2698

    
2699
static void opt_codec(int *pstream_copy, int *pcodec_id,
2700
                      int codec_type, const char *arg)
2701
{
2702
    AVCodec *p;
2703

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

    
2722
static void opt_audio_codec(const char *arg)
2723
{
2724
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2725
}
2726

    
2727
static void opt_audio_tag(const char *arg)
2728
{
2729
    char *tail;
2730
    audio_codec_tag= strtol(arg, &tail, 0);
2731

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

    
2736
static void opt_video_tag(const char *arg)
2737
{
2738
    char *tail;
2739
    video_codec_tag= strtol(arg, &tail, 0);
2740

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

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

    
2752
    using_vhook = 1;
2753

    
2754
    argv[0] = strtok(args, " ");
2755
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2756
    }
2757

    
2758
    i = frame_hook_add(argc, argv);
2759

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

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

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

    
2795
static void opt_video_codec(const char *arg)
2796
{
2797
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2798
}
2799

    
2800
static void opt_subtitle_codec(const char *arg)
2801
{
2802
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2803
}
2804

    
2805
static void opt_map(const char *arg)
2806
{
2807
    AVStreamMap *m;
2808
    const char *p;
2809

    
2810
    p = arg;
2811
    m = &stream_maps[nb_stream_maps++];
2812

    
2813
    m->file_index = strtol(arg, (char **)&p, 0);
2814
    if (*p)
2815
        p++;
2816

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

    
2830
static void opt_map_meta_data(const char *arg)
2831
{
2832
    AVMetaDataMap *m;
2833
    const char *p;
2834

    
2835
    p = arg;
2836
    m = &meta_data_maps[nb_meta_data_maps++];
2837

    
2838
    m->out_file = strtol(arg, (char **)&p, 0);
2839
    if (*p)
2840
        p++;
2841

    
2842
    m->in_file = strtol(p, (char **)&p, 0);
2843
}
2844

    
2845
static void opt_recording_time(const char *arg)
2846
{
2847
    recording_time = parse_date(arg, 1);
2848
}
2849

    
2850
static void opt_start_time(const char *arg)
2851
{
2852
    start_time = parse_date(arg, 1);
2853
}
2854

    
2855
static void opt_rec_timestamp(const char *arg)
2856
{
2857
    rec_timestamp = parse_date(arg, 0) / 1000000;
2858
}
2859

    
2860
static void opt_input_ts_offset(const char *arg)
2861
{
2862
    input_ts_offset = parse_date(arg, 1);
2863
}
2864

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

    
2872
    if (!strcmp(filename, "-"))
2873
        filename = "pipe:";
2874

    
2875
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2876
                   !strcmp( filename, "/dev/stdin" );
2877

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

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

    
2903
    if(genpts)
2904
        ic->flags|= AVFMT_FLAG_GENPTS;
2905

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

    
2914
    timestamp = start_time;
2915
    /* add the stream start time */
2916
    if (ic->start_time != AV_NOPTS_VALUE)
2917
        timestamp += ic->start_time;
2918

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

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

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

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

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

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

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

    
3006
    nb_input_files++;
3007
    file_iformat = NULL;
3008
    file_oformat = NULL;
3009
    image_format = NULL;
3010

    
3011
    grab_device = NULL;
3012
    video_channel = 0;
3013

    
3014
    rate_emu = 0;
3015
}
3016

    
3017
static void opt_grab(const char *arg)
3018
{
3019
    file_iformat = av_find_input_format(arg);
3020
    opt_input_file("");
3021
}
3022

    
3023
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3024
{
3025
    int has_video, has_audio, i, j;
3026
    AVFormatContext *ic;
3027

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

    
3054
static void new_video_stream(AVFormatContext *oc)
3055
{
3056
    AVStream *st;
3057
    AVCodecContext *video_enc;
3058
    int codec_id;
3059

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

    
3070
    video_enc = st->codec;
3071

    
3072
    if(video_codec_tag)
3073
        video_enc->codec_tag= video_codec_tag;
3074

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

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

    
3093
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3094
        if (video_codec_id != CODEC_ID_NONE)
3095
            codec_id = video_codec_id;
3096

    
3097
        video_enc->codec_id = codec_id;
3098
        codec = avcodec_find_encoder(codec_id);
3099

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

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

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

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

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

    
3153
        if(intra_matrix)
3154
            video_enc->intra_matrix = intra_matrix;
3155
        if(inter_matrix)
3156
            video_enc->inter_matrix = inter_matrix;
3157

    
3158
        video_enc->pre_me = pre_me;
3159

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

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

    
3227
        if(packet_size){
3228
            video_enc->rtp_mode= 1;
3229
            video_enc->rtp_payload_size= packet_size;
3230
        }
3231

    
3232
        if (do_psnr)
3233
            video_enc->flags|= CODEC_FLAG_PSNR;
3234

    
3235
        video_enc->me_method = me_method;
3236

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

    
3247
    /* reset some key parameters */
3248
    video_disable = 0;
3249
    video_codec_id = CODEC_ID_NONE;
3250
    video_stream_copy = 0;
3251
}
3252

    
3253
static void new_audio_stream(AVFormatContext *oc)
3254
{
3255
    AVStream *st;
3256
    AVCodecContext *audio_enc;
3257
    int codec_id, i;
3258

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

    
3269
    audio_enc = st->codec;
3270
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3271

    
3272
    if(audio_codec_tag)
3273
        audio_enc->codec_tag= audio_codec_tag;
3274

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

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

    
3292
        if (audio_codec_id != CODEC_ID_NONE)
3293
            codec_id = audio_codec_id;
3294
        audio_enc->codec_id = codec_id;
3295

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

    
3319
    /* reset some key parameters */
3320
    audio_disable = 0;
3321
    audio_codec_id = CODEC_ID_NONE;
3322
    audio_stream_copy = 0;
3323
}
3324

    
3325
static void opt_new_subtitle_stream(void)
3326
{
3327
    AVFormatContext *oc;
3328
    AVStream *st;
3329
    AVCodecContext *subtitle_enc;
3330
    int i;
3331

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

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

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

    
3358
    if (subtitle_language) {
3359
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3360
        av_free(subtitle_language);
3361
        subtitle_language = NULL;
3362
    }
3363

    
3364
    subtitle_codec_id = CODEC_ID_NONE;
3365
    subtitle_stream_copy = 0;
3366
}
3367

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

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

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

    
3396
    if (!strcmp(filename, "-"))
3397
        filename = "pipe:";
3398

    
3399
    oc = av_alloc_format_context();
3400

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

    
3410
    oc->oformat = file_oformat;
3411
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3412

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

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

    
3435
        /* manual disable */
3436
        if (audio_disable) {
3437
            use_audio = 0;
3438
        }
3439
        if (video_disable) {
3440
            use_video = 0;
3441
        }
3442

    
3443
        if (use_video) {
3444
            new_video_stream(oc);
3445
        }
3446

    
3447
        if (use_audio) {
3448
            new_audio_stream(oc);
3449
        }
3450

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

    
3456
        oc->timestamp = rec_timestamp;
3457

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

    
3468
    output_files[nb_output_files++] = oc;
3469

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

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

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

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

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

    
3517
    oc->packet_size= mux_packet_size;
3518
    oc->mux_rate= mux_rate;
3519
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3520
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3521
    oc->loop_output = loop_output;
3522

    
3523
    /* reset some options */
3524
    file_oformat = NULL;
3525
    file_iformat = NULL;
3526
    image_format = NULL;
3527
}
3528

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

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

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

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

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

    
3599
        if (verbose >= 0)
3600
            dump_format(ic, nb_input_files, "", 0);
3601

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

    
3614
        if (verbose >= 0)
3615
            dump_format(ic, nb_input_files, "", 0);
3616

    
3617
        nb_input_files++;
3618
    }
3619
}
3620

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

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

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

    
3648
extern int ffm_nopts;
3649

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3877
    if(!strcmp(arg, "vcd")) {
3878

    
3879
        opt_video_codec("mpeg1video");
3880
        opt_audio_codec("mp2");
3881
        opt_format("vcd");
3882

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

    
3887
        video_bit_rate = 1150000;
3888
        video_rc_max_rate = 1150000;
3889
        video_rc_min_rate = 1150000;
3890
        video_rc_buffer_size = 40*1024*8;
3891

    
3892
        audio_bit_rate = 224000;
3893
        audio_sample_rate = 44100;
3894

    
3895
        mux_packet_size= 2324;
3896
        mux_rate= 2352 * 75 * 8;
3897

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

    
3906
        opt_video_codec("mpeg2video");
3907
        opt_audio_codec("mp2");
3908
        opt_format("svcd");
3909

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

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

    
3920

    
3921
        audio_bit_rate = 224000;
3922
        audio_sample_rate = 44100;
3923

    
3924
        mux_packet_size= 2324;
3925

    
3926
    } else if(!strcmp(arg, "dvd")) {
3927

    
3928
        opt_video_codec("mpeg2video");
3929
        opt_audio_codec("ac3");
3930
        opt_format("dvd");
3931

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

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

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

    
3944
        audio_bit_rate = 448000;
3945
        audio_sample_rate = 48000;
3946

    
3947
    } else if(!strcmp(arg, "dv")) {
3948

    
3949
        opt_format("dv");
3950

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

    
3954
        audio_sample_rate = 48000;
3955
        audio_channels = 2;
3956

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

    
3963
static void show_version(void)
3964
{
3965
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3966
           "libavcodec  %d\n"
3967
           "libavformat %d\n",
3968
           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", 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

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

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

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

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

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

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

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

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

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

    
4232
    exit(1);
4233
}
4234

    
4235
void parse_arg_file(const char *filename)
4236
{
4237
    opt_output_file(filename);
4238
}
4239

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

    
4245
    av_register_all();
4246

    
4247
    avctx_opts= avcodec_alloc_context();
4248

    
4249
    if (argc <= 1)
4250
        show_help();
4251
    else
4252
        show_banner();
4253

    
4254
    /* parse options */
4255
    parse_options(argc, argv, options);
4256

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

    
4263
    if (nb_input_files == 0) {
4264
        input_sync = 1;
4265
        prepare_grab();
4266
    }
4267

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

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

    
4290
    av_free_static();
4291

    
4292
    if(intra_matrix)
4293
        av_free(intra_matrix);
4294
    if(inter_matrix)
4295
        av_free(inter_matrix);
4296

    
4297
#ifdef POWERPC_PERFORMANCE_REPORT
4298
    extern void powerpc_display_perf_report(void);
4299
    powerpc_display_perf_report();
4300
#endif /* POWERPC_PERFORMANCE_REPORT */
4301

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