Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 63d5075c

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 "swscale.h"
23
#include "framehook.h"
24
#include "dsputil.h"
25
#include "opt.h"
26

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

    
44
#include "version.h"
45
#include "cmdutils.h"
46

    
47
#undef NDEBUG
48
#include <assert.h>
49

    
50
#if !defined(INFINITY) && defined(HUGE_VAL)
51
#define INFINITY HUGE_VAL
52
#endif
53

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

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

    
68
extern const OptionDef options[];
69

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

    
74
#define MAX_FILES 20
75

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

    
80
static AVFormatContext *output_files[MAX_FILES];
81
static int nb_output_files = 0;
82

    
83
static AVStreamMap stream_maps[MAX_FILES];
84
static int nb_stream_maps;
85

    
86
static AVMetaDataMap meta_data_maps[MAX_FILES];
87
static int nb_meta_data_maps;
88

    
89
static AVInputFormat *file_iformat;
90
static AVOutputFormat *file_oformat;
91
static AVImageFormat *image_format;
92
static int frame_width  = 0;
93
static int frame_height = 0;
94
static float frame_aspect_ratio = 0;
95
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
96
static int frame_padtop  = 0;
97
static int frame_padbottom = 0;
98
static int frame_padleft  = 0;
99
static int frame_padright = 0;
100
static int padcolor[3] = {16,128,128}; /* default to black */
101
static int frame_topBand  = 0;
102
static int frame_bottomBand = 0;
103
static int frame_leftBand  = 0;
104
static int frame_rightBand = 0;
105
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
106
static int frame_rate = 25;
107
static int frame_rate_base = 1;
108
static int video_bit_rate = 200*1000;
109
static int video_bit_rate_tolerance = 4000*1000;
110
static float video_qscale = 0;
111
static int video_qmin = 2;
112
static int video_qmax = 31;
113
static int video_lmin = 2*FF_QP2LAMBDA;
114
static int video_lmax = 31*FF_QP2LAMBDA;
115
static int video_mb_lmin = 2*FF_QP2LAMBDA;
116
static int video_mb_lmax = 31*FF_QP2LAMBDA;
117
static int video_qdiff = 3;
118
static float video_qblur = 0.5;
119
static float video_qsquish = 0.0;
120
static float video_qcomp = 0.5;
121
static uint16_t *intra_matrix = NULL;
122
static uint16_t *inter_matrix = NULL;
123
#if 0 //experimental, (can be removed)
124
static float video_rc_qsquish=1.0;
125
static float video_rc_qmod_amp=0;
126
static int video_rc_qmod_freq=0;
127
#endif
128
static char *video_rc_override_string=NULL;
129
static char *video_rc_eq="tex^qComp";
130
static int video_rc_buffer_size=0;
131
static float video_rc_buffer_aggressivity=1.0;
132
static int video_rc_max_rate=0;
133
static int video_rc_min_rate=0;
134
static float video_rc_initial_cplx=0;
135
static float video_b_qfactor = 1.25;
136
static float video_b_qoffset = 1.25;
137
static float video_i_qfactor = -0.8;
138
static float video_i_qoffset = 0.0;
139
static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
140
static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
141
static int me_method = ME_EPZS;
142
static int video_disable = 0;
143
static int video_discard = 0;
144
static int video_codec_id = CODEC_ID_NONE;
145
static int video_codec_tag = 0;
146
static int same_quality = 0;
147
static int b_frames = 0;
148
static int pre_me = 0;
149
static int do_deinterlace = 0;
150
static int workaround_bugs = FF_BUG_AUTODETECT;
151
static int packet_size = 0;
152
static int error_rate = 0;
153
static int strict = 0;
154
static int top_field_first = -1;
155
static int sc_threshold = 0;
156
static int me_threshold = 0;
157
static int mb_threshold = 0;
158
static int intra_dc_precision = 8;
159
static int me_penalty_compensation= 256;
160
static int frame_skip_threshold= 0;
161
static int frame_skip_factor= 0;
162
static int frame_skip_exp= 0;
163
static int loop_input = 0;
164
static int loop_output = AVFMT_NOOUTPUTLOOP;
165
static int qp_hist = 0;
166

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

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

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

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

    
213
static int rate_emu = 0;
214

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

    
229
static const char *audio_grab_format = "audio_device";
230
static char *audio_device = NULL;
231
static int audio_volume = 256;
232

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

    
247
static int pgmyuv_compatibility_hack=0;
248
static int dts_delta_threshold = 10;
249

    
250
static int sws_flags = SWS_BICUBIC;
251

    
252
const char **opt_names=NULL;
253
int opt_name_count=0;
254
AVCodecContext *avctx_opts;
255
AVFormatContext *avformat_opts;
256

    
257
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
258
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
259
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
260

    
261
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
262

    
263
struct AVInputStream;
264

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

    
283
    int video_crop;
284
    int topBand;             /* cropping area sizes */
285
    int leftBand;
286

    
287
    int video_pad;
288
    int padtop;              /* padding area sizes */
289
    int padbottom;
290
    int padleft;
291
    int padright;
292

    
293
    /* audio only */
294
    int audio_resample;
295
    ReSampleContext *resample; /* for audio resampling */
296
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
297
    FILE *logfile;
298
} AVOutputStream;
299

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

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

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

    
325
#ifndef __MINGW32__
326

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

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

    
335
static volatile sig_atomic_t received_sigterm = 0;
336

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

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

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

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

    
360
    tcsetattr (0, TCSANOW, &tty);
361

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

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

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

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

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

    
404
#else
405

    
406
static volatile int received_sigterm = 0;
407

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

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

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

    
422
#endif
423

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

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

    
437
        // FIXME: a more elegant solution is needed
438
        st = av_mallocz(sizeof(AVStream));
439
        memcpy(st, ic->streams[i], sizeof(AVStream));
440
        st->codec = avcodec_alloc_context();
441
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
442
        s->streams[i] = st;
443
    }
444

    
445
    av_close_input_file(ic);
446
    return 0;
447
}
448

    
449
static double
450
get_sync_ipts(const AVOutputStream *ost)
451
{
452
    const AVInputStream *ist = ost->sync_ist;
453
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
454
}
455

    
456
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
457
    while(bsfc){
458
        AVPacket new_pkt= *pkt;
459
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
460
                                          &new_pkt.data, &new_pkt.size,
461
                                          pkt->data, pkt->size,
462
                                          pkt->flags & PKT_FLAG_KEY);
463
        if(a){
464
            av_free_packet(pkt);
465
            new_pkt.destruct= av_destruct_packet;
466
        }
467
        *pkt= new_pkt;
468

    
469
        bsfc= bsfc->next;
470
    }
471

    
472
    av_interleaved_write_frame(s, pkt);
473
}
474

    
475
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
476

    
477
static void do_audio_out(AVFormatContext *s,
478
                         AVOutputStream *ost,
479
                         AVInputStream *ist,
480
                         unsigned char *buf, int size)
481
{
482
    uint8_t *buftmp;
483
    static uint8_t *audio_buf = NULL;
484
    static uint8_t *audio_out = NULL;
485
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
486

    
487
    int size_out, frame_bytes, ret;
488
    AVCodecContext *enc= ost->st->codec;
489

    
490
    /* SC: dynamic allocation of buffers */
491
    if (!audio_buf)
492
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
493
    if (!audio_out)
494
        audio_out = av_malloc(audio_out_size);
495
    if (!audio_buf || !audio_out)
496
        return;               /* Should signal an error ! */
497

    
498
    if(audio_sync_method){
499
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
500
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
501
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
502
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
503

    
504
        //FIXME resample delay
505
        if(fabs(delta) > 50){
506
            if(ist->is_start){
507
                if(byte_delta < 0){
508
                    byte_delta= FFMAX(byte_delta, -size);
509
                    size += byte_delta;
510
                    buf  -= byte_delta;
511
                    if(verbose > 2)
512
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
513
                    if(!size)
514
                        return;
515
                    ist->is_start=0;
516
                }else{
517
                    static uint8_t *input_tmp= NULL;
518
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
519

    
520
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
521
                        ist->is_start=0;
522
                    else
523
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
524

    
525
                    memset(input_tmp, 0, byte_delta);
526
                    memcpy(input_tmp + byte_delta, buf, size);
527
                    buf= input_tmp;
528
                    size += byte_delta;
529
                    if(verbose > 2)
530
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
531
                }
532
            }else if(audio_sync_method>1){
533
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
534
                assert(ost->audio_resample);
535
                if(verbose > 2)
536
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
537
//                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));
538
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
539
            }
540
        }
541
    }else
542
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
543
                        - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
544

    
545
    if (ost->audio_resample) {
546
        buftmp = audio_buf;
547
        size_out = audio_resample(ost->resample,
548
                                  (short *)buftmp, (short *)buf,
549
                                  size / (ist->st->codec->channels * 2));
550
        size_out = size_out * enc->channels * 2;
551
    } else {
552
        buftmp = buf;
553
        size_out = size;
554
    }
555

    
556
    /* now encode as many frames as possible */
557
    if (enc->frame_size > 1) {
558
        /* output resampled raw samples */
559
        fifo_write(&ost->fifo, buftmp, size_out,
560
                   &ost->fifo.wptr);
561

    
562
        frame_bytes = enc->frame_size * 2 * enc->channels;
563

    
564
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
565
                     &ost->fifo.rptr) == 0) {
566
            AVPacket pkt;
567
            av_init_packet(&pkt);
568

    
569
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
570
                                       (short *)audio_buf);
571
            audio_size += ret;
572
            pkt.stream_index= ost->index;
573
            pkt.data= audio_out;
574
            pkt.size= ret;
575
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
576
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
577
            pkt.flags |= PKT_FLAG_KEY;
578
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
579

    
580
            ost->sync_opts += enc->frame_size;
581
        }
582
    } else {
583
        AVPacket pkt;
584
        av_init_packet(&pkt);
585

    
586
        ost->sync_opts += size_out / (2 * enc->channels);
587

    
588
        /* output a pcm frame */
589
        /* XXX: change encoding codec API to avoid this ? */
590
        switch(enc->codec->id) {
591
        case CODEC_ID_PCM_S32LE:
592
        case CODEC_ID_PCM_S32BE:
593
        case CODEC_ID_PCM_U32LE:
594
        case CODEC_ID_PCM_U32BE:
595
            size_out = size_out << 1;
596
            break;
597
        case CODEC_ID_PCM_S24LE:
598
        case CODEC_ID_PCM_S24BE:
599
        case CODEC_ID_PCM_U24LE:
600
        case CODEC_ID_PCM_U24BE:
601
        case CODEC_ID_PCM_S24DAUD:
602
            size_out = size_out / 2 * 3;
603
            break;
604
        case CODEC_ID_PCM_S16LE:
605
        case CODEC_ID_PCM_S16BE:
606
        case CODEC_ID_PCM_U16LE:
607
        case CODEC_ID_PCM_U16BE:
608
            break;
609
        default:
610
            size_out = size_out >> 1;
611
            break;
612
        }
613
        ret = avcodec_encode_audio(enc, audio_out, size_out,
614
                                   (short *)buftmp);
615
        audio_size += ret;
616
        pkt.stream_index= ost->index;
617
        pkt.data= audio_out;
618
        pkt.size= ret;
619
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
620
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
621
        pkt.flags |= PKT_FLAG_KEY;
622
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
623
    }
624
}
625

    
626
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
627
{
628
    AVCodecContext *dec;
629
    AVPicture *picture2;
630
    AVPicture picture_tmp;
631
    uint8_t *buf = 0;
632

    
633
    dec = ist->st->codec;
634

    
635
    /* deinterlace : must be done before any resize */
636
    if (do_deinterlace || using_vhook) {
637
        int size;
638

    
639
        /* create temporary picture */
640
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
641
        buf = av_malloc(size);
642
        if (!buf)
643
            return;
644

    
645
        picture2 = &picture_tmp;
646
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
647

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

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

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

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

    
673
static void do_subtitle_out(AVFormatContext *s,
674
                            AVOutputStream *ost,
675
                            AVInputStream *ist,
676
                            AVSubtitle *sub,
677
                            int64_t pts)
678
{
679
    static uint8_t *subtitle_out = NULL;
680
    int subtitle_out_max_size = 65536;
681
    int subtitle_out_size, nb, i;
682
    AVCodecContext *enc;
683
    AVPacket pkt;
684

    
685
    if (pts == AV_NOPTS_VALUE) {
686
        fprintf(stderr, "Subtitle packets must have a pts\n");
687
        return;
688
    }
689

    
690
    enc = ost->st->codec;
691

    
692
    if (!subtitle_out) {
693
        subtitle_out = av_malloc(subtitle_out_max_size);
694
    }
695

    
696
    /* Note: DVB subtitle need one packet to draw them and one other
697
       packet to clear them */
698
    /* XXX: signal it in the codec context ? */
699
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
700
        nb = 2;
701
    else
702
        nb = 1;
703

    
704
    for(i = 0; i < nb; i++) {
705
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
706
                                                    subtitle_out_max_size, sub);
707

    
708
        av_init_packet(&pkt);
709
        pkt.stream_index = ost->index;
710
        pkt.data = subtitle_out;
711
        pkt.size = subtitle_out_size;
712
        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);
713
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
714
            /* XXX: the pts correction is handled here. Maybe handling
715
               it in the codec would be better */
716
            if (i == 0)
717
                pkt.pts += 90 * sub->start_display_time;
718
            else
719
                pkt.pts += 90 * sub->end_display_time;
720
        }
721
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
722
    }
723
}
724

    
725
static int bit_buffer_size= 1024*256;
726
static uint8_t *bit_buffer= NULL;
727

    
728
static void do_video_out(AVFormatContext *s,
729
                         AVOutputStream *ost,
730
                         AVInputStream *ist,
731
                         AVFrame *in_picture,
732
                         int *frame_size)
733
{
734
    int nb_frames, i, ret;
735
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
736
    AVFrame picture_crop_temp, picture_pad_temp;
737
    uint8_t *buf = NULL, *buf1 = NULL;
738
    AVCodecContext *enc, *dec;
739

    
740
    avcodec_get_frame_defaults(&picture_crop_temp);
741
    avcodec_get_frame_defaults(&picture_pad_temp);
742

    
743
    enc = ost->st->codec;
744
    dec = ist->st->codec;
745

    
746
    /* by default, we output a single frame */
747
    nb_frames = 1;
748

    
749
    *frame_size = 0;
750

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

    
772
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
773
    if (nb_frames <= 0)
774
        return;
775

    
776
    if (ost->video_crop) {
777
        if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
778
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
779
            goto the_end;
780
        }
781
        formatted_picture = &picture_crop_temp;
782
    } else {
783
        formatted_picture = in_picture;
784
    }
785

    
786
    final_picture = formatted_picture;
787
    padding_src = formatted_picture;
788
    resampling_dst = &ost->pict_tmp;
789
    if (ost->video_pad) {
790
        final_picture = &ost->pict_tmp;
791
        if (ost->video_resample) {
792
            if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
793
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
794
                goto the_end;
795
            }
796
            resampling_dst = &picture_pad_temp;
797
        }
798
    }
799

    
800
    if (ost->video_resample) {
801
        padding_src = NULL;
802
        final_picture = &ost->pict_tmp;
803
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
804
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
805
    }
806

    
807
    if (ost->video_pad) {
808
        img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
809
                enc->height, enc->width, enc->pix_fmt,
810
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
811
    }
812

    
813
    /* duplicates frame if needed */
814
    for(i=0;i<nb_frames;i++) {
815
        AVPacket pkt;
816
        av_init_packet(&pkt);
817
        pkt.stream_index= ost->index;
818

    
819
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
820
            /* raw pictures are written as AVPicture structure to
821
               avoid any copies. We support temorarily the older
822
               method. */
823
            AVFrame* old_frame = enc->coded_frame;
824
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
825
            pkt.data= (uint8_t *)final_picture;
826
            pkt.size=  sizeof(AVPicture);
827
            if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
828
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
829
            if(dec->coded_frame && dec->coded_frame->key_frame)
830
                pkt.flags |= PKT_FLAG_KEY;
831

    
832
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
833
            enc->coded_frame = old_frame;
834
        } else {
835
            AVFrame big_picture;
836

    
837
            big_picture= *final_picture;
838
            /* better than nothing: use input picture interlaced
839
               settings */
840
            big_picture.interlaced_frame = in_picture->interlaced_frame;
841
            if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
842
                if(top_field_first == -1)
843
                    big_picture.top_field_first = in_picture->top_field_first;
844
                else
845
                    big_picture.top_field_first = top_field_first;
846
            }
847

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

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

    
894
static double psnr(double d){
895
    if(d==0) return INFINITY;
896
    return -10.0*log(d)/log(10.0);
897
}
898

    
899
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
900
                           int frame_size)
901
{
902
    static FILE *fvstats=NULL;
903
    char filename[40];
904
    time_t today2;
905
    struct tm *today;
906
    AVCodecContext *enc;
907
    int frame_number;
908
    int64_t ti;
909
    double ti1, bitrate, avg_bitrate;
910

    
911
    if (!fvstats) {
912
        today2 = time(NULL);
913
        today = localtime(&today2);
914
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
915
                                               today->tm_min,
916
                                               today->tm_sec);
917
        fvstats = fopen(filename,"w");
918
        if (!fvstats) {
919
            perror("fopen");
920
            exit(1);
921
        }
922
    }
923

    
924
    ti = MAXINT64;
925
    enc = ost->st->codec;
926
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
927
        frame_number = ost->frame_number;
928
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
929
        if (enc->flags&CODEC_FLAG_PSNR)
930
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
931

    
932
        fprintf(fvstats,"f_size= %6d ", frame_size);
933
        /* compute pts value */
934
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
935
        if (ti1 < 0.01)
936
            ti1 = 0.01;
937

    
938
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
939
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
940
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
941
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
942
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
943
    }
944
}
945

    
946
static void print_report(AVFormatContext **output_files,
947
                         AVOutputStream **ost_table, int nb_ostreams,
948
                         int is_last_report)
949
{
950
    char buf[1024];
951
    AVOutputStream *ost;
952
    AVFormatContext *oc, *os;
953
    int64_t total_size;
954
    AVCodecContext *enc;
955
    int frame_number, vid, i;
956
    double bitrate, ti1, pts;
957
    static int64_t last_time = -1;
958
    static int qp_histogram[52];
959

    
960
    if (!is_last_report) {
961
        int64_t cur_time;
962
        /* display the report every 0.5 seconds */
963
        cur_time = av_gettime();
964
        if (last_time == -1) {
965
            last_time = cur_time;
966
            return;
967
        }
968
        if ((cur_time - last_time) < 500000)
969
            return;
970
        last_time = cur_time;
971
    }
972

    
973

    
974
    oc = output_files[0];
975

    
976
    total_size = url_ftell(&oc->pb);
977

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

    
1034
    if (verbose || is_last_report) {
1035
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1036

    
1037
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1038
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1039
            (double)total_size / 1024, ti1, bitrate);
1040

    
1041
        if (verbose > 1)
1042
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1043
                  nb_frames_dup, nb_frames_drop);
1044

    
1045
        if (verbose >= 0)
1046
            fprintf(stderr, "%s    \r", buf);
1047

    
1048
        fflush(stderr);
1049
    }
1050

    
1051
    if (is_last_report && verbose >= 0){
1052
        int64_t raw= audio_size + video_size + extra_size;
1053
        fprintf(stderr, "\n");
1054
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1055
                video_size/1024.0,
1056
                audio_size/1024.0,
1057
                extra_size/1024.0,
1058
                100.0*(total_size - raw)/raw
1059
        );
1060
    }
1061
}
1062

    
1063
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1064
static int output_packet(AVInputStream *ist, int ist_index,
1065
                         AVOutputStream **ost_table, int nb_ostreams,
1066
                         const AVPacket *pkt)
1067
{
1068
    AVFormatContext *os;
1069
    AVOutputStream *ost;
1070
    uint8_t *ptr;
1071
    int len, ret, i;
1072
    uint8_t *data_buf;
1073
    int data_size, got_picture;
1074
    AVFrame picture;
1075
    void *buffer_to_free;
1076
    static unsigned int samples_size= 0;
1077
    static short *samples= NULL;
1078
    AVSubtitle subtitle, *subtitle_to_free;
1079
    int got_subtitle;
1080

    
1081
    if(!pkt){
1082
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1083
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1084
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1085
    } else {
1086
//        assert(ist->pts == ist->next_pts);
1087
    }
1088

    
1089
    if (pkt == NULL) {
1090
        /* EOF handling */
1091
        ptr = NULL;
1092
        len = 0;
1093
        goto handle_eof;
1094
    }
1095

    
1096
    len = pkt->size;
1097
    ptr = pkt->data;
1098
    while (len > 0) {
1099
    handle_eof:
1100
        /* decode the packet if needed */
1101
        data_buf = NULL; /* fail safe */
1102
        data_size = 0;
1103
        subtitle_to_free = NULL;
1104
        if (ist->decoding_needed) {
1105
            switch(ist->st->codec->codec_type) {
1106
            case CODEC_TYPE_AUDIO:{
1107
                if(pkt)
1108
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1109
                    /* XXX: could avoid copy if PCM 16 bits with same
1110
                       endianness as CPU */
1111
                ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1112
                                           ptr, len);
1113
                if (ret < 0)
1114
                    goto fail_decode;
1115
                ptr += ret;
1116
                len -= ret;
1117
                /* Some bug in mpeg audio decoder gives */
1118
                /* data_size < 0, it seems they are overflows */
1119
                if (data_size <= 0) {
1120
                    /* no audio frame */
1121
                    continue;
1122
                }
1123
                data_buf = (uint8_t *)samples;
1124
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1125
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1126
                break;}
1127
            case CODEC_TYPE_VIDEO:
1128
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1129
                    /* XXX: allocate picture correctly */
1130
                    avcodec_get_frame_defaults(&picture);
1131

    
1132
                    ret = avcodec_decode_video(ist->st->codec,
1133
                                               &picture, &got_picture, ptr, len);
1134
                    ist->st->quality= picture.quality;
1135
                    if (ret < 0)
1136
                        goto fail_decode;
1137
                    if (!got_picture) {
1138
                        /* no picture yet */
1139
                        goto discard_packet;
1140
                    }
1141
                    if (ist->st->codec->time_base.num != 0) {
1142
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1143
                                          ist->st->codec->time_base.num) /
1144
                            ist->st->codec->time_base.den;
1145
                    }
1146
                    len = 0;
1147
                    break;
1148
            case CODEC_TYPE_SUBTITLE:
1149
                ret = avcodec_decode_subtitle(ist->st->codec,
1150
                                              &subtitle, &got_subtitle, ptr, len);
1151
                if (ret < 0)
1152
                    goto fail_decode;
1153
                if (!got_subtitle) {
1154
                    goto discard_packet;
1155
                }
1156
                subtitle_to_free = &subtitle;
1157
                len = 0;
1158
                break;
1159
            default:
1160
                goto fail_decode;
1161
            }
1162
        } else {
1163
                switch(ist->st->codec->codec_type) {
1164
                case CODEC_TYPE_AUDIO:
1165
                    ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1166
                        (ist->st->codec->sample_rate * ist->st->codec->channels);
1167
                    break;
1168
                case CODEC_TYPE_VIDEO:
1169
                    if (ist->st->codec->time_base.num != 0) {
1170
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1171
                                          ist->st->codec->time_base.num) /
1172
                            ist->st->codec->time_base.den;
1173
                    }
1174
                    break;
1175
                }
1176
                data_buf = ptr;
1177
                data_size = len;
1178
                ret = len;
1179
                len = 0;
1180
            }
1181

    
1182
            buffer_to_free = NULL;
1183
            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1184
                pre_process_video_frame(ist, (AVPicture *)&picture,
1185
                                        &buffer_to_free);
1186
            }
1187

    
1188
            // preprocess audio (volume)
1189
            if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1190
                if (audio_volume != 256) {
1191
                    short *volp;
1192
                    volp = samples;
1193
                    for(i=0;i<(data_size / sizeof(short));i++) {
1194
                        int v = ((*volp) * audio_volume + 128) >> 8;
1195
                        if (v < -32768) v = -32768;
1196
                        if (v >  32767) v = 32767;
1197
                        *volp++ = v;
1198
                    }
1199
                }
1200
            }
1201

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

    
1209
                ist->frame++;
1210
            }
1211

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

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

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

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

    
1267
                            /* no reencoding needed : output the packet directly */
1268
                            /* force the input stream PTS */
1269

    
1270
                            avcodec_get_frame_defaults(&avframe);
1271
                            ost->st->codec->coded_frame= &avframe;
1272
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1273

    
1274
                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1275
                                audio_size += data_size;
1276
                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1277
                                video_size += data_size;
1278
                                ost->sync_opts++;
1279
                            }
1280

    
1281
                            opkt.stream_index= ost->index;
1282
                            if(pkt->pts != AV_NOPTS_VALUE)
1283
                                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);
1284
                            else
1285
                                opkt.pts= AV_NOPTS_VALUE;
1286

    
1287
                            {
1288
                                int64_t dts;
1289
                                if (pkt->dts == AV_NOPTS_VALUE)
1290
                                    dts = ist->next_pts;
1291
                                else
1292
                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1293
                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1294
                            }
1295
                            opkt.flags= pkt->flags;
1296

    
1297
                            //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1298
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1299
                                opkt.destruct= av_destruct_packet;
1300

    
1301
                            write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1302
                            ost->st->codec->frame_number++;
1303
                            ost->frame_number++;
1304
                            av_free_packet(&opkt);
1305
                        }
1306
                    }
1307
                }
1308
            av_free(buffer_to_free);
1309
            /* XXX: allocate the subtitles in the codec ? */
1310
            if (subtitle_to_free) {
1311
                if (subtitle_to_free->rects != NULL) {
1312
                    for (i = 0; i < subtitle_to_free->num_rects; i++) {
1313
                        av_free(subtitle_to_free->rects[i].bitmap);
1314
                        av_free(subtitle_to_free->rects[i].rgba_palette);
1315
                    }
1316
                    av_freep(&subtitle_to_free->rects);
1317
                }
1318
                subtitle_to_free->num_rects = 0;
1319
                subtitle_to_free = NULL;
1320
            }
1321
        }
1322
 discard_packet:
1323
    if (pkt == NULL) {
1324
        /* EOF handling */
1325

    
1326
        for(i=0;i<nb_ostreams;i++) {
1327
            ost = ost_table[i];
1328
            if (ost->source_index == ist_index) {
1329
                AVCodecContext *enc= ost->st->codec;
1330
                os = output_files[ost->file_index];
1331

    
1332
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1333
                    continue;
1334
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1335
                    continue;
1336

    
1337
                if (ost->encoding_needed) {
1338
                    for(;;) {
1339
                        AVPacket pkt;
1340
                        int fifo_bytes;
1341
                        av_init_packet(&pkt);
1342
                        pkt.stream_index= ost->index;
1343

    
1344
                        switch(ost->st->codec->codec_type) {
1345
                        case CODEC_TYPE_AUDIO:
1346
                            fifo_bytes = fifo_size(&ost->fifo, NULL);
1347
                            ret = 0;
1348
                            /* encode any samples remaining in fifo */
1349
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1350
                                int fs_tmp = enc->frame_size;
1351
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1352
                                if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1353
                                        &ost->fifo.rptr) == 0) {
1354
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1355
                                }
1356
                                enc->frame_size = fs_tmp;
1357
                            }
1358
                            if(ret <= 0) {
1359
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1360
                            }
1361
                            audio_size += ret;
1362
                            pkt.flags |= PKT_FLAG_KEY;
1363
                            break;
1364
                        case CODEC_TYPE_VIDEO:
1365
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1366
                            video_size += ret;
1367
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1368
                                pkt.flags |= PKT_FLAG_KEY;
1369
                            if (ost->logfile && enc->stats_out) {
1370
                                fprintf(ost->logfile, "%s", enc->stats_out);
1371
                            }
1372
                            break;
1373
                        default:
1374
                            ret=-1;
1375
                        }
1376

    
1377
                        if(ret<=0)
1378
                            break;
1379
                        pkt.data= bit_buffer;
1380
                        pkt.size= ret;
1381
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1382
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1383
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1384
                    }
1385
                }
1386
            }
1387
        }
1388
    }
1389

    
1390
    return 0;
1391
 fail_decode:
1392
    return -1;
1393
}
1394

    
1395

    
1396
/*
1397
 * The following code is the main loop of the file converter
1398
 */
1399
static int av_encode(AVFormatContext **output_files,
1400
                     int nb_output_files,
1401
                     AVFormatContext **input_files,
1402
                     int nb_input_files,
1403
                     AVStreamMap *stream_maps, int nb_stream_maps)
1404
{
1405
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1406
    AVFormatContext *is, *os;
1407
    AVCodecContext *codec, *icodec;
1408
    AVOutputStream *ost, **ost_table = NULL;
1409
    AVInputStream *ist, **ist_table = NULL;
1410
    AVInputFile *file_table;
1411
    AVFormatContext *stream_no_data;
1412
    int key;
1413

    
1414
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1415
    if (!file_table)
1416
        goto fail;
1417

    
1418
    /* input stream init */
1419
    j = 0;
1420
    for(i=0;i<nb_input_files;i++) {
1421
        is = input_files[i];
1422
        file_table[i].ist_index = j;
1423
        file_table[i].nb_streams = is->nb_streams;
1424
        j += is->nb_streams;
1425
    }
1426
    nb_istreams = j;
1427

    
1428
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1429
    if (!ist_table)
1430
        goto fail;
1431

    
1432
    for(i=0;i<nb_istreams;i++) {
1433
        ist = av_mallocz(sizeof(AVInputStream));
1434
        if (!ist)
1435
            goto fail;
1436
        ist_table[i] = ist;
1437
    }
1438
    j = 0;
1439
    for(i=0;i<nb_input_files;i++) {
1440
        is = input_files[i];
1441
        for(k=0;k<is->nb_streams;k++) {
1442
            ist = ist_table[j++];
1443
            ist->st = is->streams[k];
1444
            ist->file_index = i;
1445
            ist->index = k;
1446
            ist->discard = 1; /* the stream is discarded by default
1447
                                 (changed later) */
1448

    
1449
            if (ist->st->codec->rate_emu) {
1450
                ist->start = av_gettime();
1451
                ist->frame = 0;
1452
            }
1453
        }
1454
    }
1455

    
1456
    /* output stream init */
1457
    nb_ostreams = 0;
1458
    for(i=0;i<nb_output_files;i++) {
1459
        os = output_files[i];
1460
        nb_ostreams += os->nb_streams;
1461
    }
1462
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1463
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1464
        exit(1);
1465
    }
1466

    
1467
    /* Sanity check the mapping args -- do the input files & streams exist? */
1468
    for(i=0;i<nb_stream_maps;i++) {
1469
        int fi = stream_maps[i].file_index;
1470
        int si = stream_maps[i].stream_index;
1471

    
1472
        if (fi < 0 || fi > nb_input_files - 1 ||
1473
            si < 0 || si > file_table[fi].nb_streams - 1) {
1474
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1475
            exit(1);
1476
        }
1477
        fi = stream_maps[i].sync_file_index;
1478
        si = stream_maps[i].sync_stream_index;
1479
        if (fi < 0 || fi > nb_input_files - 1 ||
1480
            si < 0 || si > file_table[fi].nb_streams - 1) {
1481
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1482
            exit(1);
1483
        }
1484
    }
1485

    
1486
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1487
    if (!ost_table)
1488
        goto fail;
1489
    for(i=0;i<nb_ostreams;i++) {
1490
        ost = av_mallocz(sizeof(AVOutputStream));
1491
        if (!ost)
1492
            goto fail;
1493
        ost_table[i] = ost;
1494
    }
1495

    
1496
    n = 0;
1497
    for(k=0;k<nb_output_files;k++) {
1498
        os = output_files[k];
1499
        for(i=0;i<os->nb_streams;i++) {
1500
            int found;
1501
            ost = ost_table[n++];
1502
            ost->file_index = k;
1503
            ost->index = i;
1504
            ost->st = os->streams[i];
1505
            if (nb_stream_maps > 0) {
1506
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1507
                    stream_maps[n-1].stream_index;
1508

    
1509
                /* Sanity check that the stream types match */
1510
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1511
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1512
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1513
                        ost->file_index, ost->index);
1514
                    exit(1);
1515
                }
1516

    
1517
            } else {
1518
                /* get corresponding input stream index : we select the first one with the right type */
1519
                found = 0;
1520
                for(j=0;j<nb_istreams;j++) {
1521
                    ist = ist_table[j];
1522
                    if (ist->discard &&
1523
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1524
                        ost->source_index = j;
1525
                        found = 1;
1526
                        break;
1527
                    }
1528
                }
1529

    
1530
                if (!found) {
1531
                    /* try again and reuse existing stream */
1532
                    for(j=0;j<nb_istreams;j++) {
1533
                        ist = ist_table[j];
1534
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1535
                            ost->source_index = j;
1536
                            found = 1;
1537
                        }
1538
                    }
1539
                    if (!found) {
1540
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1541
                                ost->file_index, ost->index);
1542
                        exit(1);
1543
                    }
1544
                }
1545
            }
1546
            ist = ist_table[ost->source_index];
1547
            ist->discard = 0;
1548
            ost->sync_ist = (nb_stream_maps > 0) ?
1549
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1550
                         stream_maps[n-1].sync_stream_index] : ist;
1551
        }
1552
    }
1553

    
1554
    /* for each output stream, we compute the right encoding parameters */
1555
    for(i=0;i<nb_ostreams;i++) {
1556
        ost = ost_table[i];
1557
        ist = ist_table[ost->source_index];
1558

    
1559
        codec = ost->st->codec;
1560
        icodec = ist->st->codec;
1561

    
1562
        if (ost->st->stream_copy) {
1563
            /* if stream_copy is selected, no need to decode or encode */
1564
            codec->codec_id = icodec->codec_id;
1565
            codec->codec_type = icodec->codec_type;
1566
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1567
            codec->bit_rate = icodec->bit_rate;
1568
            codec->extradata= icodec->extradata;
1569
            codec->extradata_size= icodec->extradata_size;
1570
            codec->time_base = icodec->time_base;
1571
            switch(codec->codec_type) {
1572
            case CODEC_TYPE_AUDIO:
1573
                codec->sample_rate = icodec->sample_rate;
1574
                codec->channels = icodec->channels;
1575
                codec->frame_size = icodec->frame_size;
1576
                codec->block_align= icodec->block_align;
1577
                break;
1578
            case CODEC_TYPE_VIDEO:
1579
                codec->pix_fmt = icodec->pix_fmt;
1580
                codec->width = icodec->width;
1581
                codec->height = icodec->height;
1582
                codec->has_b_frames = icodec->has_b_frames;
1583
                break;
1584
            case CODEC_TYPE_SUBTITLE:
1585
                break;
1586
            default:
1587
                av_abort();
1588
            }
1589
        } else {
1590
            switch(codec->codec_type) {
1591
            case CODEC_TYPE_AUDIO:
1592
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1593
                    goto fail;
1594

    
1595
                if (codec->channels == icodec->channels &&
1596
                    codec->sample_rate == icodec->sample_rate) {
1597
                    ost->audio_resample = 0;
1598
                } else {
1599
                    if (codec->channels != icodec->channels &&
1600
                        (icodec->codec_id == CODEC_ID_AC3 ||
1601
                         icodec->codec_id == CODEC_ID_DTS)) {
1602
                        /* Special case for 5:1 AC3 and DTS input */
1603
                        /* and mono or stereo output      */
1604
                        /* Request specific number of channels */
1605
                        icodec->channels = codec->channels;
1606
                        if (codec->sample_rate == icodec->sample_rate)
1607
                            ost->audio_resample = 0;
1608
                        else {
1609
                            ost->audio_resample = 1;
1610
                        }
1611
                    } else {
1612
                        ost->audio_resample = 1;
1613
                    }
1614
                }
1615
                if(audio_sync_method>1)
1616
                    ost->audio_resample = 1;
1617

    
1618
                if(ost->audio_resample){
1619
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1620
                                                    codec->sample_rate, icodec->sample_rate);
1621
                    if(!ost->resample){
1622
                        printf("Can't resample.  Aborting.\n");
1623
                        av_abort();
1624
                    }
1625
                }
1626
                ist->decoding_needed = 1;
1627
                ost->encoding_needed = 1;
1628
                break;
1629
            case CODEC_TYPE_VIDEO:
1630
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1631
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1632
                ost->video_resample = ((codec->width != icodec->width -
1633
                                (frame_leftBand + frame_rightBand) +
1634
                                (frame_padleft + frame_padright)) ||
1635
                        (codec->height != icodec->height -
1636
                                (frame_topBand  + frame_bottomBand) +
1637
                                (frame_padtop + frame_padbottom)) ||
1638
                        (codec->pix_fmt != icodec->pix_fmt));
1639
                if (ost->video_crop) {
1640
                    ost->topBand = frame_topBand;
1641
                    ost->leftBand = frame_leftBand;
1642
                }
1643
                if (ost->video_pad) {
1644
                    ost->padtop = frame_padtop;
1645
                    ost->padleft = frame_padleft;
1646
                    ost->padbottom = frame_padbottom;
1647
                    ost->padright = frame_padright;
1648
                    if (!ost->video_resample) {
1649
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1650
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1651
                                         codec->width, codec->height ) )
1652
                            goto fail;
1653
                    }
1654
                }
1655
                if (ost->video_resample) {
1656
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1657
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1658
                                         codec->width, codec->height ) )
1659
                        goto fail;
1660

    
1661
                    ost->img_resample_ctx = sws_getContext(
1662
                            icodec->width - (frame_leftBand + frame_rightBand),
1663
                            icodec->height - (frame_topBand + frame_bottomBand),
1664
                            icodec->pix_fmt,
1665
                            codec->width - (frame_padleft + frame_padright),
1666
                            codec->height - (frame_padtop + frame_padbottom),
1667
                            codec->pix_fmt,
1668
                            sws_flags, NULL, NULL, NULL);
1669
                    if (ost->img_resample_ctx == NULL) {
1670
                        fprintf(stderr, "Cannot get resampling context\n");
1671
                        exit(1);
1672
                    }
1673
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1674
                }
1675
                ost->encoding_needed = 1;
1676
                ist->decoding_needed = 1;
1677
                break;
1678
            case CODEC_TYPE_SUBTITLE:
1679
                ost->encoding_needed = 1;
1680
                ist->decoding_needed = 1;
1681
                break;
1682
            default:
1683
                av_abort();
1684
                break;
1685
            }
1686
            /* two pass mode */
1687
            if (ost->encoding_needed &&
1688
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1689
                char logfilename[1024];
1690
                FILE *f;
1691
                int size;
1692
                char *logbuffer;
1693

    
1694
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1695
                         pass_logfilename ?
1696
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1697
                if (codec->flags & CODEC_FLAG_PASS1) {
1698
                    f = fopen(logfilename, "w");
1699
                    if (!f) {
1700
                        perror(logfilename);
1701
                        exit(1);
1702
                    }
1703
                    ost->logfile = f;
1704
                } else {
1705
                    /* read the log file */
1706
                    f = fopen(logfilename, "r");
1707
                    if (!f) {
1708
                        perror(logfilename);
1709
                        exit(1);
1710
                    }
1711
                    fseek(f, 0, SEEK_END);
1712
                    size = ftell(f);
1713
                    fseek(f, 0, SEEK_SET);
1714
                    logbuffer = av_malloc(size + 1);
1715
                    if (!logbuffer) {
1716
                        fprintf(stderr, "Could not allocate log buffer\n");
1717
                        exit(1);
1718
                    }
1719
                    size = fread(logbuffer, 1, size, f);
1720
                    fclose(f);
1721
                    logbuffer[size] = '\0';
1722
                    codec->stats_in = logbuffer;
1723
                }
1724
            }
1725
        }
1726
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1727
            int size= codec->width * codec->height;
1728
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1729
        }
1730
    }
1731

    
1732
    if (!bit_buffer)
1733
        bit_buffer = av_malloc(bit_buffer_size);
1734
    if (!bit_buffer)
1735
        goto fail;
1736

    
1737
    /* dump the file output parameters - cannot be done before in case
1738
       of stream copy */
1739
    for(i=0;i<nb_output_files;i++) {
1740
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1741
    }
1742

    
1743
    /* dump the stream mapping */
1744
    if (verbose >= 0) {
1745
        fprintf(stderr, "Stream mapping:\n");
1746
        for(i=0;i<nb_ostreams;i++) {
1747
            ost = ost_table[i];
1748
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1749
                    ist_table[ost->source_index]->file_index,
1750
                    ist_table[ost->source_index]->index,
1751
                    ost->file_index,
1752
                    ost->index);
1753
            if (ost->sync_ist != ist_table[ost->source_index])
1754
                fprintf(stderr, " [sync #%d.%d]",
1755
                        ost->sync_ist->file_index,
1756
                        ost->sync_ist->index);
1757
            fprintf(stderr, "\n");
1758
        }
1759
    }
1760

    
1761
    /* open each encoder */
1762
    for(i=0;i<nb_ostreams;i++) {
1763
        ost = ost_table[i];
1764
        if (ost->encoding_needed) {
1765
            AVCodec *codec;
1766
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1767
            if (!codec) {
1768
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1769
                        ost->file_index, ost->index);
1770
                exit(1);
1771
            }
1772
            if (avcodec_open(ost->st->codec, codec) < 0) {
1773
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1774
                        ost->file_index, ost->index);
1775
                exit(1);
1776
            }
1777
            extra_size += ost->st->codec->extradata_size;
1778
        }
1779
    }
1780

    
1781
    /* open each decoder */
1782
    for(i=0;i<nb_istreams;i++) {
1783
        ist = ist_table[i];
1784
        if (ist->decoding_needed) {
1785
            AVCodec *codec;
1786
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1787
            if (!codec) {
1788
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1789
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1790
                exit(1);
1791
            }
1792
            if (avcodec_open(ist->st->codec, codec) < 0) {
1793
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1794
                        ist->file_index, ist->index);
1795
                exit(1);
1796
            }
1797
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1798
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1799
        }
1800
    }
1801

    
1802
    /* init pts */
1803
    for(i=0;i<nb_istreams;i++) {
1804
        ist = ist_table[i];
1805
        is = input_files[ist->file_index];
1806
        ist->pts = 0;
1807
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1808
        if(ist->st->start_time == AV_NOPTS_VALUE)
1809
            ist->next_pts=0;
1810
        if(input_files_ts_offset[ist->file_index])
1811
            ist->next_pts= AV_NOPTS_VALUE;
1812
        ist->is_start = 1;
1813
    }
1814

    
1815
    /* compute buffer size max (should use a complete heuristic) */
1816
    for(i=0;i<nb_input_files;i++) {
1817
        file_table[i].buffer_size_max = 2048;
1818
    }
1819

    
1820
    /* set meta data information from input file if required */
1821
    for (i=0;i<nb_meta_data_maps;i++) {
1822
        AVFormatContext *out_file;
1823
        AVFormatContext *in_file;
1824

    
1825
        int out_file_index = meta_data_maps[i].out_file;
1826
        int in_file_index = meta_data_maps[i].in_file;
1827
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1828
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1829
            ret = -EINVAL;
1830
            goto fail;
1831
        }
1832
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1833
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1834
            ret = -EINVAL;
1835
            goto fail;
1836
        }
1837

    
1838
        out_file = output_files[out_file_index];
1839
        in_file = input_files[in_file_index];
1840

    
1841
        strcpy(out_file->title, in_file->title);
1842
        strcpy(out_file->author, in_file->author);
1843
        strcpy(out_file->copyright, in_file->copyright);
1844
        strcpy(out_file->comment, in_file->comment);
1845
        strcpy(out_file->album, in_file->album);
1846
        out_file->year = in_file->year;
1847
        out_file->track = in_file->track;
1848
        strcpy(out_file->genre, in_file->genre);
1849
    }
1850

    
1851
    /* open files and write file headers */
1852
    for(i=0;i<nb_output_files;i++) {
1853
        os = output_files[i];
1854
        if (av_write_header(os) < 0) {
1855
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1856
            ret = -EINVAL;
1857
            goto fail;
1858
        }
1859
    }
1860

    
1861
#ifndef __MINGW32__
1862
    if ( !using_stdin && verbose >= 0) {
1863
        fprintf(stderr, "Press [q] to stop encoding\n");
1864
        url_set_interrupt_cb(decode_interrupt_cb);
1865
    }
1866
#endif
1867
    term_init();
1868

    
1869
    stream_no_data = 0;
1870
    key = -1;
1871

    
1872
    for(; received_sigterm == 0;) {
1873
        int file_index, ist_index;
1874
        AVPacket pkt;
1875
        double ipts_min;
1876
        double opts_min;
1877

    
1878
    redo:
1879
        ipts_min= 1e100;
1880
        opts_min= 1e100;
1881
        /* if 'q' pressed, exits */
1882
        if (!using_stdin) {
1883
            if (q_pressed)
1884
                break;
1885
            /* read_key() returns 0 on EOF */
1886
            key = read_key();
1887
            if (key == 'q')
1888
                break;
1889
        }
1890

    
1891
        /* select the stream that we must read now by looking at the
1892
           smallest output pts */
1893
        file_index = -1;
1894
        for(i=0;i<nb_ostreams;i++) {
1895
            double ipts, opts;
1896
            ost = ost_table[i];
1897
            os = output_files[ost->file_index];
1898
            ist = ist_table[ost->source_index];
1899
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1900
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1901
            else
1902
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1903
            ipts = (double)ist->pts;
1904
            if (!file_table[ist->file_index].eof_reached){
1905
                if(ipts < ipts_min) {
1906
                    ipts_min = ipts;
1907
                    if(input_sync ) file_index = ist->file_index;
1908
                }
1909
                if(opts < opts_min) {
1910
                    opts_min = opts;
1911
                    if(!input_sync) file_index = ist->file_index;
1912
                }
1913
            }
1914
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1915
                file_index= -1;
1916
                break;
1917
            }
1918
        }
1919
        /* if none, if is finished */
1920
        if (file_index < 0) {
1921
            break;
1922
        }
1923

    
1924
        /* finish if recording time exhausted */
1925
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1926
            break;
1927

    
1928
        /* finish if limit size exhausted */
1929
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1930
            break;
1931

    
1932
        /* read a frame from it and output it in the fifo */
1933
        is = input_files[file_index];
1934
        if (av_read_frame(is, &pkt) < 0) {
1935
            file_table[file_index].eof_reached = 1;
1936
            if (opt_shortest) break; else continue; //
1937
        }
1938

    
1939
        if (!pkt.size) {
1940
            stream_no_data = is;
1941
        } else {
1942
            stream_no_data = 0;
1943
        }
1944
        if (do_pkt_dump) {
1945
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1946
        }
1947
        /* the following test is needed in case new streams appear
1948
           dynamically in stream : we ignore them */
1949
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1950
            goto discard_packet;
1951
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1952
        ist = ist_table[ist_index];
1953
        if (ist->discard)
1954
            goto discard_packet;
1955

    
1956
//        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);
1957
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1958
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1959
            if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1960
                input_files_ts_offset[ist->file_index]-= delta;
1961
                if (verbose > 2)
1962
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1963
                for(i=0; i<file_table[file_index].nb_streams; i++){
1964
                    int index= file_table[file_index].ist_index + i;
1965
                    ist_table[index]->next_pts += delta;
1966
                    ist_table[index]->is_start=1;
1967
                }
1968
            }
1969
        }
1970

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

    
1974
            if (verbose >= 0)
1975
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1976
                        ist->file_index, ist->index);
1977

    
1978
            av_free_packet(&pkt);
1979
            goto redo;
1980
        }
1981

    
1982
    discard_packet:
1983
        av_free_packet(&pkt);
1984

    
1985
        /* dump report by using the output first video and audio streams */
1986
        print_report(output_files, ost_table, nb_ostreams, 0);
1987
    }
1988

    
1989
    /* at the end of stream, we must flush the decoder buffers */
1990
    for(i=0;i<nb_istreams;i++) {
1991
        ist = ist_table[i];
1992
        if (ist->decoding_needed) {
1993
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1994
        }
1995
    }
1996

    
1997
    term_exit();
1998

    
1999
    /* write the trailer if needed and close file */
2000
    for(i=0;i<nb_output_files;i++) {
2001
        os = output_files[i];
2002
        av_write_trailer(os);
2003
    }
2004

    
2005
    /* dump report by using the first video and audio streams */
2006
    print_report(output_files, ost_table, nb_ostreams, 1);
2007

    
2008
    /* close each encoder */
2009
    for(i=0;i<nb_ostreams;i++) {
2010
        ost = ost_table[i];
2011
        if (ost->encoding_needed) {
2012
            av_freep(&ost->st->codec->stats_in);
2013
            avcodec_close(ost->st->codec);
2014
        }
2015
    }
2016

    
2017
    /* close each decoder */
2018
    for(i=0;i<nb_istreams;i++) {
2019
        ist = ist_table[i];
2020
        if (ist->decoding_needed) {
2021
            avcodec_close(ist->st->codec);
2022
        }
2023
    }
2024

    
2025
    /* finished ! */
2026

    
2027
    ret = 0;
2028
 fail1:
2029
    av_freep(&bit_buffer);
2030
    av_free(file_table);
2031

    
2032
    if (ist_table) {
2033
        for(i=0;i<nb_istreams;i++) {
2034
            ist = ist_table[i];
2035
            av_free(ist);
2036
        }
2037
        av_free(ist_table);
2038
    }
2039
    if (ost_table) {
2040
        for(i=0;i<nb_ostreams;i++) {
2041
            ost = ost_table[i];
2042
            if (ost) {
2043
                if (ost->logfile) {
2044
                    fclose(ost->logfile);
2045
                    ost->logfile = NULL;
2046
                }
2047
                fifo_free(&ost->fifo); /* works even if fifo is not
2048
                                          initialized but set to zero */
2049
                av_free(ost->pict_tmp.data[0]);
2050
                if (ost->video_resample)
2051
                    sws_freeContext(ost->img_resample_ctx);
2052
                if (ost->audio_resample)
2053
                    audio_resample_close(ost->resample);
2054
                av_free(ost);
2055
            }
2056
        }
2057
        av_free(ost_table);
2058
    }
2059
    return ret;
2060
 fail:
2061
    ret = -ENOMEM;
2062
    goto fail1;
2063
}
2064

    
2065
#if 0
2066
int file_read(const char *filename)
2067
{
2068
    URLContext *h;
2069
    unsigned char buffer[1024];
2070
    int len, i;
2071

2072
    if (url_open(&h, filename, O_RDONLY) < 0) {
2073
        printf("could not open '%s'\n", filename);
2074
        return -1;
2075
    }
2076
    for(;;) {
2077
        len = url_read(h, buffer, sizeof(buffer));
2078
        if (len <= 0)
2079
            break;
2080
        for(i=0;i<len;i++) putchar(buffer[i]);
2081
    }
2082
    url_close(h);
2083
    return 0;
2084
}
2085
#endif
2086

    
2087
static void opt_image_format(const char *arg)
2088
{
2089
    AVImageFormat *f;
2090

    
2091
    for(f = first_image_format; f != NULL; f = f->next) {
2092
        if (!strcmp(arg, f->name))
2093
            break;
2094
    }
2095
    if (!f) {
2096
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2097
        exit(1);
2098
    }
2099
    image_format = f;
2100
}
2101

    
2102
static void opt_format(const char *arg)
2103
{
2104
    /* compatibility stuff for pgmyuv */
2105
    if (!strcmp(arg, "pgmyuv")) {
2106
        pgmyuv_compatibility_hack=1;
2107
//        opt_image_format(arg);
2108
        arg = "image2";
2109
    }
2110

    
2111
    file_iformat = av_find_input_format(arg);
2112
    file_oformat = guess_format(arg, NULL, NULL);
2113
    if (!file_iformat && !file_oformat) {
2114
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2115
        exit(1);
2116
    }
2117
}
2118

    
2119
static void opt_video_bitrate(const char *arg)
2120
{
2121
    video_bit_rate = atoi(arg) * 1000;
2122
}
2123

    
2124
static void opt_video_bitrate_tolerance(const char *arg)
2125
{
2126
    video_bit_rate_tolerance = atoi(arg) * 1000;
2127
}
2128

    
2129
static void opt_video_bitrate_max(const char *arg)
2130
{
2131
    video_rc_max_rate = atoi(arg) * 1000;
2132
}
2133

    
2134
static void opt_video_bitrate_min(const char *arg)
2135
{
2136
    video_rc_min_rate = atoi(arg) * 1000;
2137
}
2138

    
2139
static void opt_video_buffer_size(const char *arg)
2140
{
2141
    video_rc_buffer_size = atoi(arg) * 8*1024;
2142
}
2143

    
2144
static void opt_video_rc_eq(char *arg)
2145
{
2146
    video_rc_eq = arg;
2147
}
2148

    
2149
static void opt_video_rc_override_string(char *arg)
2150
{
2151
    video_rc_override_string = arg;
2152
}
2153

    
2154

    
2155
static void opt_workaround_bugs(const char *arg)
2156
{
2157
    workaround_bugs = atoi(arg);
2158
}
2159

    
2160
static void opt_me_threshold(const char *arg)
2161
{
2162
    me_threshold = atoi(arg);
2163
}
2164

    
2165
static void opt_mb_threshold(const char *arg)
2166
{
2167
    mb_threshold = atoi(arg);
2168
}
2169

    
2170
static void opt_verbose(const char *arg)
2171
{
2172
    verbose = atoi(arg);
2173
    av_log_set_level(atoi(arg));
2174
}
2175

    
2176
static void opt_frame_rate(const char *arg)
2177
{
2178
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2179
        fprintf(stderr, "Incorrect frame rate\n");
2180
        exit(1);
2181
    }
2182
}
2183

    
2184
static void opt_frame_crop_top(const char *arg)
2185
{
2186
    frame_topBand = atoi(arg);
2187
    if (frame_topBand < 0) {
2188
        fprintf(stderr, "Incorrect top crop size\n");
2189
        exit(1);
2190
    }
2191
    if ((frame_topBand % 2) != 0) {
2192
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2193
        exit(1);
2194
    }
2195
    if ((frame_topBand) >= frame_height){
2196
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2197
        exit(1);
2198
    }
2199
    frame_height -= frame_topBand;
2200
}
2201

    
2202
static void opt_frame_crop_bottom(const char *arg)
2203
{
2204
    frame_bottomBand = atoi(arg);
2205
    if (frame_bottomBand < 0) {
2206
        fprintf(stderr, "Incorrect bottom crop size\n");
2207
        exit(1);
2208
    }
2209
    if ((frame_bottomBand % 2) != 0) {
2210
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2211
        exit(1);
2212
    }
2213
    if ((frame_bottomBand) >= frame_height){
2214
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2215
        exit(1);
2216
    }
2217
    frame_height -= frame_bottomBand;
2218
}
2219

    
2220
static void opt_frame_crop_left(const char *arg)
2221
{
2222
    frame_leftBand = atoi(arg);
2223
    if (frame_leftBand < 0) {
2224
        fprintf(stderr, "Incorrect left crop size\n");
2225
        exit(1);
2226
    }
2227
    if ((frame_leftBand % 2) != 0) {
2228
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2229
        exit(1);
2230
    }
2231
    if ((frame_leftBand) >= frame_width){
2232
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2233
        exit(1);
2234
    }
2235
    frame_width -= frame_leftBand;
2236
}
2237

    
2238
static void opt_frame_crop_right(const char *arg)
2239
{
2240
    frame_rightBand = atoi(arg);
2241
    if (frame_rightBand < 0) {
2242
        fprintf(stderr, "Incorrect right crop size\n");
2243
        exit(1);
2244
    }
2245
    if ((frame_rightBand % 2) != 0) {
2246
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2247
        exit(1);
2248
    }
2249
    if ((frame_rightBand) >= frame_width){
2250
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2251
        exit(1);
2252
    }
2253
    frame_width -= frame_rightBand;
2254
}
2255

    
2256
static void opt_frame_size(const char *arg)
2257
{
2258
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2259
        fprintf(stderr, "Incorrect frame size\n");
2260
        exit(1);
2261
    }
2262
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2263
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2264
        exit(1);
2265
    }
2266
}
2267

    
2268

    
2269
#define SCALEBITS 10
2270
#define ONE_HALF  (1 << (SCALEBITS - 1))
2271
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2272

    
2273
#define RGB_TO_Y(r, g, b) \
2274
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2275
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2276

    
2277
#define RGB_TO_U(r1, g1, b1, shift)\
2278
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2279
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2280

    
2281
#define RGB_TO_V(r1, g1, b1, shift)\
2282
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2283
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2284

    
2285
static void opt_pad_color(const char *arg) {
2286
    /* Input is expected to be six hex digits similar to
2287
       how colors are expressed in html tags (but without the #) */
2288
    int rgb = strtol(arg, NULL, 16);
2289
    int r,g,b;
2290

    
2291
    r = (rgb >> 16);
2292
    g = ((rgb >> 8) & 255);
2293
    b = (rgb & 255);
2294

    
2295
    padcolor[0] = RGB_TO_Y(r,g,b);
2296
    padcolor[1] = RGB_TO_U(r,g,b,0);
2297
    padcolor[2] = RGB_TO_V(r,g,b,0);
2298
}
2299

    
2300
static void opt_frame_pad_top(const char *arg)
2301
{
2302
    frame_padtop = atoi(arg);
2303
    if (frame_padtop < 0) {
2304
        fprintf(stderr, "Incorrect top pad size\n");
2305
        exit(1);
2306
    }
2307
    if ((frame_padtop % 2) != 0) {
2308
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2309
        exit(1);
2310
    }
2311
}
2312

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

    
2326

    
2327
static void opt_frame_pad_left(const char *arg)
2328
{
2329
    frame_padleft = atoi(arg);
2330
    if (frame_padleft < 0) {
2331
        fprintf(stderr, "Incorrect left pad size\n");
2332
        exit(1);
2333
    }
2334
    if ((frame_padleft % 2) != 0) {
2335
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2336
        exit(1);
2337
    }
2338
}
2339

    
2340

    
2341
static void opt_frame_pad_right(const char *arg)
2342
{
2343
    frame_padright = atoi(arg);
2344
    if (frame_padright < 0) {
2345
        fprintf(stderr, "Incorrect right pad size\n");
2346
        exit(1);
2347
    }
2348
    if ((frame_padright % 2) != 0) {
2349
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2350
        exit(1);
2351
    }
2352
}
2353

    
2354

    
2355
static void opt_frame_pix_fmt(const char *arg)
2356
{
2357
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2358
}
2359

    
2360
static void opt_frame_aspect_ratio(const char *arg)
2361
{
2362
    int x = 0, y = 0;
2363
    double ar = 0;
2364
    const char *p;
2365

    
2366
    p = strchr(arg, ':');
2367
    if (p) {
2368
        x = strtol(arg, (char **)&arg, 10);
2369
        if (arg == p)
2370
            y = strtol(arg+1, (char **)&arg, 10);
2371
        if (x > 0 && y > 0)
2372
            ar = (double)x / (double)y;
2373
    } else
2374
        ar = strtod(arg, (char **)&arg);
2375

    
2376
    if (!ar) {
2377
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2378
        exit(1);
2379
    }
2380
    frame_aspect_ratio = ar;
2381
}
2382

    
2383
static void opt_gop_size(const char *arg)
2384
{
2385
    gop_size = atoi(arg);
2386
}
2387

    
2388
static void opt_b_frames(const char *arg)
2389
{
2390
    b_frames = atoi(arg);
2391
    if (b_frames > FF_MAX_B_FRAMES) {
2392
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2393
        exit(1);
2394
    } else if (b_frames < 1) {
2395
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2396
        exit(1);
2397
    }
2398
}
2399

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

    
2405
static void opt_qscale(const char *arg)
2406
{
2407
    video_qscale = atof(arg);
2408
    if (video_qscale <= 0 ||
2409
        video_qscale > 255) {
2410
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2411
        exit(1);
2412
    }
2413
}
2414

    
2415
static void opt_qsquish(const char *arg)
2416
{
2417
    video_qsquish = atof(arg);
2418
    if (video_qsquish < 0.0 ||
2419
        video_qsquish > 99.0) {
2420
        fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2421
        exit(1);
2422
    }
2423
}
2424

    
2425
static void opt_lmax(const char *arg)
2426
{
2427
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2428
}
2429

    
2430
static void opt_lmin(const char *arg)
2431
{
2432
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2433
}
2434

    
2435
static void opt_qmin(const char *arg)
2436
{
2437
    video_qmin = atoi(arg);
2438
    if (video_qmin < 1 ||
2439
        video_qmin > 51) {
2440
        fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2441
        exit(1);
2442
    }
2443
}
2444

    
2445
static void opt_qmax(const char *arg)
2446
{
2447
    video_qmax = atoi(arg);
2448
    if (video_qmax < 1 ||
2449
        video_qmax > 51) {
2450
        fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2451
        exit(1);
2452
    }
2453
}
2454

    
2455
static void opt_mb_lmin(const char *arg)
2456
{
2457
    video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2458
    if (video_mb_lmin < 1 ||
2459
        video_mb_lmin > FF_LAMBDA_MAX) {
2460
        fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2461
        exit(1);
2462
    }
2463
}
2464

    
2465
static void opt_mb_lmax(const char *arg)
2466
{
2467
    video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2468
    if (video_mb_lmax < 1 ||
2469
        video_mb_lmax > FF_LAMBDA_MAX) {
2470
        fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2471
        exit(1);
2472
    }
2473
}
2474

    
2475
static void opt_qdiff(const char *arg)
2476
{
2477
    video_qdiff = atoi(arg);
2478
    if (video_qdiff < 0 ||
2479
        video_qdiff > 31) {
2480
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2481
        exit(1);
2482
    }
2483
}
2484

    
2485
static void opt_qblur(const char *arg)
2486
{
2487
    video_qblur = atof(arg);
2488
}
2489

    
2490
static void opt_qcomp(const char *arg)
2491
{
2492
    video_qcomp = atof(arg);
2493
}
2494

    
2495
static void opt_rc_initial_cplx(const char *arg)
2496
{
2497
    video_rc_initial_cplx = atof(arg);
2498
}
2499
static void opt_b_qfactor(const char *arg)
2500
{
2501
    video_b_qfactor = atof(arg);
2502
}
2503
static void opt_i_qfactor(const char *arg)
2504
{
2505
    video_i_qfactor = atof(arg);
2506
}
2507
static void opt_b_qoffset(const char *arg)
2508
{
2509
    video_b_qoffset = atof(arg);
2510
}
2511
static void opt_i_qoffset(const char *arg)
2512
{
2513
    video_i_qoffset = atof(arg);
2514
}
2515

    
2516
static void opt_ibias(const char *arg)
2517
{
2518
    video_intra_quant_bias = atoi(arg);
2519
}
2520
static void opt_pbias(const char *arg)
2521
{
2522
    video_inter_quant_bias = atoi(arg);
2523
}
2524

    
2525
static void opt_packet_size(const char *arg)
2526
{
2527
    packet_size= atoi(arg);
2528
}
2529

    
2530
static void opt_error_rate(const char *arg)
2531
{
2532
    error_rate= atoi(arg);
2533
}
2534

    
2535
static void opt_strict(const char *arg)
2536
{
2537
    strict= atoi(arg);
2538
}
2539

    
2540
static void opt_top_field_first(const char *arg)
2541
{
2542
    top_field_first= atoi(arg);
2543
}
2544

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

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

    
2555
static void opt_thread_count(const char *arg)
2556
{
2557
    thread_count= atoi(arg);
2558
#if !defined(HAVE_THREADS)
2559
    if (verbose >= 0)
2560
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2561
#endif
2562
}
2563

    
2564
static void opt_audio_bitrate(const char *arg)
2565
{
2566
    audio_bit_rate = atoi(arg) * 1000;
2567
}
2568

    
2569
static void opt_audio_rate(const char *arg)
2570
{
2571
    audio_sample_rate = atoi(arg);
2572
}
2573

    
2574
static void opt_audio_channels(const char *arg)
2575
{
2576
    audio_channels = atoi(arg);
2577
}
2578

    
2579
static void opt_video_device(const char *arg)
2580
{
2581
    video_device = av_strdup(arg);
2582
}
2583

    
2584
static void opt_grab_device(const char *arg)
2585
{
2586
    grab_device = av_strdup(arg);
2587
}
2588

    
2589
static void opt_video_channel(const char *arg)
2590
{
2591
    video_channel = strtol(arg, NULL, 0);
2592
}
2593

    
2594
static void opt_video_standard(const char *arg)
2595
{
2596
    video_standard = av_strdup(arg);
2597
}
2598

    
2599
static void opt_audio_device(const char *arg)
2600
{
2601
    audio_device = av_strdup(arg);
2602
}
2603

    
2604
static void opt_codec(int *pstream_copy, int *pcodec_id,
2605
                      int codec_type, const char *arg)
2606
{
2607
    AVCodec *p;
2608

    
2609
    if (!strcmp(arg, "copy")) {
2610
        *pstream_copy = 1;
2611
    } else {
2612
        p = first_avcodec;
2613
        while (p) {
2614
            if (!strcmp(p->name, arg) && p->type == codec_type)
2615
                break;
2616
            p = p->next;
2617
        }
2618
        if (p == NULL) {
2619
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2620
            exit(1);
2621
        } else {
2622
            *pcodec_id = p->id;
2623
        }
2624
    }
2625
}
2626

    
2627
static void opt_audio_codec(const char *arg)
2628
{
2629
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2630
}
2631

    
2632
static void opt_audio_tag(const char *arg)
2633
{
2634
    char *tail;
2635
    audio_codec_tag= strtol(arg, &tail, 0);
2636

    
2637
    if(!tail || *tail)
2638
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2639
}
2640

    
2641
static void opt_video_tag(const char *arg)
2642
{
2643
    char *tail;
2644
    video_codec_tag= strtol(arg, &tail, 0);
2645

    
2646
    if(!tail || *tail)
2647
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2648
}
2649

    
2650
static void add_frame_hooker(const char *arg)
2651
{
2652
    int argc = 0;
2653
    char *argv[64];
2654
    int i;
2655
    char *args = av_strdup(arg);
2656

    
2657
    using_vhook = 1;
2658

    
2659
    argv[0] = strtok(args, " ");
2660
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2661
    }
2662

    
2663
    i = frame_hook_add(argc, argv);
2664

    
2665
    if (i != 0) {
2666
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2667
        exit(1);
2668
    }
2669
}
2670

    
2671
const char *motion_str[] = {
2672
    "zero",
2673
    "full",
2674
    "log",
2675
    "phods",
2676
    "epzs",
2677
    "x1",
2678
    "hex",
2679
    "umh",
2680
    "iter",
2681
    NULL,
2682
};
2683

    
2684
static void opt_motion_estimation(const char *arg)
2685
{
2686
    const char **p;
2687
    p = motion_str;
2688
    for(;;) {
2689
        if (!*p) {
2690
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2691
            exit(1);
2692
        }
2693
        if (!strcmp(*p, arg))
2694
            break;
2695
        p++;
2696
    }
2697
    me_method = (p - motion_str) + 1;
2698
}
2699

    
2700
static void opt_video_codec(const char *arg)
2701
{
2702
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2703
}
2704

    
2705
static void opt_subtitle_codec(const char *arg)
2706
{
2707
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2708
}
2709

    
2710
static void opt_map(const char *arg)
2711
{
2712
    AVStreamMap *m;
2713
    const char *p;
2714

    
2715
    p = arg;
2716
    m = &stream_maps[nb_stream_maps++];
2717

    
2718
    m->file_index = strtol(arg, (char **)&p, 0);
2719
    if (*p)
2720
        p++;
2721

    
2722
    m->stream_index = strtol(p, (char **)&p, 0);
2723
    if (*p) {
2724
        p++;
2725
        m->sync_file_index = strtol(p, (char **)&p, 0);
2726
        if (*p)
2727
            p++;
2728
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2729
    } else {
2730
        m->sync_file_index = m->file_index;
2731
        m->sync_stream_index = m->stream_index;
2732
    }
2733
}
2734

    
2735
static void opt_map_meta_data(const char *arg)
2736
{
2737
    AVMetaDataMap *m;
2738
    const char *p;
2739

    
2740
    p = arg;
2741
    m = &meta_data_maps[nb_meta_data_maps++];
2742

    
2743
    m->out_file = strtol(arg, (char **)&p, 0);
2744
    if (*p)
2745
        p++;
2746

    
2747
    m->in_file = strtol(p, (char **)&p, 0);
2748
}
2749

    
2750
static void opt_recording_time(const char *arg)
2751
{
2752
    recording_time = parse_date(arg, 1);
2753
}
2754

    
2755
static void opt_start_time(const char *arg)
2756
{
2757
    start_time = parse_date(arg, 1);
2758
}
2759

    
2760
static void opt_rec_timestamp(const char *arg)
2761
{
2762
    rec_timestamp = parse_date(arg, 0) / 1000000;
2763
}
2764

    
2765
static void opt_input_ts_offset(const char *arg)
2766
{
2767
    input_ts_offset = parse_date(arg, 1);
2768
}
2769

    
2770
static void opt_input_file(const char *filename)
2771
{
2772
    AVFormatContext *ic;
2773
    AVFormatParameters params, *ap = &params;
2774
    int err, i, ret, rfps, rfps_base;
2775
    int64_t timestamp;
2776

    
2777
    if (!strcmp(filename, "-"))
2778
        filename = "pipe:";
2779

    
2780
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2781
                   !strcmp( filename, "/dev/stdin" );
2782

    
2783
    /* get default parameters from command line */
2784
    ic = av_alloc_format_context();
2785

    
2786
    memset(ap, 0, sizeof(*ap));
2787
    ap->prealloced_context = 1;
2788
    ap->sample_rate = audio_sample_rate;
2789
    ap->channels = audio_channels;
2790
    ap->time_base.den = frame_rate;
2791
    ap->time_base.num = frame_rate_base;
2792
    ap->width = frame_width + frame_padleft + frame_padright;
2793
    ap->height = frame_height + frame_padtop + frame_padbottom;
2794
    ap->image_format = image_format;
2795
    ap->pix_fmt = frame_pix_fmt;
2796
    ap->device  = grab_device;
2797
    ap->channel = video_channel;
2798
    ap->standard = video_standard;
2799
    ap->video_codec_id = video_codec_id;
2800
    ap->audio_codec_id = audio_codec_id;
2801
    if(pgmyuv_compatibility_hack)
2802
        ap->video_codec_id= CODEC_ID_PGMYUV;
2803

    
2804
    for(i=0; i<opt_name_count; i++){
2805
        AVOption *opt;
2806
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2807
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2808
            av_set_double(ic, opt_names[i], d);
2809
    }
2810
    /* open the input file with generic libav function */
2811
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2812
    if (err < 0) {
2813
        print_error(filename, err);
2814
        exit(1);
2815
    }
2816

    
2817
    ic->loop_input = loop_input;
2818

    
2819
    /* If not enough info to get the stream parameters, we decode the
2820
       first frames to get it. (used in mpeg case for example) */
2821
    ret = av_find_stream_info(ic);
2822
    if (ret < 0 && verbose >= 0) {
2823
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2824
        exit(1);
2825
    }
2826

    
2827
    timestamp = start_time;
2828
    /* add the stream start time */
2829
    if (ic->start_time != AV_NOPTS_VALUE)
2830
        timestamp += ic->start_time;
2831

    
2832
    /* if seeking requested, we execute it */
2833
    if (start_time != 0) {
2834
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2835
        if (ret < 0) {
2836
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2837
                    filename, (double)timestamp / AV_TIME_BASE);
2838
        }
2839
        /* reset seek info */
2840
        start_time = 0;
2841
    }
2842

    
2843
    /* update the current parameters so that they match the one of the input stream */
2844
    for(i=0;i<ic->nb_streams;i++) {
2845
        int j;
2846
        AVCodecContext *enc = ic->streams[i]->codec;
2847
#if defined(HAVE_THREADS)
2848
        if(thread_count>1)
2849
            avcodec_thread_init(enc, thread_count);
2850
#endif
2851
        enc->thread_count= thread_count;
2852
        switch(enc->codec_type) {
2853
        case CODEC_TYPE_AUDIO:
2854
            for(j=0; j<opt_name_count; j++){
2855
                AVOption *opt;
2856
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2857
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2858
                    av_set_double(enc, opt_names[j], d);
2859
            }
2860
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2861
            audio_channels = enc->channels;
2862
            audio_sample_rate = enc->sample_rate;
2863
            if(audio_disable)
2864
                ic->streams[i]->discard= AVDISCARD_ALL;
2865
            break;
2866
        case CODEC_TYPE_VIDEO:
2867
            for(j=0; j<opt_name_count; j++){
2868
                AVOption *opt;
2869
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2870
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2871
                    av_set_double(enc, opt_names[j], d);
2872
            }
2873
            frame_height = enc->height;
2874
            frame_width = enc->width;
2875
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2876
            frame_pix_fmt = enc->pix_fmt;
2877
            rfps      = ic->streams[i]->r_frame_rate.num;
2878
            rfps_base = ic->streams[i]->r_frame_rate.den;
2879
            enc->workaround_bugs = workaround_bugs;
2880
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2881
            if(me_threshold)
2882
                enc->debug |= FF_DEBUG_MV;
2883

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

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

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

    
2896
            enc->rate_emu = rate_emu;
2897
            if(video_disable)
2898
                ic->streams[i]->discard= AVDISCARD_ALL;
2899
            else if(video_discard)
2900
                ic->streams[i]->discard= video_discard;
2901
            break;
2902
        case CODEC_TYPE_DATA:
2903
            break;
2904
        case CODEC_TYPE_SUBTITLE:
2905
            break;
2906
        case CODEC_TYPE_UNKNOWN:
2907
            break;
2908
        default:
2909
            av_abort();
2910
        }
2911
    }
2912

    
2913
    input_files[nb_input_files] = ic;
2914
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2915
    /* dump the file content */
2916
    if (verbose >= 0)
2917
        dump_format(ic, nb_input_files, filename, 0);
2918

    
2919
    nb_input_files++;
2920
    file_iformat = NULL;
2921
    file_oformat = NULL;
2922
    image_format = NULL;
2923

    
2924
    grab_device = NULL;
2925
    video_channel = 0;
2926

    
2927
    rate_emu = 0;
2928
}
2929

    
2930
static void opt_grab(const char *arg)
2931
{
2932
    file_iformat = av_find_input_format(arg);
2933
    opt_input_file("");
2934
}
2935

    
2936
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2937
{
2938
    int has_video, has_audio, i, j;
2939
    AVFormatContext *ic;
2940

    
2941
    has_video = 0;
2942
    has_audio = 0;
2943
    for(j=0;j<nb_input_files;j++) {
2944
        ic = input_files[j];
2945
        for(i=0;i<ic->nb_streams;i++) {
2946
            AVCodecContext *enc = ic->streams[i]->codec;
2947
            switch(enc->codec_type) {
2948
            case CODEC_TYPE_AUDIO:
2949
                has_audio = 1;
2950
                break;
2951
            case CODEC_TYPE_VIDEO:
2952
                has_video = 1;
2953
                break;
2954
            case CODEC_TYPE_DATA:
2955
            case CODEC_TYPE_UNKNOWN:
2956
            case CODEC_TYPE_SUBTITLE:
2957
                break;
2958
            default:
2959
                av_abort();
2960
            }
2961
        }
2962
    }
2963
    *has_video_ptr = has_video;
2964
    *has_audio_ptr = has_audio;
2965
}
2966

    
2967
static void new_video_stream(AVFormatContext *oc)
2968
{
2969
    AVStream *st;
2970
    AVCodecContext *video_enc;
2971
    int codec_id;
2972

    
2973
    st = av_new_stream(oc, oc->nb_streams);
2974
    if (!st) {
2975
        fprintf(stderr, "Could not alloc stream\n");
2976
        exit(1);
2977
    }
2978
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2979
    video_bitstream_filters= NULL;
2980

    
2981
#if defined(HAVE_THREADS)
2982
    if(thread_count>1)
2983
        avcodec_thread_init(st->codec, thread_count);
2984
#endif
2985

    
2986
    video_enc = st->codec;
2987

    
2988
    if(video_codec_tag)
2989
        video_enc->codec_tag= video_codec_tag;
2990

    
2991
    if(   (video_global_header&1)
2992
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2993
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2994
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2995
    }
2996
    if(video_global_header&2){
2997
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2998
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2999
    }
3000

    
3001
    if (video_stream_copy) {
3002
        st->stream_copy = 1;
3003
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3004
    } else {
3005
        char *p;
3006
        int i;
3007
        AVCodec *codec;
3008

    
3009
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3010
        if (video_codec_id != CODEC_ID_NONE)
3011
            codec_id = video_codec_id;
3012

    
3013
        video_enc->codec_id = codec_id;
3014
        codec = avcodec_find_encoder(codec_id);
3015

    
3016
        for(i=0; i<opt_name_count; i++){
3017
             AVOption *opt;
3018
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3019
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3020
                 av_set_double(video_enc, opt_names[i], d);
3021
        }
3022

    
3023
        video_enc->bit_rate = video_bit_rate;
3024
        video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3025
        video_enc->time_base.den = frame_rate;
3026
        video_enc->time_base.num = frame_rate_base;
3027
        if(codec && codec->supported_framerates){
3028
            const AVRational *p= codec->supported_framerates;
3029
            AVRational req= (AVRational){frame_rate, frame_rate_base};
3030
            const AVRational *best=NULL;
3031
            AVRational best_error= (AVRational){INT_MAX, 1};
3032
            for(; p->den!=0; p++){
3033
                AVRational error= av_sub_q(req, *p);
3034
                if(error.num <0) error.num *= -1;
3035
                if(av_cmp_q(error, best_error) < 0){
3036
                    best_error= error;
3037
                    best= p;
3038
                }
3039
            }
3040
            video_enc->time_base.den= best->num;
3041
            video_enc->time_base.num= best->den;
3042
        }
3043

    
3044
        video_enc->width = frame_width + frame_padright + frame_padleft;
3045
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3046
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3047
        video_enc->pix_fmt = frame_pix_fmt;
3048

    
3049
        if(codec && codec->pix_fmts){
3050
            const enum PixelFormat *p= codec->pix_fmts;
3051
            for(; *p!=-1; p++){
3052
                if(*p == video_enc->pix_fmt)
3053
                    break;
3054
            }
3055
            if(*p == -1)
3056
                video_enc->pix_fmt = codec->pix_fmts[0];
3057
        }
3058

    
3059
        if (!intra_only)
3060
            video_enc->gop_size = gop_size;
3061
        else
3062
            video_enc->gop_size = 0;
3063
        if (video_qscale || same_quality) {
3064
            video_enc->flags |= CODEC_FLAG_QSCALE;
3065
            video_enc->global_quality=
3066
                st->quality = FF_QP2LAMBDA * video_qscale;
3067
        }
3068

    
3069
        if(intra_matrix)
3070
            video_enc->intra_matrix = intra_matrix;
3071
        if(inter_matrix)
3072
            video_enc->inter_matrix = inter_matrix;
3073

    
3074
        video_enc->pre_me = pre_me;
3075

    
3076
        if (b_frames) {
3077
            video_enc->max_b_frames = b_frames;
3078
            video_enc->b_quant_factor = 2.0;
3079
        }
3080
        video_enc->qmin = video_qmin;
3081
        video_enc->qmax = video_qmax;
3082
        video_enc->lmin = video_lmin;
3083
        video_enc->lmax = video_lmax;
3084
        video_enc->rc_qsquish = video_qsquish;
3085
        video_enc->mb_lmin = video_mb_lmin;
3086
        video_enc->mb_lmax = video_mb_lmax;
3087
        video_enc->max_qdiff = video_qdiff;
3088
        video_enc->qblur = video_qblur;
3089
        video_enc->qcompress = video_qcomp;
3090
        video_enc->rc_eq = video_rc_eq;
3091
        video_enc->workaround_bugs = workaround_bugs;
3092
        video_enc->thread_count = thread_count;
3093
        p= video_rc_override_string;
3094
        for(i=0; p; i++){
3095
            int start, end, q;
3096
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3097
            if(e!=3){
3098
                fprintf(stderr, "error parsing rc_override\n");
3099
                exit(1);
3100
            }
3101
            video_enc->rc_override=
3102
                av_realloc(video_enc->rc_override,
3103
                           sizeof(RcOverride)*(i+1));
3104
            video_enc->rc_override[i].start_frame= start;
3105
            video_enc->rc_override[i].end_frame  = end;
3106
            if(q>0){
3107
                video_enc->rc_override[i].qscale= q;
3108
                video_enc->rc_override[i].quality_factor= 1.0;
3109
            }
3110
            else{
3111
                video_enc->rc_override[i].qscale= 0;
3112
                video_enc->rc_override[i].quality_factor= -q/100.0;
3113
            }
3114
            p= strchr(p, '/');
3115
            if(p) p++;
3116
        }
3117
        video_enc->rc_override_count=i;
3118

    
3119
        video_enc->rc_max_rate = video_rc_max_rate;
3120
        video_enc->rc_min_rate = video_rc_min_rate;
3121
        video_enc->rc_buffer_size = video_rc_buffer_size;
3122
        video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3123
        video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3124
        video_enc->rc_initial_cplx= video_rc_initial_cplx;
3125
        video_enc->i_quant_factor = video_i_qfactor;
3126
        video_enc->b_quant_factor = video_b_qfactor;
3127
        video_enc->i_quant_offset = video_i_qoffset;
3128
        video_enc->b_quant_offset = video_b_qoffset;
3129
        video_enc->intra_quant_bias = video_intra_quant_bias;
3130
        video_enc->inter_quant_bias = video_inter_quant_bias;
3131
        video_enc->me_threshold= me_threshold;
3132
        video_enc->mb_threshold= mb_threshold;
3133
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3134
        video_enc->strict_std_compliance = strict;
3135
        video_enc->error_rate = error_rate;
3136
        video_enc->scenechange_threshold= sc_threshold;
3137
        video_enc->me_range = me_range;
3138
        video_enc->me_penalty_compensation= me_penalty_compensation;
3139
        video_enc->frame_skip_threshold= frame_skip_threshold;
3140
        video_enc->frame_skip_factor= frame_skip_factor;
3141
        video_enc->frame_skip_exp= frame_skip_exp;
3142

    
3143
        if(packet_size){
3144
            video_enc->rtp_mode= 1;
3145
            video_enc->rtp_payload_size= packet_size;
3146
        }
3147

    
3148
        if (do_psnr)
3149
            video_enc->flags|= CODEC_FLAG_PSNR;
3150

    
3151
        video_enc->me_method = me_method;
3152

    
3153
        /* two pass mode */
3154
        if (do_pass) {
3155
            if (do_pass == 1) {
3156
                video_enc->flags |= CODEC_FLAG_PASS1;
3157
            } else {
3158
                video_enc->flags |= CODEC_FLAG_PASS2;
3159
            }
3160
        }
3161
    }
3162

    
3163
    /* reset some key parameters */
3164
    video_disable = 0;
3165
    video_codec_id = CODEC_ID_NONE;
3166
    video_stream_copy = 0;
3167
}
3168

    
3169
static void new_audio_stream(AVFormatContext *oc)
3170
{
3171
    AVStream *st;
3172
    AVCodecContext *audio_enc;
3173
    int codec_id, i;
3174

    
3175
    st = av_new_stream(oc, oc->nb_streams);
3176
    if (!st) {
3177
        fprintf(stderr, "Could not alloc stream\n");
3178
        exit(1);
3179
    }
3180

    
3181
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3182
    audio_bitstream_filters= NULL;
3183

    
3184
#if defined(HAVE_THREADS)
3185
    if(thread_count>1)
3186
        avcodec_thread_init(st->codec, thread_count);
3187
#endif
3188

    
3189
    audio_enc = st->codec;
3190
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3191

    
3192
    if(audio_codec_tag)
3193
        audio_enc->codec_tag= audio_codec_tag;
3194

    
3195
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3196
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3197
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3198
    }
3199
    if (audio_stream_copy) {
3200
        st->stream_copy = 1;
3201
        audio_enc->channels = audio_channels;
3202
    } else {
3203
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3204

    
3205
        for(i=0; i<opt_name_count; i++){
3206
            AVOption *opt;
3207
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
3208
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3209
                av_set_double(audio_enc, opt_names[i], d);
3210
        }
3211

    
3212
        if (audio_codec_id != CODEC_ID_NONE)
3213
            codec_id = audio_codec_id;
3214
        audio_enc->codec_id = codec_id;
3215

    
3216
        audio_enc->bit_rate = audio_bit_rate;
3217
        if (audio_qscale > QSCALE_NONE) {
3218
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3219
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3220
        }
3221
        audio_enc->strict_std_compliance = strict;
3222
        audio_enc->thread_count = thread_count;
3223
        /* For audio codecs other than AC3 or DTS we limit */
3224
        /* the number of coded channels to stereo   */
3225
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3226
            && codec_id != CODEC_ID_DTS) {
3227
            audio_enc->channels = 2;
3228
        } else
3229
            audio_enc->channels = audio_channels;
3230
    }
3231
    audio_enc->sample_rate = audio_sample_rate;
3232
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3233
    if (audio_language) {
3234
        pstrcpy(st->language, sizeof(st->language), audio_language);
3235
        av_free(audio_language);
3236
        audio_language = NULL;
3237
    }
3238

    
3239
    /* reset some key parameters */
3240
    audio_disable = 0;
3241
    audio_codec_id = CODEC_ID_NONE;
3242
    audio_stream_copy = 0;
3243
}
3244

    
3245
static void opt_new_subtitle_stream(void)
3246
{
3247
    AVFormatContext *oc;
3248
    AVStream *st;
3249
    AVCodecContext *subtitle_enc;
3250
    int i;
3251

    
3252
    if (nb_output_files <= 0) {
3253
        fprintf(stderr, "At least one output file must be specified\n");
3254
        exit(1);
3255
    }
3256
    oc = output_files[nb_output_files - 1];
3257

    
3258
    st = av_new_stream(oc, oc->nb_streams);
3259
    if (!st) {
3260
        fprintf(stderr, "Could not alloc stream\n");
3261
        exit(1);
3262
    }
3263

    
3264
    subtitle_enc = st->codec;
3265
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3266
    if (subtitle_stream_copy) {
3267
        st->stream_copy = 1;
3268
    } else {
3269
        for(i=0; i<opt_name_count; i++){
3270
             AVOption *opt;
3271
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3272
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3273
                 av_set_double(subtitle_enc, opt_names[i], d);
3274
        }
3275
        subtitle_enc->codec_id = subtitle_codec_id;
3276
    }
3277

    
3278
    if (subtitle_language) {
3279
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3280
        av_free(subtitle_language);
3281
        subtitle_language = NULL;
3282
    }
3283

    
3284
    subtitle_codec_id = CODEC_ID_NONE;
3285
    subtitle_stream_copy = 0;
3286
}
3287

    
3288
static void opt_new_audio_stream(void)
3289
{
3290
    AVFormatContext *oc;
3291
    if (nb_output_files <= 0) {
3292
        fprintf(stderr, "At least one output file must be specified\n");
3293
        exit(1);
3294
    }
3295
    oc = output_files[nb_output_files - 1];
3296
    new_audio_stream(oc);
3297
}
3298

    
3299
static void opt_new_video_stream(void)
3300
{
3301
    AVFormatContext *oc;
3302
    if (nb_output_files <= 0) {
3303
        fprintf(stderr, "At least one output file must be specified\n");
3304
        exit(1);
3305
    }
3306
    oc = output_files[nb_output_files - 1];
3307
    new_video_stream(oc);
3308
}
3309

    
3310
static void opt_output_file(const char *filename)
3311
{
3312
    AVFormatContext *oc;
3313
    int use_video, use_audio, input_has_video, input_has_audio;
3314
    AVFormatParameters params, *ap = &params;
3315

    
3316
    if (!strcmp(filename, "-"))
3317
        filename = "pipe:";
3318

    
3319
    oc = av_alloc_format_context();
3320

    
3321
    if (!file_oformat) {
3322
        file_oformat = guess_format(NULL, filename, NULL);
3323
        if (!file_oformat) {
3324
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3325
                    filename);
3326
            exit(1);
3327
        }
3328
    }
3329

    
3330
    oc->oformat = file_oformat;
3331
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3332

    
3333
    if (!strcmp(file_oformat->name, "ffm") &&
3334
        strstart(filename, "http:", NULL)) {
3335
        /* special case for files sent to ffserver: we get the stream
3336
           parameters from ffserver */
3337
        if (read_ffserver_streams(oc, filename) < 0) {
3338
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3339
            exit(1);
3340
        }
3341
    } else {
3342
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3343
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3344

    
3345
        /* disable if no corresponding type found and at least one
3346
           input file */
3347
        if (nb_input_files > 0) {
3348
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3349
            if (!input_has_video)
3350
                use_video = 0;
3351
            if (!input_has_audio)
3352
                use_audio = 0;
3353
        }
3354

    
3355
        /* manual disable */
3356
        if (audio_disable) {
3357
            use_audio = 0;
3358
        }
3359
        if (video_disable) {
3360
            use_video = 0;
3361
        }
3362

    
3363
        if (use_video) {
3364
            new_video_stream(oc);
3365
        }
3366

    
3367
        if (use_audio) {
3368
            new_audio_stream(oc);
3369
        }
3370

    
3371
        if (!oc->nb_streams) {
3372
            fprintf(stderr, "No audio or video streams available\n");
3373
            exit(1);
3374
        }
3375

    
3376
        oc->timestamp = rec_timestamp;
3377

    
3378
        if (str_title)
3379
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3380
        if (str_author)
3381
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3382
        if (str_copyright)
3383
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3384
        if (str_comment)
3385
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3386
        if (str_album)
3387
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3388
    }
3389

    
3390
    output_files[nb_output_files++] = oc;
3391

    
3392
    /* check filename in case of an image number is expected */
3393
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3394
        if (!av_filename_number_test(oc->filename)) {
3395
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3396
            exit(1);
3397
        }
3398
    }
3399

    
3400
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3401
        /* test if it already exists to avoid loosing precious files */
3402
        if (!file_overwrite &&
3403
            (strchr(filename, ':') == NULL ||
3404
             strstart(filename, "file:", NULL))) {
3405
            if (url_exist(filename)) {
3406
                int c;
3407

    
3408
                if ( !using_stdin ) {
3409
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3410
                    fflush(stderr);
3411
                    c = getchar();
3412
                    if (toupper(c) != 'Y') {
3413
                        fprintf(stderr, "Not overwriting - exiting\n");
3414
                        exit(1);
3415
                    }
3416
                                }
3417
                                else {
3418
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3419
                    exit(1);
3420
                                }
3421
            }
3422
        }
3423

    
3424
        /* open the file */
3425
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3426
            fprintf(stderr, "Could not open '%s'\n", filename);
3427
            exit(1);
3428
        }
3429
    }
3430

    
3431
    memset(ap, 0, sizeof(*ap));
3432
    ap->image_format = image_format;
3433
    if (av_set_parameters(oc, ap) < 0) {
3434
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3435
                oc->filename);
3436
        exit(1);
3437
    }
3438

    
3439
    oc->packet_size= mux_packet_size;
3440
    oc->mux_rate= mux_rate;
3441
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3442
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3443
    oc->loop_output = loop_output;
3444

    
3445
    /* reset some options */
3446
    file_oformat = NULL;
3447
    file_iformat = NULL;
3448
    image_format = NULL;
3449
}
3450

    
3451
/* prepare dummy protocols for grab */
3452
static void prepare_grab(void)
3453
{
3454
    int has_video, has_audio, i, j;
3455
    AVFormatContext *oc;
3456
    AVFormatContext *ic;
3457
    AVFormatParameters vp1, *vp = &vp1;
3458
    AVFormatParameters ap1, *ap = &ap1;
3459

    
3460
    /* see if audio/video inputs are needed */
3461
    has_video = 0;
3462
    has_audio = 0;
3463
    memset(ap, 0, sizeof(*ap));
3464
    memset(vp, 0, sizeof(*vp));
3465
    vp->time_base.num= 1;
3466
    for(j=0;j<nb_output_files;j++) {
3467
        oc = output_files[j];
3468
        for(i=0;i<oc->nb_streams;i++) {
3469
            AVCodecContext *enc = oc->streams[i]->codec;
3470
            switch(enc->codec_type) {
3471
            case CODEC_TYPE_AUDIO:
3472
                if (enc->sample_rate > ap->sample_rate)
3473
                    ap->sample_rate = enc->sample_rate;
3474
                if (enc->channels > ap->channels)
3475
                    ap->channels = enc->channels;
3476
                has_audio = 1;
3477
                break;
3478
            case CODEC_TYPE_VIDEO:
3479
                if (enc->width > vp->width)
3480
                    vp->width = enc->width;
3481
                if (enc->height > vp->height)
3482
                    vp->height = enc->height;
3483

    
3484
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3485
                    vp->time_base = enc->time_base;
3486
                    vp->width += frame_leftBand + frame_rightBand;
3487
                    vp->width -= (frame_padleft + frame_padright);
3488
                    vp->height += frame_topBand + frame_bottomBand;
3489
                    vp->height -= (frame_padtop + frame_padbottom);
3490
                }
3491
                has_video = 1;
3492
                break;
3493
            default:
3494
                av_abort();
3495
            }
3496
        }
3497
    }
3498

    
3499
    if (has_video == 0 && has_audio == 0) {
3500
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3501
        exit(1);
3502
    }
3503

    
3504
    if (has_video) {
3505
        AVInputFormat *fmt1;
3506
        fmt1 = av_find_input_format(video_grab_format);
3507
        vp->device  = video_device;
3508
        vp->channel = video_channel;
3509
        vp->standard = video_standard;
3510
        vp->pix_fmt = frame_pix_fmt;
3511
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3512
            fprintf(stderr, "Could not find video grab device\n");
3513
            exit(1);
3514
        }
3515
        /* If not enough info to get the stream parameters, we decode the
3516
           first frames to get it. */
3517
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3518
            fprintf(stderr, "Could not find video grab parameters\n");
3519
            exit(1);
3520
        }
3521
        /* by now video grab has one stream */
3522
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3523
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3524
        input_files[nb_input_files] = ic;
3525

    
3526
        if (verbose >= 0)
3527
            dump_format(ic, nb_input_files, "", 0);
3528

    
3529
        nb_input_files++;
3530
    }
3531
    if (has_audio && audio_grab_format) {
3532
        AVInputFormat *fmt1;
3533
        fmt1 = av_find_input_format(audio_grab_format);
3534
        ap->device = audio_device;
3535
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3536
            fprintf(stderr, "Could not find audio grab device\n");
3537
            exit(1);
3538
        }
3539
        input_files[nb_input_files] = ic;
3540

    
3541
        if (verbose >= 0)
3542
            dump_format(ic, nb_input_files, "", 0);
3543

    
3544
        nb_input_files++;
3545
    }
3546
}
3547

    
3548
/* same option as mencoder */
3549
static void opt_pass(const char *pass_str)
3550
{
3551
    int pass;
3552
    pass = atoi(pass_str);
3553
    if (pass != 1 && pass != 2) {
3554
        fprintf(stderr, "pass number can be only 1 or 2\n");
3555
        exit(1);
3556
    }
3557
    do_pass = pass;
3558
}
3559

    
3560
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3561
static int64_t getutime(void)
3562
{
3563
  return av_gettime();
3564
}
3565
#else
3566
static int64_t getutime(void)
3567
{
3568
    struct rusage rusage;
3569

    
3570
    getrusage(RUSAGE_SELF, &rusage);
3571
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3572
}
3573
#endif
3574

    
3575
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3576
extern int ffm_nopts;
3577
#endif
3578

    
3579
static void show_formats(void)
3580
{
3581
    AVInputFormat *ifmt;
3582
    AVOutputFormat *ofmt;
3583
    AVImageFormat *image_fmt;
3584
    URLProtocol *up;
3585
    AVCodec *p, *p2;
3586
    const char **pp, *last_name;
3587

    
3588
    printf("File formats:\n");
3589
    last_name= "000";
3590
    for(;;){
3591
        int decode=0;
3592
        int encode=0;
3593
        const char *name=NULL;
3594
        const char *long_name=NULL;
3595

    
3596
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3597
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3598
                strcmp(ofmt->name, last_name)>0){
3599
                name= ofmt->name;
3600
                long_name= ofmt->long_name;
3601
                encode=1;
3602
            }
3603
        }
3604
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3605
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3606
                strcmp(ifmt->name, last_name)>0){
3607
                name= ifmt->name;
3608
                long_name= ifmt->long_name;
3609
                encode=0;
3610
            }
3611
            if(name && strcmp(ifmt->name, name)==0)
3612
                decode=1;
3613
        }
3614
        if(name==NULL)
3615
            break;
3616
        last_name= name;
3617

    
3618
        printf(
3619
            " %s%s %-15s %s\n",
3620
            decode ? "D":" ",
3621
            encode ? "E":" ",
3622
            name,
3623
            long_name ? long_name:" ");
3624
    }
3625
    printf("\n");
3626

    
3627
    printf("Image formats (filename extensions, if any, follow):\n");
3628
    for(image_fmt = first_image_format; image_fmt != NULL;
3629
        image_fmt = image_fmt->next) {
3630
        printf(
3631
            " %s%s %-6s %s\n",
3632
            image_fmt->img_read  ? "D":" ",
3633
            image_fmt->img_write ? "E":" ",
3634
            image_fmt->name,
3635
            image_fmt->extensions ? image_fmt->extensions:" ");
3636
    }
3637
    printf("\n");
3638

    
3639
    printf("Codecs:\n");
3640
    last_name= "000";
3641
    for(;;){
3642
        int decode=0;
3643
        int encode=0;
3644
        int cap=0;
3645
        const char *type_str;
3646

    
3647
        p2=NULL;
3648
        for(p = first_avcodec; p != NULL; p = p->next) {
3649
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3650
                strcmp(p->name, last_name)>0){
3651
                p2= p;
3652
                decode= encode= cap=0;
3653
            }
3654
            if(p2 && strcmp(p->name, p2->name)==0){
3655
                if(p->decode) decode=1;
3656
                if(p->encode) encode=1;
3657
                cap |= p->capabilities;
3658
            }
3659
        }
3660
        if(p2==NULL)
3661
            break;
3662
        last_name= p2->name;
3663

    
3664
        switch(p2->type) {
3665
        case CODEC_TYPE_VIDEO:
3666
            type_str = "V";
3667
            break;
3668
        case CODEC_TYPE_AUDIO:
3669
            type_str = "A";
3670
            break;
3671
        case CODEC_TYPE_SUBTITLE:
3672
            type_str = "S";
3673
            break;
3674
        default:
3675
            type_str = "?";
3676
            break;
3677
        }
3678
        printf(
3679
            " %s%s%s%s%s%s %s",
3680
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3681
            encode ? "E":" ",
3682
            type_str,
3683
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3684
            cap & CODEC_CAP_DR1 ? "D":" ",
3685
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3686
            p2->name);
3687
       /* if(p2->decoder && decode==0)
3688
            printf(" use %s for decoding", p2->decoder->name);*/
3689
        printf("\n");
3690
    }
3691
    printf("\n");
3692

    
3693
    printf("Supported file protocols:\n");
3694
    for(up = first_protocol; up != NULL; up = up->next)
3695
        printf(" %s:", up->name);
3696
    printf("\n");
3697

    
3698
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3699
    printf("Motion estimation methods:\n");
3700
    pp = motion_str;
3701
    while (*pp) {
3702
        printf(" %s", *pp);
3703
        if ((pp - motion_str + 1) == ME_ZERO)
3704
            printf("(fastest)");
3705
        else if ((pp - motion_str + 1) == ME_FULL)
3706
            printf("(slowest)");
3707
        else if ((pp - motion_str + 1) == ME_EPZS)
3708
            printf("(default)");
3709
        pp++;
3710
    }
3711
    printf("\n\n");
3712
    printf(
3713
"Note, the names of encoders and decoders dont always match, so there are\n"
3714
"several cases where the above table shows encoder only or decoder only entries\n"
3715
"even though both encoding and decoding are supported for example, the h263\n"
3716
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3717
"worse\n");
3718
    exit(1);
3719
}
3720

    
3721
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3722
{
3723
    int i;
3724
    const char *p = str;
3725
    for(i = 0;; i++) {
3726
        dest[i] = atoi(p);
3727
        if(i == 63)
3728
            break;
3729
        p = strchr(p, ',');
3730
        if(!p) {
3731
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3732
            exit(1);
3733
        }
3734
        p++;
3735
    }
3736
}
3737

    
3738
static void opt_inter_matrix(const char *arg)
3739
{
3740
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3741
    parse_matrix_coeffs(inter_matrix, arg);
3742
}
3743

    
3744
static void opt_intra_matrix(const char *arg)
3745
{
3746
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3747
    parse_matrix_coeffs(intra_matrix, arg);
3748
}
3749

    
3750
static void opt_target(const char *arg)
3751
{
3752
    int norm = -1;
3753
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3754

    
3755
    if(!strncmp(arg, "pal-", 4)) {
3756
        norm = 0;
3757
        arg += 4;
3758
    } else if(!strncmp(arg, "ntsc-", 5)) {
3759
        norm = 1;
3760
        arg += 5;
3761
    } else if(!strncmp(arg, "film-", 5)) {
3762
        norm = 2;
3763
        arg += 5;
3764
    } else {
3765
        int fr;
3766
        /* Calculate FR via float to avoid int overflow */
3767
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3768
        if(fr == 25000) {
3769
            norm = 0;
3770
        } else if((fr == 29970) || (fr == 23976)) {
3771
            norm = 1;
3772
        } else {
3773
            /* Try to determine PAL/NTSC by peeking in the input files */
3774
            if(nb_input_files) {
3775
                int i, j;
3776
                for(j = 0; j < nb_input_files; j++) {
3777
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3778
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3779
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3780
                            continue;
3781
                        fr = c->time_base.den * 1000 / c->time_base.num;
3782
                        if(fr == 25000) {
3783
                            norm = 0;
3784
                            break;
3785
                        } else if((fr == 29970) || (fr == 23976)) {
3786
                            norm = 1;
3787
                            break;
3788
                        }
3789
                    }
3790
                    if(norm >= 0)
3791
                        break;
3792
                }
3793
            }
3794
        }
3795
        if(verbose && norm >= 0)
3796
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3797
    }
3798

    
3799
    if(norm < 0) {
3800
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3801
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3802
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3803
        exit(1);
3804
    }
3805

    
3806
    if(!strcmp(arg, "vcd")) {
3807

    
3808
        opt_video_codec("mpeg1video");
3809
        opt_audio_codec("mp2");
3810
        opt_format("vcd");
3811

    
3812
        opt_frame_size(norm ? "352x240" : "352x288");
3813
        opt_frame_rate(frame_rates[norm]);
3814
        opt_gop_size(norm ? "18" : "15");
3815

    
3816
        video_bit_rate = 1150000;
3817
        video_rc_max_rate = 1150000;
3818
        video_rc_min_rate = 1150000;
3819
        video_rc_buffer_size = 40*1024*8;
3820

    
3821
        audio_bit_rate = 224000;
3822
        audio_sample_rate = 44100;
3823

    
3824
        mux_packet_size= 2324;
3825
        mux_rate= 2352 * 75 * 8;
3826

    
3827
        /* We have to offset the PTS, so that it is consistent with the SCR.
3828
           SCR starts at 36000, but the first two packs contain only padding
3829
           and the first pack from the other stream, respectively, may also have
3830
           been written before.
3831
           So the real data starts at SCR 36000+3*1200. */
3832
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3833
    } else if(!strcmp(arg, "svcd")) {
3834

    
3835
        opt_video_codec("mpeg2video");
3836
        opt_audio_codec("mp2");
3837
        opt_format("svcd");
3838

    
3839
        opt_frame_size(norm ? "480x480" : "480x576");
3840
        opt_frame_rate(frame_rates[norm]);
3841
        opt_gop_size(norm ? "18" : "15");
3842

    
3843
        video_bit_rate = 2040000;
3844
        video_rc_max_rate = 2516000;
3845
        video_rc_min_rate = 0; //1145000;
3846
        video_rc_buffer_size = 224*1024*8;
3847
        opt_default("flags", "+SCAN_OFFSET");
3848

    
3849

    
3850
        audio_bit_rate = 224000;
3851
        audio_sample_rate = 44100;
3852

    
3853
        mux_packet_size= 2324;
3854

    
3855
    } else if(!strcmp(arg, "dvd")) {
3856

    
3857
        opt_video_codec("mpeg2video");
3858
        opt_audio_codec("ac3");
3859
        opt_format("dvd");
3860

    
3861
        opt_frame_size(norm ? "720x480" : "720x576");
3862
        opt_frame_rate(frame_rates[norm]);
3863
        opt_gop_size(norm ? "18" : "15");
3864

    
3865
        video_bit_rate = 6000000;
3866
        video_rc_max_rate = 9000000;
3867
        video_rc_min_rate = 0; //1500000;
3868
        video_rc_buffer_size = 224*1024*8;
3869

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

    
3873
        audio_bit_rate = 448000;
3874
        audio_sample_rate = 48000;
3875

    
3876
    } else if(!strncmp(arg, "dv", 2)) {
3877

    
3878
        opt_format("dv");
3879

    
3880
        opt_frame_size(norm ? "720x480" : "720x576");
3881
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3882
                                             (norm ? "yuv411p" : "yuv420p"));
3883
        opt_frame_rate(frame_rates[norm]);
3884

    
3885
        audio_sample_rate = 48000;
3886
        audio_channels = 2;
3887

    
3888
    } else {
3889
        fprintf(stderr, "Unknown target: %s\n", arg);
3890
        exit(1);
3891
    }
3892
}
3893

    
3894
static void opt_video_bsf(const char *arg)
3895
{
3896
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3897
    AVBitStreamFilterContext **bsfp;
3898

    
3899
    if(!bsfc){
3900
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3901
        exit(1);
3902
    }
3903

    
3904
    bsfp= &video_bitstream_filters;
3905
    while(*bsfp)
3906
        bsfp= &(*bsfp)->next;
3907

    
3908
    *bsfp= bsfc;
3909
}
3910

    
3911
//FIXME avoid audio - video code duplication
3912
static void opt_audio_bsf(const char *arg)
3913
{
3914
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3915
    AVBitStreamFilterContext **bsfp;
3916

    
3917
    if(!bsfc){
3918
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3919
        exit(1);
3920
    }
3921

    
3922
    bsfp= &audio_bitstream_filters;
3923
    while(*bsfp)
3924
        bsfp= &(*bsfp)->next;
3925

    
3926
    *bsfp= bsfc;
3927
}
3928

    
3929
static void show_version(void)
3930
{
3931
    /* TODO: add function interface to avutil and avformat */
3932
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3933
           "libavutil   %d\n"
3934
           "libavcodec  %d\n"
3935
           "libavformat %d\n",
3936
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3937
    exit(1);
3938
}
3939

    
3940
static int opt_default(const char *opt, const char *arg){
3941
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3942
    if(!o)
3943
        o = av_set_string(avformat_opts, opt, arg);
3944
    if(!o)
3945
        return -1;
3946

    
3947
//    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));
3948

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

    
3953
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3954
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3955
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3956
        ffm_nopts = 1;
3957
#endif
3958

    
3959
    if(avctx_opts->debug)
3960
        av_log_set_level(AV_LOG_DEBUG);
3961
    return 0;
3962
}
3963

    
3964
const OptionDef options[] = {
3965
    /* main options */
3966
    { "L", 0, {(void*)show_license}, "show license" },
3967
    { "h", 0, {(void*)show_help}, "show help" },
3968
    { "version", 0, {(void*)show_version}, "show version" },
3969
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3970
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3971
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3972
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3973
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3974
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3975
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3976
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3977
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3978
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3979
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3980
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3981
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3982
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3983
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3984
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3985
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3986
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3987
      "add timings for benchmarking" },
3988
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3989
      "dump each input packet" },
3990
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3991
      "when dumping packets, also dump the payload" },
3992
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3993
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3994
    { "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)", "" },
3995
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3996
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3997
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3998
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3999
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4000
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4001
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4002
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4003
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
4004

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

    
4085
    /* audio options */
4086
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4087
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4088
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4089
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4090
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4091
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4092
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4093
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4094
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4095
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4096

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

    
4102
    /* grab options */
4103
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4104
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4105
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4106
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4107

    
4108
    /* G.2 grab options */
4109
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4110
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4111

    
4112
    /* muxer options */
4113
    { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4114
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4115
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4116
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4117

    
4118
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
4119
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
4120

    
4121
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4122
    { NULL, },
4123
};
4124

    
4125
static void show_banner(void)
4126
{
4127
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4128
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
4129
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4130
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4131
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4132
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4133
#ifdef __GNUC__
4134
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
4135
#else
4136
    fprintf(stderr, ", using a non-gcc compiler\n");
4137
#endif
4138
}
4139

    
4140
static void show_license(void)
4141
{
4142
    show_banner();
4143
#ifdef CONFIG_GPL
4144
    printf(
4145
    "This program is free software; you can redistribute it and/or modify\n"
4146
    "it under the terms of the GNU General Public License as published by\n"
4147
    "the Free Software Foundation; either version 2 of the License, or\n"
4148
    "(at your option) any later version.\n"
4149
    "\n"
4150
    "This program is distributed in the hope that it will be useful,\n"
4151
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4152
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
4153
    "GNU General Public License for more details.\n"
4154
    "\n"
4155
    "You should have received a copy of the GNU General Public License\n"
4156
    "along with this program; if not, write to the Free Software\n"
4157
    "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4158
    );
4159
#else
4160
    printf(
4161
    "This library is free software; you can redistribute it and/or\n"
4162
    "modify it under the terms of the GNU Lesser General Public\n"
4163
    "License as published by the Free Software Foundation; either\n"
4164
    "version 2 of the License, or (at your option) any later version.\n"
4165
    "\n"
4166
    "This library is distributed in the hope that it will be useful,\n"
4167
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4168
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
4169
    "Lesser General Public License for more details.\n"
4170
    "\n"
4171
    "You should have received a copy of the GNU Lesser General Public\n"
4172
    "License along with this library; if not, write to the Free Software\n"
4173
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4174
    );
4175
#endif
4176
    exit(1);
4177
}
4178

    
4179
static void show_help(void)
4180
{
4181
    show_banner();
4182
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4183
           "Hyper fast Audio and Video encoder\n");
4184
    printf("\n");
4185
    show_help_options(options, "Main options:\n",
4186
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4187
    show_help_options(options, "\nVideo options:\n",
4188
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4189
                      OPT_VIDEO);
4190
    show_help_options(options, "\nAdvanced Video options:\n",
4191
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4192
                      OPT_VIDEO | OPT_EXPERT);
4193
    show_help_options(options, "\nAudio options:\n",
4194
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4195
                      OPT_AUDIO);
4196
    show_help_options(options, "\nAdvanced Audio options:\n",
4197
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4198
                      OPT_AUDIO | OPT_EXPERT);
4199
    show_help_options(options, "\nSubtitle options:\n",
4200
                      OPT_SUBTITLE | OPT_GRAB,
4201
                      OPT_SUBTITLE);
4202
    show_help_options(options, "\nAudio/Video grab options:\n",
4203
                      OPT_GRAB,
4204
                      OPT_GRAB);
4205
    show_help_options(options, "\nAdvanced options:\n",
4206
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4207
                      OPT_EXPERT);
4208
    av_opt_show(avctx_opts, NULL);
4209
    av_opt_show(avformat_opts, NULL);
4210

    
4211
    exit(1);
4212
}
4213

    
4214
void parse_arg_file(const char *filename)
4215
{
4216
    opt_output_file(filename);
4217
}
4218

    
4219
int main(int argc, char **argv)
4220
{
4221
    int i;
4222
    int64_t ti;
4223

    
4224
    av_register_all();
4225

    
4226
    avctx_opts= avcodec_alloc_context();
4227
    avformat_opts = av_alloc_format_context();
4228

    
4229
    if (argc <= 1)
4230
        show_help();
4231
    else
4232
        show_banner();
4233

    
4234
    /* parse options */
4235
    parse_options(argc, argv, options);
4236

    
4237
    /* file converter / grab */
4238
    if (nb_output_files <= 0) {
4239
        fprintf(stderr, "Must supply at least one output file\n");
4240
        exit(1);
4241
    }
4242

    
4243
    if (nb_input_files == 0) {
4244
        input_sync = 1;
4245
        prepare_grab();
4246
    }
4247

    
4248
    ti = getutime();
4249
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
4250
              stream_maps, nb_stream_maps);
4251
    ti = getutime() - ti;
4252
    if (do_benchmark) {
4253
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4254
    }
4255

    
4256
    /* close files */
4257
    for(i=0;i<nb_output_files;i++) {
4258
        /* maybe av_close_output_file ??? */
4259
        AVFormatContext *s = output_files[i];
4260
        int j;
4261
        if (!(s->oformat->flags & AVFMT_NOFILE))
4262
            url_fclose(&s->pb);
4263
        for(j=0;j<s->nb_streams;j++)
4264
            av_free(s->streams[j]);
4265
        av_free(s);
4266
    }
4267
    for(i=0;i<nb_input_files;i++)
4268
        av_close_input_file(input_files[i]);
4269

    
4270
    av_free_static();
4271

    
4272
    if(intra_matrix)
4273
        av_free(intra_matrix);
4274
    if(inter_matrix)
4275
        av_free(inter_matrix);
4276

    
4277
#ifdef POWERPC_PERFORMANCE_REPORT
4278
    extern void powerpc_display_perf_report(void);
4279
    powerpc_display_perf_report();
4280
#endif /* POWERPC_PERFORMANCE_REPORT */
4281

    
4282
#ifndef __MINGW32__
4283
    if (received_sigterm) {
4284
        fprintf(stderr,
4285
            "Received signal %d: terminating.\n",
4286
            (int) received_sigterm);
4287
        exit (255);
4288
    }
4289
#endif
4290
    exit(0); /* not all OS-es handle main() return value */
4291
    return 0;
4292
}