Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 09a45576

History | View | Annotate | Download (143 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 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 float video_qscale = 0;
109
static int video_qmin = 2;
110
static int video_qmax = 31;
111
static int video_lmin = 2*FF_QP2LAMBDA;
112
static int video_lmax = 31*FF_QP2LAMBDA;
113
static int video_mb_lmin = 2*FF_QP2LAMBDA;
114
static int video_mb_lmax = 31*FF_QP2LAMBDA;
115
static int video_qdiff = 3;
116
static float video_qsquish = 0.0;
117
static uint16_t *intra_matrix = NULL;
118
static uint16_t *inter_matrix = NULL;
119
#if 0 //experimental, (can be removed)
120
static float video_rc_qsquish=1.0;
121
static float video_rc_qmod_amp=0;
122
static int video_rc_qmod_freq=0;
123
#endif
124
static char *video_rc_override_string=NULL;
125
static char *video_rc_eq="tex^qComp";
126
static float video_rc_buffer_aggressivity=1.0;
127
static int me_method = ME_EPZS;
128
static int video_disable = 0;
129
static int video_discard = 0;
130
static int video_codec_id = CODEC_ID_NONE;
131
static int video_codec_tag = 0;
132
static int same_quality = 0;
133
static int b_frames = 0;
134
static int do_deinterlace = 0;
135
static int workaround_bugs = FF_BUG_AUTODETECT;
136
static int packet_size = 0;
137
static int error_rate = 0;
138
static int strict = 0;
139
static int top_field_first = -1;
140
static int sc_threshold = 0;
141
static int me_threshold = 0;
142
static int mb_threshold = 0;
143
static int intra_dc_precision = 8;
144
static int me_penalty_compensation= 256;
145
static int frame_skip_threshold= 0;
146
static int frame_skip_factor= 0;
147
static int frame_skip_exp= 0;
148
static int loop_input = 0;
149
static int loop_output = AVFMT_NOOUTPUTLOOP;
150
static int qp_hist = 0;
151

    
152
static int intra_only = 0;
153
static int audio_sample_rate = 44100;
154
static int audio_bit_rate = 64000;
155
#define QSCALE_NONE -99999
156
static float audio_qscale = QSCALE_NONE;
157
static int audio_disable = 0;
158
static int audio_channels = 1;
159
static int audio_codec_id = CODEC_ID_NONE;
160
static int audio_codec_tag = 0;
161
static char *audio_language = NULL;
162

    
163
static int subtitle_codec_id = CODEC_ID_NONE;
164
static char *subtitle_language = NULL;
165

    
166
static int mux_packet_size= 0;
167
static float mux_preload= 0.5;
168
static float mux_max_delay= 0.7;
169

    
170
static int64_t recording_time = 0;
171
static int64_t start_time = 0;
172
static int64_t rec_timestamp = 0;
173
static int64_t input_ts_offset = 0;
174
static int file_overwrite = 0;
175
static char *str_title = NULL;
176
static char *str_author = NULL;
177
static char *str_copyright = NULL;
178
static char *str_comment = NULL;
179
static char *str_album = NULL;
180
static int do_benchmark = 0;
181
static int do_hex_dump = 0;
182
static int do_pkt_dump = 0;
183
static int do_psnr = 0;
184
static int do_vstats = 0;
185
static int do_pass = 0;
186
static char *pass_logfilename = NULL;
187
static int audio_stream_copy = 0;
188
static int video_stream_copy = 0;
189
static int subtitle_stream_copy = 0;
190
static int video_sync_method= 1;
191
static int audio_sync_method= 0;
192
static int copy_ts= 0;
193
static int opt_shortest = 0; //
194
static int video_global_header = 0;
195

    
196
static int rate_emu = 0;
197

    
198
#ifdef CONFIG_BKTR
199
static const char *video_grab_format = "bktr";
200
#else
201
#ifdef CONFIG_VIDEO4LINUX2
202
static const char *video_grab_format = "video4linux2";
203
#else
204
static const char *video_grab_format = "video4linux";
205
#endif
206
#endif
207
static char *video_device = NULL;
208
static char *grab_device = NULL;
209
static int  video_channel = 0;
210
static char *video_standard = "ntsc";
211

    
212
static const char *audio_grab_format = "audio_device";
213
static char *audio_device = NULL;
214
static int audio_volume = 256;
215

    
216
static int using_stdin = 0;
217
static int using_vhook = 0;
218
static int verbose = 1;
219
static int thread_count= 1;
220
static int q_pressed = 0;
221
static int64_t video_size = 0;
222
static int64_t audio_size = 0;
223
static int64_t extra_size = 0;
224
static int nb_frames_dup = 0;
225
static int nb_frames_drop = 0;
226
static int input_sync;
227
static int limit_filesize = 0; //
228

    
229
static int pgmyuv_compatibility_hack=0;
230
static int dts_delta_threshold = 10;
231

    
232
static int sws_flags = SWS_BICUBIC;
233

    
234
const char **opt_names=NULL;
235
int opt_name_count=0;
236
AVCodecContext *avctx_opts;
237
AVFormatContext *avformat_opts;
238

    
239
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
240
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
241
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
242

    
243
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
244

    
245
struct AVInputStream;
246

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

    
265
    int video_crop;
266
    int topBand;             /* cropping area sizes */
267
    int leftBand;
268

    
269
    int video_pad;
270
    int padtop;              /* padding area sizes */
271
    int padbottom;
272
    int padleft;
273
    int padright;
274

    
275
    /* audio only */
276
    int audio_resample;
277
    ReSampleContext *resample; /* for audio resampling */
278
    FifoBuffer fifo;     /* for compression: one audio fifo per codec */
279
    FILE *logfile;
280
} AVOutputStream;
281

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

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

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

    
307
#ifndef __MINGW32__
308

    
309
/* init terminal so that we can grab keys */
310
static struct termios oldtty;
311

    
312
static void term_exit(void)
313
{
314
    tcsetattr (0, TCSANOW, &oldtty);
315
}
316

    
317
static volatile sig_atomic_t received_sigterm = 0;
318

    
319
static void
320
sigterm_handler(int sig)
321
{
322
    received_sigterm = sig;
323
    term_exit();
324
}
325

    
326
static void term_init(void)
327
{
328
    struct termios tty;
329

    
330
    tcgetattr (0, &tty);
331
    oldtty = tty;
332

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

    
342
    tcsetattr (0, TCSANOW, &tty);
343

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

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

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

    
376
        return n;
377
    }
378
    return -1;
379
}
380

    
381
static int decode_interrupt_cb(void)
382
{
383
    return q_pressed || (q_pressed = read_key() == 'q');
384
}
385

    
386
#else
387

    
388
static volatile int received_sigterm = 0;
389

    
390
/* no interactive support */
391
static void term_exit(void)
392
{
393
}
394

    
395
static void term_init(void)
396
{
397
}
398

    
399
static int read_key(void)
400
{
401
    return 0;
402
}
403

    
404
#endif
405

    
406
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
407
{
408
    int i, err;
409
    AVFormatContext *ic;
410

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

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

    
427
    av_close_input_file(ic);
428
    return 0;
429
}
430

    
431
static double
432
get_sync_ipts(const AVOutputStream *ost)
433
{
434
    const AVInputStream *ist = ost->sync_ist;
435
    return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
436
}
437

    
438
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
439
    while(bsfc){
440
        AVPacket new_pkt= *pkt;
441
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
442
                                          &new_pkt.data, &new_pkt.size,
443
                                          pkt->data, pkt->size,
444
                                          pkt->flags & PKT_FLAG_KEY);
445
        if(a){
446
            av_free_packet(pkt);
447
            new_pkt.destruct= av_destruct_packet;
448
        }
449
        *pkt= new_pkt;
450

    
451
        bsfc= bsfc->next;
452
    }
453

    
454
    av_interleaved_write_frame(s, pkt);
455
}
456

    
457
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
458

    
459
static void do_audio_out(AVFormatContext *s,
460
                         AVOutputStream *ost,
461
                         AVInputStream *ist,
462
                         unsigned char *buf, int size)
463
{
464
    uint8_t *buftmp;
465
    static uint8_t *audio_buf = NULL;
466
    static uint8_t *audio_out = NULL;
467
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
468

    
469
    int size_out, frame_bytes, ret;
470
    AVCodecContext *enc= ost->st->codec;
471

    
472
    /* SC: dynamic allocation of buffers */
473
    if (!audio_buf)
474
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
475
    if (!audio_out)
476
        audio_out = av_malloc(audio_out_size);
477
    if (!audio_buf || !audio_out)
478
        return;               /* Should signal an error ! */
479

    
480
    if(audio_sync_method){
481
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
482
                - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
483
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
484
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
485

    
486
        //FIXME resample delay
487
        if(fabs(delta) > 50){
488
            if(ist->is_start){
489
                if(byte_delta < 0){
490
                    byte_delta= FFMAX(byte_delta, -size);
491
                    size += byte_delta;
492
                    buf  -= byte_delta;
493
                    if(verbose > 2)
494
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
495
                    if(!size)
496
                        return;
497
                    ist->is_start=0;
498
                }else{
499
                    static uint8_t *input_tmp= NULL;
500
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
501

    
502
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
503
                        ist->is_start=0;
504
                    else
505
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
506

    
507
                    memset(input_tmp, 0, byte_delta);
508
                    memcpy(input_tmp + byte_delta, buf, size);
509
                    buf= input_tmp;
510
                    size += byte_delta;
511
                    if(verbose > 2)
512
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
513
                }
514
            }else if(audio_sync_method>1){
515
                int comp= clip(delta, -audio_sync_method, audio_sync_method);
516
                assert(ost->audio_resample);
517
                if(verbose > 2)
518
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
519
//                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));
520
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
521
            }
522
        }
523
    }else
524
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
525
                        - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
526

    
527
    if (ost->audio_resample) {
528
        buftmp = audio_buf;
529
        size_out = audio_resample(ost->resample,
530
                                  (short *)buftmp, (short *)buf,
531
                                  size / (ist->st->codec->channels * 2));
532
        size_out = size_out * enc->channels * 2;
533
    } else {
534
        buftmp = buf;
535
        size_out = size;
536
    }
537

    
538
    /* now encode as many frames as possible */
539
    if (enc->frame_size > 1) {
540
        /* output resampled raw samples */
541
        fifo_write(&ost->fifo, buftmp, size_out,
542
                   &ost->fifo.wptr);
543

    
544
        frame_bytes = enc->frame_size * 2 * enc->channels;
545

    
546
        while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
547
                     &ost->fifo.rptr) == 0) {
548
            AVPacket pkt;
549
            av_init_packet(&pkt);
550

    
551
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
552
                                       (short *)audio_buf);
553
            audio_size += ret;
554
            pkt.stream_index= ost->index;
555
            pkt.data= audio_out;
556
            pkt.size= ret;
557
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
558
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
559
            pkt.flags |= PKT_FLAG_KEY;
560
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
561

    
562
            ost->sync_opts += enc->frame_size;
563
        }
564
    } else {
565
        AVPacket pkt;
566
        av_init_packet(&pkt);
567

    
568
        ost->sync_opts += size_out / (2 * enc->channels);
569

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

    
608
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
609
{
610
    AVCodecContext *dec;
611
    AVPicture *picture2;
612
    AVPicture picture_tmp;
613
    uint8_t *buf = 0;
614

    
615
    dec = ist->st->codec;
616

    
617
    /* deinterlace : must be done before any resize */
618
    if (do_deinterlace || using_vhook) {
619
        int size;
620

    
621
        /* create temporary picture */
622
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
623
        buf = av_malloc(size);
624
        if (!buf)
625
            return;
626

    
627
        picture2 = &picture_tmp;
628
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
629

    
630
        if (do_deinterlace){
631
            if(avpicture_deinterlace(picture2, picture,
632
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
633
                /* if error, do not deinterlace */
634
                av_free(buf);
635
                buf = NULL;
636
                picture2 = picture;
637
            }
638
        } else {
639
            img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
640
        }
641
    } else {
642
        picture2 = picture;
643
    }
644

    
645
    frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
646

    
647
    if (picture != picture2)
648
        *picture = *picture2;
649
    *bufp = buf;
650
}
651

    
652
/* we begin to correct av delay at this threshold */
653
#define AV_DELAY_MAX 0.100
654

    
655
static void do_subtitle_out(AVFormatContext *s,
656
                            AVOutputStream *ost,
657
                            AVInputStream *ist,
658
                            AVSubtitle *sub,
659
                            int64_t pts)
660
{
661
    static uint8_t *subtitle_out = NULL;
662
    int subtitle_out_max_size = 65536;
663
    int subtitle_out_size, nb, i;
664
    AVCodecContext *enc;
665
    AVPacket pkt;
666

    
667
    if (pts == AV_NOPTS_VALUE) {
668
        fprintf(stderr, "Subtitle packets must have a pts\n");
669
        return;
670
    }
671

    
672
    enc = ost->st->codec;
673

    
674
    if (!subtitle_out) {
675
        subtitle_out = av_malloc(subtitle_out_max_size);
676
    }
677

    
678
    /* Note: DVB subtitle need one packet to draw them and one other
679
       packet to clear them */
680
    /* XXX: signal it in the codec context ? */
681
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
682
        nb = 2;
683
    else
684
        nb = 1;
685

    
686
    for(i = 0; i < nb; i++) {
687
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
688
                                                    subtitle_out_max_size, sub);
689

    
690
        av_init_packet(&pkt);
691
        pkt.stream_index = ost->index;
692
        pkt.data = subtitle_out;
693
        pkt.size = subtitle_out_size;
694
        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);
695
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
696
            /* XXX: the pts correction is handled here. Maybe handling
697
               it in the codec would be better */
698
            if (i == 0)
699
                pkt.pts += 90 * sub->start_display_time;
700
            else
701
                pkt.pts += 90 * sub->end_display_time;
702
        }
703
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
704
    }
705
}
706

    
707
static int bit_buffer_size= 1024*256;
708
static uint8_t *bit_buffer= NULL;
709

    
710
static void do_video_out(AVFormatContext *s,
711
                         AVOutputStream *ost,
712
                         AVInputStream *ist,
713
                         AVFrame *in_picture,
714
                         int *frame_size)
715
{
716
    int nb_frames, i, ret;
717
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
718
    AVFrame picture_crop_temp, picture_pad_temp;
719
    uint8_t *buf = NULL, *buf1 = NULL;
720
    AVCodecContext *enc, *dec;
721

    
722
    avcodec_get_frame_defaults(&picture_crop_temp);
723
    avcodec_get_frame_defaults(&picture_pad_temp);
724

    
725
    enc = ost->st->codec;
726
    dec = ist->st->codec;
727

    
728
    /* by default, we output a single frame */
729
    nb_frames = 1;
730

    
731
    *frame_size = 0;
732

    
733
    if(video_sync_method){
734
        double vdelta;
735
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
736
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
737
        if (vdelta < -1.1)
738
            nb_frames = 0;
739
        else if (vdelta > 1.1)
740
            nb_frames = lrintf(vdelta);
741
//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);
742
        if (nb_frames == 0){
743
            ++nb_frames_drop;
744
            if (verbose>2)
745
                fprintf(stderr, "*** drop!\n");
746
        }else if (nb_frames > 1) {
747
            nb_frames_dup += nb_frames;
748
            if (verbose>2)
749
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
750
        }
751
    }else
752
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
753

    
754
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
755
    if (nb_frames <= 0)
756
        return;
757

    
758
    if (ost->video_crop) {
759
        if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
760
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
761
            goto the_end;
762
        }
763
        formatted_picture = &picture_crop_temp;
764
    } else {
765
        formatted_picture = in_picture;
766
    }
767

    
768
    final_picture = formatted_picture;
769
    padding_src = formatted_picture;
770
    resampling_dst = &ost->pict_tmp;
771
    if (ost->video_pad) {
772
        final_picture = &ost->pict_tmp;
773
        if (ost->video_resample) {
774
            if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
775
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
776
                goto the_end;
777
            }
778
            resampling_dst = &picture_pad_temp;
779
        }
780
    }
781

    
782
    if (ost->video_resample) {
783
        padding_src = NULL;
784
        final_picture = &ost->pict_tmp;
785
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
786
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
787
    }
788

    
789
    if (ost->video_pad) {
790
        img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
791
                enc->height, enc->width, enc->pix_fmt,
792
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
793
    }
794

    
795
    /* duplicates frame if needed */
796
    for(i=0;i<nb_frames;i++) {
797
        AVPacket pkt;
798
        av_init_packet(&pkt);
799
        pkt.stream_index= ost->index;
800

    
801
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
802
            /* raw pictures are written as AVPicture structure to
803
               avoid any copies. We support temorarily the older
804
               method. */
805
            AVFrame* old_frame = enc->coded_frame;
806
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
807
            pkt.data= (uint8_t *)final_picture;
808
            pkt.size=  sizeof(AVPicture);
809
            if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
810
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
811
            if(dec->coded_frame && dec->coded_frame->key_frame)
812
                pkt.flags |= PKT_FLAG_KEY;
813

    
814
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
815
            enc->coded_frame = old_frame;
816
        } else {
817
            AVFrame big_picture;
818

    
819
            big_picture= *final_picture;
820
            /* better than nothing: use input picture interlaced
821
               settings */
822
            big_picture.interlaced_frame = in_picture->interlaced_frame;
823
            if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
824
                if(top_field_first == -1)
825
                    big_picture.top_field_first = in_picture->top_field_first;
826
                else
827
                    big_picture.top_field_first = top_field_first;
828
            }
829

    
830
            /* handles sameq here. This is not correct because it may
831
               not be a global option */
832
            if (same_quality) {
833
                big_picture.quality = ist->st->quality;
834
            }else
835
                big_picture.quality = ost->st->quality;
836
            if(!me_threshold)
837
                big_picture.pict_type = 0;
838
//            big_picture.pts = AV_NOPTS_VALUE;
839
            big_picture.pts= ost->sync_opts;
840
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
841
//av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
842
            ret = avcodec_encode_video(enc,
843
                                       bit_buffer, bit_buffer_size,
844
                                       &big_picture);
845
            //enc->frame_number = enc->real_pict_num;
846
            if(ret>0){
847
                pkt.data= bit_buffer;
848
                pkt.size= ret;
849
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
850
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
851
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
852
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
853
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
854

    
855
                if(enc->coded_frame && enc->coded_frame->key_frame)
856
                    pkt.flags |= PKT_FLAG_KEY;
857
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
858
                *frame_size = ret;
859
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
860
                //        enc->frame_number-1, enc->real_pict_num, ret,
861
                //        enc->pict_type);
862
                /* if two pass, output log */
863
                if (ost->logfile && enc->stats_out) {
864
                    fprintf(ost->logfile, "%s", enc->stats_out);
865
                }
866
            }
867
        }
868
        ost->sync_opts++;
869
        ost->frame_number++;
870
    }
871
 the_end:
872
    av_free(buf);
873
    av_free(buf1);
874
}
875

    
876
static double psnr(double d){
877
    if(d==0) return INFINITY;
878
    return -10.0*log(d)/log(10.0);
879
}
880

    
881
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
882
                           int frame_size)
883
{
884
    static FILE *fvstats=NULL;
885
    char filename[40];
886
    time_t today2;
887
    struct tm *today;
888
    AVCodecContext *enc;
889
    int frame_number;
890
    int64_t ti;
891
    double ti1, bitrate, avg_bitrate;
892

    
893
    if (!fvstats) {
894
        today2 = time(NULL);
895
        today = localtime(&today2);
896
        snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
897
                                               today->tm_min,
898
                                               today->tm_sec);
899
        fvstats = fopen(filename,"w");
900
        if (!fvstats) {
901
            perror("fopen");
902
            exit(1);
903
        }
904
    }
905

    
906
    ti = MAXINT64;
907
    enc = ost->st->codec;
908
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
909
        frame_number = ost->frame_number;
910
        fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
911
        if (enc->flags&CODEC_FLAG_PSNR)
912
            fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
913

    
914
        fprintf(fvstats,"f_size= %6d ", frame_size);
915
        /* compute pts value */
916
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
917
        if (ti1 < 0.01)
918
            ti1 = 0.01;
919

    
920
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
921
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
922
        fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
923
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
924
        fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
925
    }
926
}
927

    
928
static void print_report(AVFormatContext **output_files,
929
                         AVOutputStream **ost_table, int nb_ostreams,
930
                         int is_last_report)
931
{
932
    char buf[1024];
933
    AVOutputStream *ost;
934
    AVFormatContext *oc, *os;
935
    int64_t total_size;
936
    AVCodecContext *enc;
937
    int frame_number, vid, i;
938
    double bitrate, ti1, pts;
939
    static int64_t last_time = -1;
940
    static int qp_histogram[52];
941

    
942
    if (!is_last_report) {
943
        int64_t cur_time;
944
        /* display the report every 0.5 seconds */
945
        cur_time = av_gettime();
946
        if (last_time == -1) {
947
            last_time = cur_time;
948
            return;
949
        }
950
        if ((cur_time - last_time) < 500000)
951
            return;
952
        last_time = cur_time;
953
    }
954

    
955

    
956
    oc = output_files[0];
957

    
958
    total_size = url_ftell(&oc->pb);
959

    
960
    buf[0] = '\0';
961
    ti1 = 1e10;
962
    vid = 0;
963
    for(i=0;i<nb_ostreams;i++) {
964
        ost = ost_table[i];
965
        os = output_files[ost->file_index];
966
        enc = ost->st->codec;
967
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
968
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
969
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
970
        }
971
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
972
            frame_number = ost->frame_number;
973
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
974
                    frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
975
            if(is_last_report)
976
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
977
            if(qp_hist && enc->coded_frame){
978
                int j;
979
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
980
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
981
                    qp_histogram[qp]++;
982
                for(j=0; j<32; j++)
983
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
984
            }
985
            if (enc->flags&CODEC_FLAG_PSNR){
986
                int j;
987
                double error, error_sum=0;
988
                double scale, scale_sum=0;
989
                char type[3]= {'Y','U','V'};
990
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
991
                for(j=0; j<3; j++){
992
                    if(is_last_report){
993
                        error= enc->error[j];
994
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
995
                    }else{
996
                        error= enc->coded_frame->error[j];
997
                        scale= enc->width*enc->height*255.0*255.0;
998
                    }
999
                    if(j) scale/=4;
1000
                    error_sum += error;
1001
                    scale_sum += scale;
1002
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1003
                }
1004
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1005
            }
1006
            vid = 1;
1007
        }
1008
        /* compute min output value */
1009
        pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1010
        if ((pts < ti1) && (pts > 0))
1011
            ti1 = pts;
1012
    }
1013
    if (ti1 < 0.01)
1014
        ti1 = 0.01;
1015

    
1016
    if (verbose || is_last_report) {
1017
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1018

    
1019
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1020
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1021
            (double)total_size / 1024, ti1, bitrate);
1022

    
1023
        if (verbose > 1)
1024
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1025
                  nb_frames_dup, nb_frames_drop);
1026

    
1027
        if (verbose >= 0)
1028
            fprintf(stderr, "%s    \r", buf);
1029

    
1030
        fflush(stderr);
1031
    }
1032

    
1033
    if (is_last_report && verbose >= 0){
1034
        int64_t raw= audio_size + video_size + extra_size;
1035
        fprintf(stderr, "\n");
1036
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1037
                video_size/1024.0,
1038
                audio_size/1024.0,
1039
                extra_size/1024.0,
1040
                100.0*(total_size - raw)/raw
1041
        );
1042
    }
1043
}
1044

    
1045
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1046
static int output_packet(AVInputStream *ist, int ist_index,
1047
                         AVOutputStream **ost_table, int nb_ostreams,
1048
                         const AVPacket *pkt)
1049
{
1050
    AVFormatContext *os;
1051
    AVOutputStream *ost;
1052
    uint8_t *ptr;
1053
    int len, ret, i;
1054
    uint8_t *data_buf;
1055
    int data_size, got_picture;
1056
    AVFrame picture;
1057
    void *buffer_to_free;
1058
    static unsigned int samples_size= 0;
1059
    static short *samples= NULL;
1060
    AVSubtitle subtitle, *subtitle_to_free;
1061
    int got_subtitle;
1062

    
1063
    if(!pkt){
1064
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1065
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1066
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1067
    } else {
1068
//        assert(ist->pts == ist->next_pts);
1069
    }
1070

    
1071
    if (pkt == NULL) {
1072
        /* EOF handling */
1073
        ptr = NULL;
1074
        len = 0;
1075
        goto handle_eof;
1076
    }
1077

    
1078
    len = pkt->size;
1079
    ptr = pkt->data;
1080
    while (len > 0) {
1081
    handle_eof:
1082
        /* decode the packet if needed */
1083
        data_buf = NULL; /* fail safe */
1084
        data_size = 0;
1085
        subtitle_to_free = NULL;
1086
        if (ist->decoding_needed) {
1087
            switch(ist->st->codec->codec_type) {
1088
            case CODEC_TYPE_AUDIO:{
1089
                if(pkt)
1090
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1091
                    /* XXX: could avoid copy if PCM 16 bits with same
1092
                       endianness as CPU */
1093
                ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1094
                                           ptr, len);
1095
                if (ret < 0)
1096
                    goto fail_decode;
1097
                ptr += ret;
1098
                len -= ret;
1099
                /* Some bug in mpeg audio decoder gives */
1100
                /* data_size < 0, it seems they are overflows */
1101
                if (data_size <= 0) {
1102
                    /* no audio frame */
1103
                    continue;
1104
                }
1105
                data_buf = (uint8_t *)samples;
1106
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1107
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1108
                break;}
1109
            case CODEC_TYPE_VIDEO:
1110
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1111
                    /* XXX: allocate picture correctly */
1112
                    avcodec_get_frame_defaults(&picture);
1113

    
1114
                    ret = avcodec_decode_video(ist->st->codec,
1115
                                               &picture, &got_picture, ptr, len);
1116
                    ist->st->quality= picture.quality;
1117
                    if (ret < 0)
1118
                        goto fail_decode;
1119
                    if (!got_picture) {
1120
                        /* no picture yet */
1121
                        goto discard_packet;
1122
                    }
1123
                    if (ist->st->codec->time_base.num != 0) {
1124
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1125
                                          ist->st->codec->time_base.num) /
1126
                            ist->st->codec->time_base.den;
1127
                    }
1128
                    len = 0;
1129
                    break;
1130
            case CODEC_TYPE_SUBTITLE:
1131
                ret = avcodec_decode_subtitle(ist->st->codec,
1132
                                              &subtitle, &got_subtitle, ptr, len);
1133
                if (ret < 0)
1134
                    goto fail_decode;
1135
                if (!got_subtitle) {
1136
                    goto discard_packet;
1137
                }
1138
                subtitle_to_free = &subtitle;
1139
                len = 0;
1140
                break;
1141
            default:
1142
                goto fail_decode;
1143
            }
1144
        } else {
1145
                switch(ist->st->codec->codec_type) {
1146
                case CODEC_TYPE_AUDIO:
1147
                    ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1148
                        (ist->st->codec->sample_rate * ist->st->codec->channels);
1149
                    break;
1150
                case CODEC_TYPE_VIDEO:
1151
                    if (ist->st->codec->time_base.num != 0) {
1152
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1153
                                          ist->st->codec->time_base.num) /
1154
                            ist->st->codec->time_base.den;
1155
                    }
1156
                    break;
1157
                }
1158
                data_buf = ptr;
1159
                data_size = len;
1160
                ret = len;
1161
                len = 0;
1162
            }
1163

    
1164
            buffer_to_free = NULL;
1165
            if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1166
                pre_process_video_frame(ist, (AVPicture *)&picture,
1167
                                        &buffer_to_free);
1168
            }
1169

    
1170
            // preprocess audio (volume)
1171
            if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1172
                if (audio_volume != 256) {
1173
                    short *volp;
1174
                    volp = samples;
1175
                    for(i=0;i<(data_size / sizeof(short));i++) {
1176
                        int v = ((*volp) * audio_volume + 128) >> 8;
1177
                        if (v < -32768) v = -32768;
1178
                        if (v >  32767) v = 32767;
1179
                        *volp++ = v;
1180
                    }
1181
                }
1182
            }
1183

    
1184
            /* frame rate emulation */
1185
            if (ist->st->codec->rate_emu) {
1186
                int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1187
                int64_t now = av_gettime() - ist->start;
1188
                if (pts > now)
1189
                    usleep(pts - now);
1190

    
1191
                ist->frame++;
1192
            }
1193

    
1194
#if 0
1195
            /* mpeg PTS deordering : if it is a P or I frame, the PTS
1196
               is the one of the next displayed one */
1197
            /* XXX: add mpeg4 too ? */
1198
            if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1199
                if (ist->st->codec->pict_type != B_TYPE) {
1200
                    int64_t tmp;
1201
                    tmp = ist->last_ip_pts;
1202
                    ist->last_ip_pts  = ist->frac_pts.val;
1203
                    ist->frac_pts.val = tmp;
1204
                }
1205
            }
1206
#endif
1207
            /* if output time reached then transcode raw format,
1208
               encode packets and output them */
1209
            if (start_time == 0 || ist->pts >= start_time)
1210
                for(i=0;i<nb_ostreams;i++) {
1211
                    int frame_size;
1212

    
1213
                    ost = ost_table[i];
1214
                    if (ost->source_index == ist_index) {
1215
                        os = output_files[ost->file_index];
1216

    
1217
#if 0
1218
                        printf("%d: got pts=%0.3f %0.3f\n", i,
1219
                               (double)pkt->pts / AV_TIME_BASE,
1220
                               ((double)ist->pts / AV_TIME_BASE) -
1221
                               ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1222
#endif
1223
                        /* set the input output pts pairs */
1224
                        //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1225

    
1226
                        if (ost->encoding_needed) {
1227
                            switch(ost->st->codec->codec_type) {
1228
                            case CODEC_TYPE_AUDIO:
1229
                                do_audio_out(os, ost, ist, data_buf, data_size);
1230
                                break;
1231
                            case CODEC_TYPE_VIDEO:
1232
                                    do_video_out(os, ost, ist, &picture, &frame_size);
1233
                                    video_size += frame_size;
1234
                                    if (do_vstats && frame_size)
1235
                                        do_video_stats(os, ost, frame_size);
1236
                                break;
1237
                            case CODEC_TYPE_SUBTITLE:
1238
                                do_subtitle_out(os, ost, ist, &subtitle,
1239
                                                pkt->pts);
1240
                                break;
1241
                            default:
1242
                                av_abort();
1243
                            }
1244
                        } else {
1245
                            AVFrame avframe; //FIXME/XXX remove this
1246
                            AVPacket opkt;
1247
                            av_init_packet(&opkt);
1248

    
1249
                            /* no reencoding needed : output the packet directly */
1250
                            /* force the input stream PTS */
1251

    
1252
                            avcodec_get_frame_defaults(&avframe);
1253
                            ost->st->codec->coded_frame= &avframe;
1254
                            avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1255

    
1256
                            if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1257
                                audio_size += data_size;
1258
                            else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1259
                                video_size += data_size;
1260
                                ost->sync_opts++;
1261
                            }
1262

    
1263
                            opkt.stream_index= ost->index;
1264
                            if(pkt->pts != AV_NOPTS_VALUE)
1265
                                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);
1266
                            else
1267
                                opkt.pts= AV_NOPTS_VALUE;
1268

    
1269
                            {
1270
                                int64_t dts;
1271
                                if (pkt->dts == AV_NOPTS_VALUE)
1272
                                    dts = ist->next_pts;
1273
                                else
1274
                                    dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1275
                                opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1276
                            }
1277
                            opkt.flags= pkt->flags;
1278

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

    
1283
                            write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1284
                            ost->st->codec->frame_number++;
1285
                            ost->frame_number++;
1286
                            av_free_packet(&opkt);
1287
                        }
1288
                    }
1289
                }
1290
            av_free(buffer_to_free);
1291
            /* XXX: allocate the subtitles in the codec ? */
1292
            if (subtitle_to_free) {
1293
                if (subtitle_to_free->rects != NULL) {
1294
                    for (i = 0; i < subtitle_to_free->num_rects; i++) {
1295
                        av_free(subtitle_to_free->rects[i].bitmap);
1296
                        av_free(subtitle_to_free->rects[i].rgba_palette);
1297
                    }
1298
                    av_freep(&subtitle_to_free->rects);
1299
                }
1300
                subtitle_to_free->num_rects = 0;
1301
                subtitle_to_free = NULL;
1302
            }
1303
        }
1304
 discard_packet:
1305
    if (pkt == NULL) {
1306
        /* EOF handling */
1307

    
1308
        for(i=0;i<nb_ostreams;i++) {
1309
            ost = ost_table[i];
1310
            if (ost->source_index == ist_index) {
1311
                AVCodecContext *enc= ost->st->codec;
1312
                os = output_files[ost->file_index];
1313

    
1314
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1315
                    continue;
1316
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1317
                    continue;
1318

    
1319
                if (ost->encoding_needed) {
1320
                    for(;;) {
1321
                        AVPacket pkt;
1322
                        int fifo_bytes;
1323
                        av_init_packet(&pkt);
1324
                        pkt.stream_index= ost->index;
1325

    
1326
                        switch(ost->st->codec->codec_type) {
1327
                        case CODEC_TYPE_AUDIO:
1328
                            fifo_bytes = fifo_size(&ost->fifo, NULL);
1329
                            ret = 0;
1330
                            /* encode any samples remaining in fifo */
1331
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1332
                                int fs_tmp = enc->frame_size;
1333
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1334
                                if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1335
                                        &ost->fifo.rptr) == 0) {
1336
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1337
                                }
1338
                                enc->frame_size = fs_tmp;
1339
                            }
1340
                            if(ret <= 0) {
1341
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1342
                            }
1343
                            audio_size += ret;
1344
                            pkt.flags |= PKT_FLAG_KEY;
1345
                            break;
1346
                        case CODEC_TYPE_VIDEO:
1347
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1348
                            video_size += ret;
1349
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1350
                                pkt.flags |= PKT_FLAG_KEY;
1351
                            if (ost->logfile && enc->stats_out) {
1352
                                fprintf(ost->logfile, "%s", enc->stats_out);
1353
                            }
1354
                            break;
1355
                        default:
1356
                            ret=-1;
1357
                        }
1358

    
1359
                        if(ret<=0)
1360
                            break;
1361
                        pkt.data= bit_buffer;
1362
                        pkt.size= ret;
1363
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1364
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1365
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1366
                    }
1367
                }
1368
            }
1369
        }
1370
    }
1371

    
1372
    return 0;
1373
 fail_decode:
1374
    return -1;
1375
}
1376

    
1377

    
1378
/*
1379
 * The following code is the main loop of the file converter
1380
 */
1381
static int av_encode(AVFormatContext **output_files,
1382
                     int nb_output_files,
1383
                     AVFormatContext **input_files,
1384
                     int nb_input_files,
1385
                     AVStreamMap *stream_maps, int nb_stream_maps)
1386
{
1387
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1388
    AVFormatContext *is, *os;
1389
    AVCodecContext *codec, *icodec;
1390
    AVOutputStream *ost, **ost_table = NULL;
1391
    AVInputStream *ist, **ist_table = NULL;
1392
    AVInputFile *file_table;
1393
    AVFormatContext *stream_no_data;
1394
    int key;
1395

    
1396
    file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1397
    if (!file_table)
1398
        goto fail;
1399

    
1400
    /* input stream init */
1401
    j = 0;
1402
    for(i=0;i<nb_input_files;i++) {
1403
        is = input_files[i];
1404
        file_table[i].ist_index = j;
1405
        file_table[i].nb_streams = is->nb_streams;
1406
        j += is->nb_streams;
1407
    }
1408
    nb_istreams = j;
1409

    
1410
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1411
    if (!ist_table)
1412
        goto fail;
1413

    
1414
    for(i=0;i<nb_istreams;i++) {
1415
        ist = av_mallocz(sizeof(AVInputStream));
1416
        if (!ist)
1417
            goto fail;
1418
        ist_table[i] = ist;
1419
    }
1420
    j = 0;
1421
    for(i=0;i<nb_input_files;i++) {
1422
        is = input_files[i];
1423
        for(k=0;k<is->nb_streams;k++) {
1424
            ist = ist_table[j++];
1425
            ist->st = is->streams[k];
1426
            ist->file_index = i;
1427
            ist->index = k;
1428
            ist->discard = 1; /* the stream is discarded by default
1429
                                 (changed later) */
1430

    
1431
            if (ist->st->codec->rate_emu) {
1432
                ist->start = av_gettime();
1433
                ist->frame = 0;
1434
            }
1435
        }
1436
    }
1437

    
1438
    /* output stream init */
1439
    nb_ostreams = 0;
1440
    for(i=0;i<nb_output_files;i++) {
1441
        os = output_files[i];
1442
        nb_ostreams += os->nb_streams;
1443
    }
1444
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1445
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1446
        exit(1);
1447
    }
1448

    
1449
    /* Sanity check the mapping args -- do the input files & streams exist? */
1450
    for(i=0;i<nb_stream_maps;i++) {
1451
        int fi = stream_maps[i].file_index;
1452
        int si = stream_maps[i].stream_index;
1453

    
1454
        if (fi < 0 || fi > nb_input_files - 1 ||
1455
            si < 0 || si > file_table[fi].nb_streams - 1) {
1456
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1457
            exit(1);
1458
        }
1459
        fi = stream_maps[i].sync_file_index;
1460
        si = stream_maps[i].sync_stream_index;
1461
        if (fi < 0 || fi > nb_input_files - 1 ||
1462
            si < 0 || si > file_table[fi].nb_streams - 1) {
1463
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1464
            exit(1);
1465
        }
1466
    }
1467

    
1468
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1469
    if (!ost_table)
1470
        goto fail;
1471
    for(i=0;i<nb_ostreams;i++) {
1472
        ost = av_mallocz(sizeof(AVOutputStream));
1473
        if (!ost)
1474
            goto fail;
1475
        ost_table[i] = ost;
1476
    }
1477

    
1478
    n = 0;
1479
    for(k=0;k<nb_output_files;k++) {
1480
        os = output_files[k];
1481
        for(i=0;i<os->nb_streams;i++) {
1482
            int found;
1483
            ost = ost_table[n++];
1484
            ost->file_index = k;
1485
            ost->index = i;
1486
            ost->st = os->streams[i];
1487
            if (nb_stream_maps > 0) {
1488
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1489
                    stream_maps[n-1].stream_index;
1490

    
1491
                /* Sanity check that the stream types match */
1492
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1493
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1494
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1495
                        ost->file_index, ost->index);
1496
                    exit(1);
1497
                }
1498

    
1499
            } else {
1500
                /* get corresponding input stream index : we select the first one with the right type */
1501
                found = 0;
1502
                for(j=0;j<nb_istreams;j++) {
1503
                    ist = ist_table[j];
1504
                    if (ist->discard &&
1505
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
1506
                        ost->source_index = j;
1507
                        found = 1;
1508
                        break;
1509
                    }
1510
                }
1511

    
1512
                if (!found) {
1513
                    /* try again and reuse existing stream */
1514
                    for(j=0;j<nb_istreams;j++) {
1515
                        ist = ist_table[j];
1516
                        if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1517
                            ost->source_index = j;
1518
                            found = 1;
1519
                        }
1520
                    }
1521
                    if (!found) {
1522
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1523
                                ost->file_index, ost->index);
1524
                        exit(1);
1525
                    }
1526
                }
1527
            }
1528
            ist = ist_table[ost->source_index];
1529
            ist->discard = 0;
1530
            ost->sync_ist = (nb_stream_maps > 0) ?
1531
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1532
                         stream_maps[n-1].sync_stream_index] : ist;
1533
        }
1534
    }
1535

    
1536
    /* for each output stream, we compute the right encoding parameters */
1537
    for(i=0;i<nb_ostreams;i++) {
1538
        ost = ost_table[i];
1539
        ist = ist_table[ost->source_index];
1540

    
1541
        codec = ost->st->codec;
1542
        icodec = ist->st->codec;
1543

    
1544
        if (ost->st->stream_copy) {
1545
            /* if stream_copy is selected, no need to decode or encode */
1546
            codec->codec_id = icodec->codec_id;
1547
            codec->codec_type = icodec->codec_type;
1548
            if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1549
            codec->bit_rate = icodec->bit_rate;
1550
            codec->extradata= icodec->extradata;
1551
            codec->extradata_size= icodec->extradata_size;
1552
            codec->time_base = icodec->time_base;
1553
            switch(codec->codec_type) {
1554
            case CODEC_TYPE_AUDIO:
1555
                codec->sample_rate = icodec->sample_rate;
1556
                codec->channels = icodec->channels;
1557
                codec->frame_size = icodec->frame_size;
1558
                codec->block_align= icodec->block_align;
1559
                break;
1560
            case CODEC_TYPE_VIDEO:
1561
                codec->pix_fmt = icodec->pix_fmt;
1562
                codec->width = icodec->width;
1563
                codec->height = icodec->height;
1564
                codec->has_b_frames = icodec->has_b_frames;
1565
                break;
1566
            case CODEC_TYPE_SUBTITLE:
1567
                break;
1568
            default:
1569
                av_abort();
1570
            }
1571
        } else {
1572
            switch(codec->codec_type) {
1573
            case CODEC_TYPE_AUDIO:
1574
                if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1575
                    goto fail;
1576

    
1577
                if (codec->channels == icodec->channels &&
1578
                    codec->sample_rate == icodec->sample_rate) {
1579
                    ost->audio_resample = 0;
1580
                } else {
1581
                    if (codec->channels != icodec->channels &&
1582
                        (icodec->codec_id == CODEC_ID_AC3 ||
1583
                         icodec->codec_id == CODEC_ID_DTS)) {
1584
                        /* Special case for 5:1 AC3 and DTS input */
1585
                        /* and mono or stereo output      */
1586
                        /* Request specific number of channels */
1587
                        icodec->channels = codec->channels;
1588
                        if (codec->sample_rate == icodec->sample_rate)
1589
                            ost->audio_resample = 0;
1590
                        else {
1591
                            ost->audio_resample = 1;
1592
                        }
1593
                    } else {
1594
                        ost->audio_resample = 1;
1595
                    }
1596
                }
1597
                if(audio_sync_method>1)
1598
                    ost->audio_resample = 1;
1599

    
1600
                if(ost->audio_resample){
1601
                    ost->resample = audio_resample_init(codec->channels, icodec->channels,
1602
                                                    codec->sample_rate, icodec->sample_rate);
1603
                    if(!ost->resample){
1604
                        printf("Can't resample.  Aborting.\n");
1605
                        av_abort();
1606
                    }
1607
                }
1608
                ist->decoding_needed = 1;
1609
                ost->encoding_needed = 1;
1610
                break;
1611
            case CODEC_TYPE_VIDEO:
1612
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1613
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1614
                ost->video_resample = ((codec->width != icodec->width -
1615
                                (frame_leftBand + frame_rightBand) +
1616
                                (frame_padleft + frame_padright)) ||
1617
                        (codec->height != icodec->height -
1618
                                (frame_topBand  + frame_bottomBand) +
1619
                                (frame_padtop + frame_padbottom)) ||
1620
                        (codec->pix_fmt != icodec->pix_fmt));
1621
                if (ost->video_crop) {
1622
                    ost->topBand = frame_topBand;
1623
                    ost->leftBand = frame_leftBand;
1624
                }
1625
                if (ost->video_pad) {
1626
                    ost->padtop = frame_padtop;
1627
                    ost->padleft = frame_padleft;
1628
                    ost->padbottom = frame_padbottom;
1629
                    ost->padright = frame_padright;
1630
                    if (!ost->video_resample) {
1631
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1632
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1633
                                         codec->width, codec->height ) )
1634
                            goto fail;
1635
                    }
1636
                }
1637
                if (ost->video_resample) {
1638
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1639
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1640
                                         codec->width, codec->height ) )
1641
                        goto fail;
1642

    
1643
                    ost->img_resample_ctx = sws_getContext(
1644
                            icodec->width - (frame_leftBand + frame_rightBand),
1645
                            icodec->height - (frame_topBand + frame_bottomBand),
1646
                            icodec->pix_fmt,
1647
                            codec->width - (frame_padleft + frame_padright),
1648
                            codec->height - (frame_padtop + frame_padbottom),
1649
                            codec->pix_fmt,
1650
                            sws_flags, NULL, NULL, NULL);
1651
                    if (ost->img_resample_ctx == NULL) {
1652
                        fprintf(stderr, "Cannot get resampling context\n");
1653
                        exit(1);
1654
                    }
1655
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1656
                }
1657
                ost->encoding_needed = 1;
1658
                ist->decoding_needed = 1;
1659
                break;
1660
            case CODEC_TYPE_SUBTITLE:
1661
                ost->encoding_needed = 1;
1662
                ist->decoding_needed = 1;
1663
                break;
1664
            default:
1665
                av_abort();
1666
                break;
1667
            }
1668
            /* two pass mode */
1669
            if (ost->encoding_needed &&
1670
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1671
                char logfilename[1024];
1672
                FILE *f;
1673
                int size;
1674
                char *logbuffer;
1675

    
1676
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1677
                         pass_logfilename ?
1678
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1679
                if (codec->flags & CODEC_FLAG_PASS1) {
1680
                    f = fopen(logfilename, "w");
1681
                    if (!f) {
1682
                        perror(logfilename);
1683
                        exit(1);
1684
                    }
1685
                    ost->logfile = f;
1686
                } else {
1687
                    /* read the log file */
1688
                    f = fopen(logfilename, "r");
1689
                    if (!f) {
1690
                        perror(logfilename);
1691
                        exit(1);
1692
                    }
1693
                    fseek(f, 0, SEEK_END);
1694
                    size = ftell(f);
1695
                    fseek(f, 0, SEEK_SET);
1696
                    logbuffer = av_malloc(size + 1);
1697
                    if (!logbuffer) {
1698
                        fprintf(stderr, "Could not allocate log buffer\n");
1699
                        exit(1);
1700
                    }
1701
                    size = fread(logbuffer, 1, size, f);
1702
                    fclose(f);
1703
                    logbuffer[size] = '\0';
1704
                    codec->stats_in = logbuffer;
1705
                }
1706
            }
1707
        }
1708
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1709
            int size= codec->width * codec->height;
1710
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1711
        }
1712
    }
1713

    
1714
    if (!bit_buffer)
1715
        bit_buffer = av_malloc(bit_buffer_size);
1716
    if (!bit_buffer)
1717
        goto fail;
1718

    
1719
    /* dump the file output parameters - cannot be done before in case
1720
       of stream copy */
1721
    for(i=0;i<nb_output_files;i++) {
1722
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1723
    }
1724

    
1725
    /* dump the stream mapping */
1726
    if (verbose >= 0) {
1727
        fprintf(stderr, "Stream mapping:\n");
1728
        for(i=0;i<nb_ostreams;i++) {
1729
            ost = ost_table[i];
1730
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1731
                    ist_table[ost->source_index]->file_index,
1732
                    ist_table[ost->source_index]->index,
1733
                    ost->file_index,
1734
                    ost->index);
1735
            if (ost->sync_ist != ist_table[ost->source_index])
1736
                fprintf(stderr, " [sync #%d.%d]",
1737
                        ost->sync_ist->file_index,
1738
                        ost->sync_ist->index);
1739
            fprintf(stderr, "\n");
1740
        }
1741
    }
1742

    
1743
    /* open each encoder */
1744
    for(i=0;i<nb_ostreams;i++) {
1745
        ost = ost_table[i];
1746
        if (ost->encoding_needed) {
1747
            AVCodec *codec;
1748
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1749
            if (!codec) {
1750
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1751
                        ost->file_index, ost->index);
1752
                exit(1);
1753
            }
1754
            if (avcodec_open(ost->st->codec, codec) < 0) {
1755
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1756
                        ost->file_index, ost->index);
1757
                exit(1);
1758
            }
1759
            extra_size += ost->st->codec->extradata_size;
1760
        }
1761
    }
1762

    
1763
    /* open each decoder */
1764
    for(i=0;i<nb_istreams;i++) {
1765
        ist = ist_table[i];
1766
        if (ist->decoding_needed) {
1767
            AVCodec *codec;
1768
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1769
            if (!codec) {
1770
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1771
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1772
                exit(1);
1773
            }
1774
            if (avcodec_open(ist->st->codec, codec) < 0) {
1775
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1776
                        ist->file_index, ist->index);
1777
                exit(1);
1778
            }
1779
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1780
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1781
        }
1782
    }
1783

    
1784
    /* init pts */
1785
    for(i=0;i<nb_istreams;i++) {
1786
        ist = ist_table[i];
1787
        is = input_files[ist->file_index];
1788
        ist->pts = 0;
1789
        ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1790
        if(ist->st->start_time == AV_NOPTS_VALUE)
1791
            ist->next_pts=0;
1792
        if(input_files_ts_offset[ist->file_index])
1793
            ist->next_pts= AV_NOPTS_VALUE;
1794
        ist->is_start = 1;
1795
    }
1796

    
1797
    /* compute buffer size max (should use a complete heuristic) */
1798
    for(i=0;i<nb_input_files;i++) {
1799
        file_table[i].buffer_size_max = 2048;
1800
    }
1801

    
1802
    /* set meta data information from input file if required */
1803
    for (i=0;i<nb_meta_data_maps;i++) {
1804
        AVFormatContext *out_file;
1805
        AVFormatContext *in_file;
1806

    
1807
        int out_file_index = meta_data_maps[i].out_file;
1808
        int in_file_index = meta_data_maps[i].in_file;
1809
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1810
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1811
            ret = -EINVAL;
1812
            goto fail;
1813
        }
1814
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1815
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1816
            ret = -EINVAL;
1817
            goto fail;
1818
        }
1819

    
1820
        out_file = output_files[out_file_index];
1821
        in_file = input_files[in_file_index];
1822

    
1823
        strcpy(out_file->title, in_file->title);
1824
        strcpy(out_file->author, in_file->author);
1825
        strcpy(out_file->copyright, in_file->copyright);
1826
        strcpy(out_file->comment, in_file->comment);
1827
        strcpy(out_file->album, in_file->album);
1828
        out_file->year = in_file->year;
1829
        out_file->track = in_file->track;
1830
        strcpy(out_file->genre, in_file->genre);
1831
    }
1832

    
1833
    /* open files and write file headers */
1834
    for(i=0;i<nb_output_files;i++) {
1835
        os = output_files[i];
1836
        if (av_write_header(os) < 0) {
1837
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1838
            ret = -EINVAL;
1839
            goto fail;
1840
        }
1841
    }
1842

    
1843
#ifndef __MINGW32__
1844
    if ( !using_stdin && verbose >= 0) {
1845
        fprintf(stderr, "Press [q] to stop encoding\n");
1846
        url_set_interrupt_cb(decode_interrupt_cb);
1847
    }
1848
#endif
1849
    term_init();
1850

    
1851
    stream_no_data = 0;
1852
    key = -1;
1853

    
1854
    for(; received_sigterm == 0;) {
1855
        int file_index, ist_index;
1856
        AVPacket pkt;
1857
        double ipts_min;
1858
        double opts_min;
1859

    
1860
    redo:
1861
        ipts_min= 1e100;
1862
        opts_min= 1e100;
1863
        /* if 'q' pressed, exits */
1864
        if (!using_stdin) {
1865
            if (q_pressed)
1866
                break;
1867
            /* read_key() returns 0 on EOF */
1868
            key = read_key();
1869
            if (key == 'q')
1870
                break;
1871
        }
1872

    
1873
        /* select the stream that we must read now by looking at the
1874
           smallest output pts */
1875
        file_index = -1;
1876
        for(i=0;i<nb_ostreams;i++) {
1877
            double ipts, opts;
1878
            ost = ost_table[i];
1879
            os = output_files[ost->file_index];
1880
            ist = ist_table[ost->source_index];
1881
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1882
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1883
            else
1884
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1885
            ipts = (double)ist->pts;
1886
            if (!file_table[ist->file_index].eof_reached){
1887
                if(ipts < ipts_min) {
1888
                    ipts_min = ipts;
1889
                    if(input_sync ) file_index = ist->file_index;
1890
                }
1891
                if(opts < opts_min) {
1892
                    opts_min = opts;
1893
                    if(!input_sync) file_index = ist->file_index;
1894
                }
1895
            }
1896
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1897
                file_index= -1;
1898
                break;
1899
            }
1900
        }
1901
        /* if none, if is finished */
1902
        if (file_index < 0) {
1903
            break;
1904
        }
1905

    
1906
        /* finish if recording time exhausted */
1907
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1908
            break;
1909

    
1910
        /* finish if limit size exhausted */
1911
        if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1912
            break;
1913

    
1914
        /* read a frame from it and output it in the fifo */
1915
        is = input_files[file_index];
1916
        if (av_read_frame(is, &pkt) < 0) {
1917
            file_table[file_index].eof_reached = 1;
1918
            if (opt_shortest) break; else continue; //
1919
        }
1920

    
1921
        if (!pkt.size) {
1922
            stream_no_data = is;
1923
        } else {
1924
            stream_no_data = 0;
1925
        }
1926
        if (do_pkt_dump) {
1927
            av_pkt_dump(stdout, &pkt, do_hex_dump);
1928
        }
1929
        /* the following test is needed in case new streams appear
1930
           dynamically in stream : we ignore them */
1931
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1932
            goto discard_packet;
1933
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1934
        ist = ist_table[ist_index];
1935
        if (ist->discard)
1936
            goto discard_packet;
1937

    
1938
//        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);
1939
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1940
            int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1941
            if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1942
                input_files_ts_offset[ist->file_index]-= delta;
1943
                if (verbose > 2)
1944
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1945
                for(i=0; i<file_table[file_index].nb_streams; i++){
1946
                    int index= file_table[file_index].ist_index + i;
1947
                    ist_table[index]->next_pts += delta;
1948
                    ist_table[index]->is_start=1;
1949
                }
1950
            }
1951
        }
1952

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

    
1956
            if (verbose >= 0)
1957
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1958
                        ist->file_index, ist->index);
1959

    
1960
            av_free_packet(&pkt);
1961
            goto redo;
1962
        }
1963

    
1964
    discard_packet:
1965
        av_free_packet(&pkt);
1966

    
1967
        /* dump report by using the output first video and audio streams */
1968
        print_report(output_files, ost_table, nb_ostreams, 0);
1969
    }
1970

    
1971
    /* at the end of stream, we must flush the decoder buffers */
1972
    for(i=0;i<nb_istreams;i++) {
1973
        ist = ist_table[i];
1974
        if (ist->decoding_needed) {
1975
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
1976
        }
1977
    }
1978

    
1979
    term_exit();
1980

    
1981
    /* write the trailer if needed and close file */
1982
    for(i=0;i<nb_output_files;i++) {
1983
        os = output_files[i];
1984
        av_write_trailer(os);
1985
    }
1986

    
1987
    /* dump report by using the first video and audio streams */
1988
    print_report(output_files, ost_table, nb_ostreams, 1);
1989

    
1990
    /* close each encoder */
1991
    for(i=0;i<nb_ostreams;i++) {
1992
        ost = ost_table[i];
1993
        if (ost->encoding_needed) {
1994
            av_freep(&ost->st->codec->stats_in);
1995
            avcodec_close(ost->st->codec);
1996
        }
1997
    }
1998

    
1999
    /* close each decoder */
2000
    for(i=0;i<nb_istreams;i++) {
2001
        ist = ist_table[i];
2002
        if (ist->decoding_needed) {
2003
            avcodec_close(ist->st->codec);
2004
        }
2005
    }
2006

    
2007
    /* finished ! */
2008

    
2009
    ret = 0;
2010
 fail1:
2011
    av_freep(&bit_buffer);
2012
    av_free(file_table);
2013

    
2014
    if (ist_table) {
2015
        for(i=0;i<nb_istreams;i++) {
2016
            ist = ist_table[i];
2017
            av_free(ist);
2018
        }
2019
        av_free(ist_table);
2020
    }
2021
    if (ost_table) {
2022
        for(i=0;i<nb_ostreams;i++) {
2023
            ost = ost_table[i];
2024
            if (ost) {
2025
                if (ost->logfile) {
2026
                    fclose(ost->logfile);
2027
                    ost->logfile = NULL;
2028
                }
2029
                fifo_free(&ost->fifo); /* works even if fifo is not
2030
                                          initialized but set to zero */
2031
                av_free(ost->pict_tmp.data[0]);
2032
                if (ost->video_resample)
2033
                    sws_freeContext(ost->img_resample_ctx);
2034
                if (ost->audio_resample)
2035
                    audio_resample_close(ost->resample);
2036
                av_free(ost);
2037
            }
2038
        }
2039
        av_free(ost_table);
2040
    }
2041
    return ret;
2042
 fail:
2043
    ret = -ENOMEM;
2044
    goto fail1;
2045
}
2046

    
2047
#if 0
2048
int file_read(const char *filename)
2049
{
2050
    URLContext *h;
2051
    unsigned char buffer[1024];
2052
    int len, i;
2053

2054
    if (url_open(&h, filename, O_RDONLY) < 0) {
2055
        printf("could not open '%s'\n", filename);
2056
        return -1;
2057
    }
2058
    for(;;) {
2059
        len = url_read(h, buffer, sizeof(buffer));
2060
        if (len <= 0)
2061
            break;
2062
        for(i=0;i<len;i++) putchar(buffer[i]);
2063
    }
2064
    url_close(h);
2065
    return 0;
2066
}
2067
#endif
2068

    
2069
static void opt_image_format(const char *arg)
2070
{
2071
    AVImageFormat *f;
2072

    
2073
    for(f = first_image_format; f != NULL; f = f->next) {
2074
        if (!strcmp(arg, f->name))
2075
            break;
2076
    }
2077
    if (!f) {
2078
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
2079
        exit(1);
2080
    }
2081
    image_format = f;
2082
}
2083

    
2084
static void opt_format(const char *arg)
2085
{
2086
    /* compatibility stuff for pgmyuv */
2087
    if (!strcmp(arg, "pgmyuv")) {
2088
        pgmyuv_compatibility_hack=1;
2089
//        opt_image_format(arg);
2090
        arg = "image2";
2091
    }
2092

    
2093
    file_iformat = av_find_input_format(arg);
2094
    file_oformat = guess_format(arg, NULL, NULL);
2095
    if (!file_iformat && !file_oformat) {
2096
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2097
        exit(1);
2098
    }
2099
}
2100

    
2101
static void opt_video_rc_eq(char *arg)
2102
{
2103
    video_rc_eq = arg;
2104
}
2105

    
2106
static void opt_video_rc_override_string(char *arg)
2107
{
2108
    video_rc_override_string = arg;
2109
}
2110

    
2111

    
2112
static void opt_workaround_bugs(const char *arg)
2113
{
2114
    workaround_bugs = atoi(arg);
2115
}
2116

    
2117
static void opt_me_threshold(const char *arg)
2118
{
2119
    me_threshold = atoi(arg);
2120
}
2121

    
2122
static void opt_mb_threshold(const char *arg)
2123
{
2124
    mb_threshold = atoi(arg);
2125
}
2126

    
2127
static void opt_verbose(const char *arg)
2128
{
2129
    verbose = atoi(arg);
2130
    av_log_set_level(atoi(arg));
2131
}
2132

    
2133
static void opt_frame_rate(const char *arg)
2134
{
2135
    if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2136
        fprintf(stderr, "Incorrect frame rate\n");
2137
        exit(1);
2138
    }
2139
}
2140

    
2141
static void opt_frame_crop_top(const char *arg)
2142
{
2143
    frame_topBand = atoi(arg);
2144
    if (frame_topBand < 0) {
2145
        fprintf(stderr, "Incorrect top crop size\n");
2146
        exit(1);
2147
    }
2148
    if ((frame_topBand % 2) != 0) {
2149
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2150
        exit(1);
2151
    }
2152
    if ((frame_topBand) >= frame_height){
2153
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2154
        exit(1);
2155
    }
2156
    frame_height -= frame_topBand;
2157
}
2158

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

    
2177
static void opt_frame_crop_left(const char *arg)
2178
{
2179
    frame_leftBand = atoi(arg);
2180
    if (frame_leftBand < 0) {
2181
        fprintf(stderr, "Incorrect left crop size\n");
2182
        exit(1);
2183
    }
2184
    if ((frame_leftBand % 2) != 0) {
2185
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2186
        exit(1);
2187
    }
2188
    if ((frame_leftBand) >= frame_width){
2189
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2190
        exit(1);
2191
    }
2192
    frame_width -= frame_leftBand;
2193
}
2194

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

    
2213
static void opt_frame_size(const char *arg)
2214
{
2215
    if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2216
        fprintf(stderr, "Incorrect frame size\n");
2217
        exit(1);
2218
    }
2219
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2220
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2221
        exit(1);
2222
    }
2223
}
2224

    
2225

    
2226
#define SCALEBITS 10
2227
#define ONE_HALF  (1 << (SCALEBITS - 1))
2228
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2229

    
2230
#define RGB_TO_Y(r, g, b) \
2231
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2232
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2233

    
2234
#define RGB_TO_U(r1, g1, b1, shift)\
2235
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2236
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2237

    
2238
#define RGB_TO_V(r1, g1, b1, shift)\
2239
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2240
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2241

    
2242
static void opt_pad_color(const char *arg) {
2243
    /* Input is expected to be six hex digits similar to
2244
       how colors are expressed in html tags (but without the #) */
2245
    int rgb = strtol(arg, NULL, 16);
2246
    int r,g,b;
2247

    
2248
    r = (rgb >> 16);
2249
    g = ((rgb >> 8) & 255);
2250
    b = (rgb & 255);
2251

    
2252
    padcolor[0] = RGB_TO_Y(r,g,b);
2253
    padcolor[1] = RGB_TO_U(r,g,b,0);
2254
    padcolor[2] = RGB_TO_V(r,g,b,0);
2255
}
2256

    
2257
static void opt_frame_pad_top(const char *arg)
2258
{
2259
    frame_padtop = atoi(arg);
2260
    if (frame_padtop < 0) {
2261
        fprintf(stderr, "Incorrect top pad size\n");
2262
        exit(1);
2263
    }
2264
    if ((frame_padtop % 2) != 0) {
2265
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2266
        exit(1);
2267
    }
2268
}
2269

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

    
2283

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

    
2297

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

    
2311

    
2312
static void opt_frame_pix_fmt(const char *arg)
2313
{
2314
    frame_pix_fmt = avcodec_get_pix_fmt(arg);
2315
}
2316

    
2317
static void opt_frame_aspect_ratio(const char *arg)
2318
{
2319
    int x = 0, y = 0;
2320
    double ar = 0;
2321
    const char *p;
2322

    
2323
    p = strchr(arg, ':');
2324
    if (p) {
2325
        x = strtol(arg, (char **)&arg, 10);
2326
        if (arg == p)
2327
            y = strtol(arg+1, (char **)&arg, 10);
2328
        if (x > 0 && y > 0)
2329
            ar = (double)x / (double)y;
2330
    } else
2331
        ar = strtod(arg, (char **)&arg);
2332

    
2333
    if (!ar) {
2334
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2335
        exit(1);
2336
    }
2337
    frame_aspect_ratio = ar;
2338
}
2339

    
2340
static void opt_b_frames(const char *arg)
2341
{
2342
    b_frames = atoi(arg);
2343
    if (b_frames > FF_MAX_B_FRAMES) {
2344
        fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2345
        exit(1);
2346
    } else if (b_frames < 1) {
2347
        fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2348
        exit(1);
2349
    }
2350
}
2351

    
2352
static void opt_qscale(const char *arg)
2353
{
2354
    video_qscale = atof(arg);
2355
    if (video_qscale <= 0 ||
2356
        video_qscale > 255) {
2357
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2358
        exit(1);
2359
    }
2360
}
2361

    
2362
static void opt_qsquish(const char *arg)
2363
{
2364
    video_qsquish = atof(arg);
2365
    if (video_qsquish < 0.0 ||
2366
        video_qsquish > 99.0) {
2367
        fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2368
        exit(1);
2369
    }
2370
}
2371

    
2372
static void opt_lmax(const char *arg)
2373
{
2374
    video_lmax = atof(arg)*FF_QP2LAMBDA;
2375
}
2376

    
2377
static void opt_lmin(const char *arg)
2378
{
2379
    video_lmin = atof(arg)*FF_QP2LAMBDA;
2380
}
2381

    
2382
static void opt_qmin(const char *arg)
2383
{
2384
    video_qmin = atoi(arg);
2385
    if (video_qmin < 1 ||
2386
        video_qmin > 51) {
2387
        fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2388
        exit(1);
2389
    }
2390
}
2391

    
2392
static void opt_qmax(const char *arg)
2393
{
2394
    video_qmax = atoi(arg);
2395
    if (video_qmax < 1 ||
2396
        video_qmax > 51) {
2397
        fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2398
        exit(1);
2399
    }
2400
}
2401

    
2402
static void opt_mb_lmin(const char *arg)
2403
{
2404
    video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2405
    if (video_mb_lmin < 1 ||
2406
        video_mb_lmin > FF_LAMBDA_MAX) {
2407
        fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2408
        exit(1);
2409
    }
2410
}
2411

    
2412
static void opt_mb_lmax(const char *arg)
2413
{
2414
    video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2415
    if (video_mb_lmax < 1 ||
2416
        video_mb_lmax > FF_LAMBDA_MAX) {
2417
        fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2418
        exit(1);
2419
    }
2420
}
2421

    
2422
static void opt_qdiff(const char *arg)
2423
{
2424
    video_qdiff = atoi(arg);
2425
    if (video_qdiff < 0 ||
2426
        video_qdiff > 31) {
2427
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2428
        exit(1);
2429
    }
2430
}
2431

    
2432
static void opt_packet_size(const char *arg)
2433
{
2434
    packet_size= atoi(arg);
2435
}
2436

    
2437
static void opt_error_rate(const char *arg)
2438
{
2439
    error_rate= atoi(arg);
2440
}
2441

    
2442
static void opt_strict(const char *arg)
2443
{
2444
    strict= atoi(arg);
2445
}
2446

    
2447
static void opt_top_field_first(const char *arg)
2448
{
2449
    top_field_first= atoi(arg);
2450
}
2451

    
2452
static void opt_sc_threshold(const char *arg)
2453
{
2454
    sc_threshold= atoi(arg);
2455
}
2456

    
2457
static void opt_thread_count(const char *arg)
2458
{
2459
    thread_count= atoi(arg);
2460
#if !defined(HAVE_THREADS)
2461
    if (verbose >= 0)
2462
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2463
#endif
2464
}
2465

    
2466
static void opt_audio_bitrate(const char *arg)
2467
{
2468
    audio_bit_rate = atoi(arg) * 1000;
2469
}
2470

    
2471
static void opt_audio_rate(const char *arg)
2472
{
2473
    audio_sample_rate = atoi(arg);
2474
}
2475

    
2476
static void opt_audio_channels(const char *arg)
2477
{
2478
    audio_channels = atoi(arg);
2479
}
2480

    
2481
static void opt_video_device(const char *arg)
2482
{
2483
    video_device = av_strdup(arg);
2484
}
2485

    
2486
static void opt_grab_device(const char *arg)
2487
{
2488
    grab_device = av_strdup(arg);
2489
}
2490

    
2491
static void opt_video_channel(const char *arg)
2492
{
2493
    video_channel = strtol(arg, NULL, 0);
2494
}
2495

    
2496
static void opt_video_standard(const char *arg)
2497
{
2498
    video_standard = av_strdup(arg);
2499
}
2500

    
2501
static void opt_audio_device(const char *arg)
2502
{
2503
    audio_device = av_strdup(arg);
2504
}
2505

    
2506
static void opt_codec(int *pstream_copy, int *pcodec_id,
2507
                      int codec_type, const char *arg)
2508
{
2509
    AVCodec *p;
2510

    
2511
    if (!strcmp(arg, "copy")) {
2512
        *pstream_copy = 1;
2513
    } else {
2514
        p = first_avcodec;
2515
        while (p) {
2516
            if (!strcmp(p->name, arg) && p->type == codec_type)
2517
                break;
2518
            p = p->next;
2519
        }
2520
        if (p == NULL) {
2521
            fprintf(stderr, "Unknown codec '%s'\n", arg);
2522
            exit(1);
2523
        } else {
2524
            *pcodec_id = p->id;
2525
        }
2526
    }
2527
}
2528

    
2529
static void opt_audio_codec(const char *arg)
2530
{
2531
    opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2532
}
2533

    
2534
static void opt_audio_tag(const char *arg)
2535
{
2536
    char *tail;
2537
    audio_codec_tag= strtol(arg, &tail, 0);
2538

    
2539
    if(!tail || *tail)
2540
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2541
}
2542

    
2543
static void opt_video_tag(const char *arg)
2544
{
2545
    char *tail;
2546
    video_codec_tag= strtol(arg, &tail, 0);
2547

    
2548
    if(!tail || *tail)
2549
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2550
}
2551

    
2552
static void add_frame_hooker(const char *arg)
2553
{
2554
    int argc = 0;
2555
    char *argv[64];
2556
    int i;
2557
    char *args = av_strdup(arg);
2558

    
2559
    using_vhook = 1;
2560

    
2561
    argv[0] = strtok(args, " ");
2562
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2563
    }
2564

    
2565
    i = frame_hook_add(argc, argv);
2566

    
2567
    if (i != 0) {
2568
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2569
        exit(1);
2570
    }
2571
}
2572

    
2573
const char *motion_str[] = {
2574
    "zero",
2575
    "full",
2576
    "log",
2577
    "phods",
2578
    "epzs",
2579
    "x1",
2580
    "hex",
2581
    "umh",
2582
    "iter",
2583
    NULL,
2584
};
2585

    
2586
static void opt_motion_estimation(const char *arg)
2587
{
2588
    const char **p;
2589
    p = motion_str;
2590
    for(;;) {
2591
        if (!*p) {
2592
            fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2593
            exit(1);
2594
        }
2595
        if (!strcmp(*p, arg))
2596
            break;
2597
        p++;
2598
    }
2599
    me_method = (p - motion_str) + 1;
2600
}
2601

    
2602
static void opt_video_codec(const char *arg)
2603
{
2604
    opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2605
}
2606

    
2607
static void opt_subtitle_codec(const char *arg)
2608
{
2609
    opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2610
}
2611

    
2612
static void opt_map(const char *arg)
2613
{
2614
    AVStreamMap *m;
2615
    const char *p;
2616

    
2617
    p = arg;
2618
    m = &stream_maps[nb_stream_maps++];
2619

    
2620
    m->file_index = strtol(arg, (char **)&p, 0);
2621
    if (*p)
2622
        p++;
2623

    
2624
    m->stream_index = strtol(p, (char **)&p, 0);
2625
    if (*p) {
2626
        p++;
2627
        m->sync_file_index = strtol(p, (char **)&p, 0);
2628
        if (*p)
2629
            p++;
2630
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2631
    } else {
2632
        m->sync_file_index = m->file_index;
2633
        m->sync_stream_index = m->stream_index;
2634
    }
2635
}
2636

    
2637
static void opt_map_meta_data(const char *arg)
2638
{
2639
    AVMetaDataMap *m;
2640
    const char *p;
2641

    
2642
    p = arg;
2643
    m = &meta_data_maps[nb_meta_data_maps++];
2644

    
2645
    m->out_file = strtol(arg, (char **)&p, 0);
2646
    if (*p)
2647
        p++;
2648

    
2649
    m->in_file = strtol(p, (char **)&p, 0);
2650
}
2651

    
2652
static void opt_recording_time(const char *arg)
2653
{
2654
    recording_time = parse_date(arg, 1);
2655
}
2656

    
2657
static void opt_start_time(const char *arg)
2658
{
2659
    start_time = parse_date(arg, 1);
2660
}
2661

    
2662
static void opt_rec_timestamp(const char *arg)
2663
{
2664
    rec_timestamp = parse_date(arg, 0) / 1000000;
2665
}
2666

    
2667
static void opt_input_ts_offset(const char *arg)
2668
{
2669
    input_ts_offset = parse_date(arg, 1);
2670
}
2671

    
2672
static void opt_input_file(const char *filename)
2673
{
2674
    AVFormatContext *ic;
2675
    AVFormatParameters params, *ap = &params;
2676
    int err, i, ret, rfps, rfps_base;
2677
    int64_t timestamp;
2678

    
2679
    if (!strcmp(filename, "-"))
2680
        filename = "pipe:";
2681

    
2682
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2683
                   !strcmp( filename, "/dev/stdin" );
2684

    
2685
    /* get default parameters from command line */
2686
    ic = av_alloc_format_context();
2687

    
2688
    memset(ap, 0, sizeof(*ap));
2689
    ap->prealloced_context = 1;
2690
    ap->sample_rate = audio_sample_rate;
2691
    ap->channels = audio_channels;
2692
    ap->time_base.den = frame_rate;
2693
    ap->time_base.num = frame_rate_base;
2694
    ap->width = frame_width + frame_padleft + frame_padright;
2695
    ap->height = frame_height + frame_padtop + frame_padbottom;
2696
    ap->image_format = image_format;
2697
    ap->pix_fmt = frame_pix_fmt;
2698
    ap->device  = grab_device;
2699
    ap->channel = video_channel;
2700
    ap->standard = video_standard;
2701
    ap->video_codec_id = video_codec_id;
2702
    ap->audio_codec_id = audio_codec_id;
2703
    if(pgmyuv_compatibility_hack)
2704
        ap->video_codec_id= CODEC_ID_PGMYUV;
2705

    
2706
    for(i=0; i<opt_name_count; i++){
2707
        AVOption *opt;
2708
        double d= av_get_double(avformat_opts, opt_names[i], &opt);
2709
        if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2710
            av_set_double(ic, opt_names[i], d);
2711
    }
2712
    /* open the input file with generic libav function */
2713
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2714
    if (err < 0) {
2715
        print_error(filename, err);
2716
        exit(1);
2717
    }
2718

    
2719
    ic->loop_input = loop_input;
2720

    
2721
    /* If not enough info to get the stream parameters, we decode the
2722
       first frames to get it. (used in mpeg case for example) */
2723
    ret = av_find_stream_info(ic);
2724
    if (ret < 0 && verbose >= 0) {
2725
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2726
        exit(1);
2727
    }
2728

    
2729
    timestamp = start_time;
2730
    /* add the stream start time */
2731
    if (ic->start_time != AV_NOPTS_VALUE)
2732
        timestamp += ic->start_time;
2733

    
2734
    /* if seeking requested, we execute it */
2735
    if (start_time != 0) {
2736
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2737
        if (ret < 0) {
2738
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2739
                    filename, (double)timestamp / AV_TIME_BASE);
2740
        }
2741
        /* reset seek info */
2742
        start_time = 0;
2743
    }
2744

    
2745
    /* update the current parameters so that they match the one of the input stream */
2746
    for(i=0;i<ic->nb_streams;i++) {
2747
        int j;
2748
        AVCodecContext *enc = ic->streams[i]->codec;
2749
#if defined(HAVE_THREADS)
2750
        if(thread_count>1)
2751
            avcodec_thread_init(enc, thread_count);
2752
#endif
2753
        enc->thread_count= thread_count;
2754
        switch(enc->codec_type) {
2755
        case CODEC_TYPE_AUDIO:
2756
            for(j=0; j<opt_name_count; j++){
2757
                AVOption *opt;
2758
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2759
                if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2760
                    av_set_double(enc, opt_names[j], d);
2761
            }
2762
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2763
            audio_channels = enc->channels;
2764
            audio_sample_rate = enc->sample_rate;
2765
            if(audio_disable)
2766
                ic->streams[i]->discard= AVDISCARD_ALL;
2767
            break;
2768
        case CODEC_TYPE_VIDEO:
2769
            for(j=0; j<opt_name_count; j++){
2770
                AVOption *opt;
2771
                double d= av_get_double(avctx_opts, opt_names[j], &opt);
2772
                if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2773
                    av_set_double(enc, opt_names[j], d);
2774
            }
2775
            frame_height = enc->height;
2776
            frame_width = enc->width;
2777
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2778
            frame_pix_fmt = enc->pix_fmt;
2779
            rfps      = ic->streams[i]->r_frame_rate.num;
2780
            rfps_base = ic->streams[i]->r_frame_rate.den;
2781
            enc->workaround_bugs = workaround_bugs;
2782
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2783
            if(me_threshold)
2784
                enc->debug |= FF_DEBUG_MV;
2785

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

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

    
2792
                    (float)rfps / rfps_base, rfps, rfps_base);
2793
            }
2794
            /* update the current frame rate to match the stream frame rate */
2795
            frame_rate      = rfps;
2796
            frame_rate_base = rfps_base;
2797

    
2798
            enc->rate_emu = rate_emu;
2799
            if(video_disable)
2800
                ic->streams[i]->discard= AVDISCARD_ALL;
2801
            else if(video_discard)
2802
                ic->streams[i]->discard= video_discard;
2803
            break;
2804
        case CODEC_TYPE_DATA:
2805
            break;
2806
        case CODEC_TYPE_SUBTITLE:
2807
            break;
2808
        case CODEC_TYPE_UNKNOWN:
2809
            break;
2810
        default:
2811
            av_abort();
2812
        }
2813
    }
2814

    
2815
    input_files[nb_input_files] = ic;
2816
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2817
    /* dump the file content */
2818
    if (verbose >= 0)
2819
        dump_format(ic, nb_input_files, filename, 0);
2820

    
2821
    nb_input_files++;
2822
    file_iformat = NULL;
2823
    file_oformat = NULL;
2824
    image_format = NULL;
2825

    
2826
    grab_device = NULL;
2827
    video_channel = 0;
2828

    
2829
    rate_emu = 0;
2830
}
2831

    
2832
static void opt_grab(const char *arg)
2833
{
2834
    file_iformat = av_find_input_format(arg);
2835
    opt_input_file("");
2836
}
2837

    
2838
static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2839
{
2840
    int has_video, has_audio, i, j;
2841
    AVFormatContext *ic;
2842

    
2843
    has_video = 0;
2844
    has_audio = 0;
2845
    for(j=0;j<nb_input_files;j++) {
2846
        ic = input_files[j];
2847
        for(i=0;i<ic->nb_streams;i++) {
2848
            AVCodecContext *enc = ic->streams[i]->codec;
2849
            switch(enc->codec_type) {
2850
            case CODEC_TYPE_AUDIO:
2851
                has_audio = 1;
2852
                break;
2853
            case CODEC_TYPE_VIDEO:
2854
                has_video = 1;
2855
                break;
2856
            case CODEC_TYPE_DATA:
2857
            case CODEC_TYPE_UNKNOWN:
2858
            case CODEC_TYPE_SUBTITLE:
2859
                break;
2860
            default:
2861
                av_abort();
2862
            }
2863
        }
2864
    }
2865
    *has_video_ptr = has_video;
2866
    *has_audio_ptr = has_audio;
2867
}
2868

    
2869
static void new_video_stream(AVFormatContext *oc)
2870
{
2871
    AVStream *st;
2872
    AVCodecContext *video_enc;
2873
    int codec_id;
2874

    
2875
    st = av_new_stream(oc, oc->nb_streams);
2876
    if (!st) {
2877
        fprintf(stderr, "Could not alloc stream\n");
2878
        exit(1);
2879
    }
2880
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2881
    video_bitstream_filters= NULL;
2882

    
2883
#if defined(HAVE_THREADS)
2884
    if(thread_count>1)
2885
        avcodec_thread_init(st->codec, thread_count);
2886
#endif
2887

    
2888
    video_enc = st->codec;
2889

    
2890
    if(video_codec_tag)
2891
        video_enc->codec_tag= video_codec_tag;
2892

    
2893
    if(   (video_global_header&1)
2894
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2895
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2896
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2897
    }
2898
    if(video_global_header&2){
2899
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2900
        avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2901
    }
2902

    
2903
    if (video_stream_copy) {
2904
        st->stream_copy = 1;
2905
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2906
    } else {
2907
        char *p;
2908
        int i;
2909
        AVCodec *codec;
2910

    
2911
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2912
        if (video_codec_id != CODEC_ID_NONE)
2913
            codec_id = video_codec_id;
2914

    
2915
        video_enc->codec_id = codec_id;
2916
        codec = avcodec_find_encoder(codec_id);
2917

    
2918
        for(i=0; i<opt_name_count; i++){
2919
             AVOption *opt;
2920
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2921
             if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2922
                 av_set_double(video_enc, opt_names[i], d);
2923
        }
2924

    
2925
        video_enc->time_base.den = frame_rate;
2926
        video_enc->time_base.num = frame_rate_base;
2927
        if(codec && codec->supported_framerates){
2928
            const AVRational *p= codec->supported_framerates;
2929
            AVRational req= (AVRational){frame_rate, frame_rate_base};
2930
            const AVRational *best=NULL;
2931
            AVRational best_error= (AVRational){INT_MAX, 1};
2932
            for(; p->den!=0; p++){
2933
                AVRational error= av_sub_q(req, *p);
2934
                if(error.num <0) error.num *= -1;
2935
                if(av_cmp_q(error, best_error) < 0){
2936
                    best_error= error;
2937
                    best= p;
2938
                }
2939
            }
2940
            video_enc->time_base.den= best->num;
2941
            video_enc->time_base.num= best->den;
2942
        }
2943

    
2944
        video_enc->width = frame_width + frame_padright + frame_padleft;
2945
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2946
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2947
        video_enc->pix_fmt = frame_pix_fmt;
2948

    
2949
        if(codec && codec->pix_fmts){
2950
            const enum PixelFormat *p= codec->pix_fmts;
2951
            for(; *p!=-1; p++){
2952
                if(*p == video_enc->pix_fmt)
2953
                    break;
2954
            }
2955
            if(*p == -1)
2956
                video_enc->pix_fmt = codec->pix_fmts[0];
2957
        }
2958

    
2959
        if (intra_only)
2960
            video_enc->gop_size = 0;
2961
        if (video_qscale || same_quality) {
2962
            video_enc->flags |= CODEC_FLAG_QSCALE;
2963
            video_enc->global_quality=
2964
                st->quality = FF_QP2LAMBDA * video_qscale;
2965
        }
2966

    
2967
        if(intra_matrix)
2968
            video_enc->intra_matrix = intra_matrix;
2969
        if(inter_matrix)
2970
            video_enc->inter_matrix = inter_matrix;
2971

    
2972
        video_enc->max_b_frames = b_frames;
2973
        video_enc->qmin = video_qmin;
2974
        video_enc->qmax = video_qmax;
2975
        video_enc->lmin = video_lmin;
2976
        video_enc->lmax = video_lmax;
2977
        video_enc->rc_qsquish = video_qsquish;
2978
        video_enc->mb_lmin = video_mb_lmin;
2979
        video_enc->mb_lmax = video_mb_lmax;
2980
        video_enc->max_qdiff = video_qdiff;
2981
        video_enc->rc_eq = video_rc_eq;
2982
        video_enc->workaround_bugs = workaround_bugs;
2983
        video_enc->thread_count = thread_count;
2984
        p= video_rc_override_string;
2985
        for(i=0; p; i++){
2986
            int start, end, q;
2987
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2988
            if(e!=3){
2989
                fprintf(stderr, "error parsing rc_override\n");
2990
                exit(1);
2991
            }
2992
            video_enc->rc_override=
2993
                av_realloc(video_enc->rc_override,
2994
                           sizeof(RcOverride)*(i+1));
2995
            video_enc->rc_override[i].start_frame= start;
2996
            video_enc->rc_override[i].end_frame  = end;
2997
            if(q>0){
2998
                video_enc->rc_override[i].qscale= q;
2999
                video_enc->rc_override[i].quality_factor= 1.0;
3000
            }
3001
            else{
3002
                video_enc->rc_override[i].qscale= 0;
3003
                video_enc->rc_override[i].quality_factor= -q/100.0;
3004
            }
3005
            p= strchr(p, '/');
3006
            if(p) p++;
3007
        }
3008
        video_enc->rc_override_count=i;
3009
        video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3010
        video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3011
        video_enc->me_threshold= me_threshold;
3012
        video_enc->mb_threshold= mb_threshold;
3013
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3014
        video_enc->strict_std_compliance = strict;
3015
        video_enc->error_rate = error_rate;
3016
        video_enc->scenechange_threshold= sc_threshold;
3017
        video_enc->me_penalty_compensation= me_penalty_compensation;
3018
        video_enc->frame_skip_threshold= frame_skip_threshold;
3019
        video_enc->frame_skip_factor= frame_skip_factor;
3020
        video_enc->frame_skip_exp= frame_skip_exp;
3021

    
3022
        if(packet_size){
3023
            video_enc->rtp_mode= 1;
3024
            video_enc->rtp_payload_size= packet_size;
3025
        }
3026

    
3027
        if (do_psnr)
3028
            video_enc->flags|= CODEC_FLAG_PSNR;
3029

    
3030
        video_enc->me_method = me_method;
3031

    
3032
        /* two pass mode */
3033
        if (do_pass) {
3034
            if (do_pass == 1) {
3035
                video_enc->flags |= CODEC_FLAG_PASS1;
3036
            } else {
3037
                video_enc->flags |= CODEC_FLAG_PASS2;
3038
            }
3039
        }
3040
    }
3041

    
3042
    /* reset some key parameters */
3043
    video_disable = 0;
3044
    video_codec_id = CODEC_ID_NONE;
3045
    video_stream_copy = 0;
3046
}
3047

    
3048
static void new_audio_stream(AVFormatContext *oc)
3049
{
3050
    AVStream *st;
3051
    AVCodecContext *audio_enc;
3052
    int codec_id, i;
3053

    
3054
    st = av_new_stream(oc, oc->nb_streams);
3055
    if (!st) {
3056
        fprintf(stderr, "Could not alloc stream\n");
3057
        exit(1);
3058
    }
3059

    
3060
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3061
    audio_bitstream_filters= NULL;
3062

    
3063
#if defined(HAVE_THREADS)
3064
    if(thread_count>1)
3065
        avcodec_thread_init(st->codec, thread_count);
3066
#endif
3067

    
3068
    audio_enc = st->codec;
3069
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3070

    
3071
    if(audio_codec_tag)
3072
        audio_enc->codec_tag= audio_codec_tag;
3073

    
3074
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3075
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3076
        avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3077
    }
3078
    if (audio_stream_copy) {
3079
        st->stream_copy = 1;
3080
        audio_enc->channels = audio_channels;
3081
    } else {
3082
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3083

    
3084
        for(i=0; i<opt_name_count; i++){
3085
            AVOption *opt;
3086
            double d= av_get_double(avctx_opts, opt_names[i], &opt);
3087
            if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3088
                av_set_double(audio_enc, opt_names[i], d);
3089
        }
3090

    
3091
        if (audio_codec_id != CODEC_ID_NONE)
3092
            codec_id = audio_codec_id;
3093
        audio_enc->codec_id = codec_id;
3094

    
3095
        audio_enc->bit_rate = audio_bit_rate;
3096
        if (audio_qscale > QSCALE_NONE) {
3097
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3098
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3099
        }
3100
        audio_enc->strict_std_compliance = strict;
3101
        audio_enc->thread_count = thread_count;
3102
        /* For audio codecs other than AC3 or DTS we limit */
3103
        /* the number of coded channels to stereo   */
3104
        if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3105
            && codec_id != CODEC_ID_DTS) {
3106
            audio_enc->channels = 2;
3107
        } else
3108
            audio_enc->channels = audio_channels;
3109
    }
3110
    audio_enc->sample_rate = audio_sample_rate;
3111
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3112
    if (audio_language) {
3113
        pstrcpy(st->language, sizeof(st->language), audio_language);
3114
        av_free(audio_language);
3115
        audio_language = NULL;
3116
    }
3117

    
3118
    /* reset some key parameters */
3119
    audio_disable = 0;
3120
    audio_codec_id = CODEC_ID_NONE;
3121
    audio_stream_copy = 0;
3122
}
3123

    
3124
static void opt_new_subtitle_stream(void)
3125
{
3126
    AVFormatContext *oc;
3127
    AVStream *st;
3128
    AVCodecContext *subtitle_enc;
3129
    int i;
3130

    
3131
    if (nb_output_files <= 0) {
3132
        fprintf(stderr, "At least one output file must be specified\n");
3133
        exit(1);
3134
    }
3135
    oc = output_files[nb_output_files - 1];
3136

    
3137
    st = av_new_stream(oc, oc->nb_streams);
3138
    if (!st) {
3139
        fprintf(stderr, "Could not alloc stream\n");
3140
        exit(1);
3141
    }
3142

    
3143
    subtitle_enc = st->codec;
3144
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3145
    if (subtitle_stream_copy) {
3146
        st->stream_copy = 1;
3147
    } else {
3148
        for(i=0; i<opt_name_count; i++){
3149
             AVOption *opt;
3150
             double d= av_get_double(avctx_opts, opt_names[i], &opt);
3151
             if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3152
                 av_set_double(subtitle_enc, opt_names[i], d);
3153
        }
3154
        subtitle_enc->codec_id = subtitle_codec_id;
3155
    }
3156

    
3157
    if (subtitle_language) {
3158
        pstrcpy(st->language, sizeof(st->language), subtitle_language);
3159
        av_free(subtitle_language);
3160
        subtitle_language = NULL;
3161
    }
3162

    
3163
    subtitle_codec_id = CODEC_ID_NONE;
3164
    subtitle_stream_copy = 0;
3165
}
3166

    
3167
static void opt_new_audio_stream(void)
3168
{
3169
    AVFormatContext *oc;
3170
    if (nb_output_files <= 0) {
3171
        fprintf(stderr, "At least one output file must be specified\n");
3172
        exit(1);
3173
    }
3174
    oc = output_files[nb_output_files - 1];
3175
    new_audio_stream(oc);
3176
}
3177

    
3178
static void opt_new_video_stream(void)
3179
{
3180
    AVFormatContext *oc;
3181
    if (nb_output_files <= 0) {
3182
        fprintf(stderr, "At least one output file must be specified\n");
3183
        exit(1);
3184
    }
3185
    oc = output_files[nb_output_files - 1];
3186
    new_video_stream(oc);
3187
}
3188

    
3189
static void opt_output_file(const char *filename)
3190
{
3191
    AVFormatContext *oc;
3192
    int use_video, use_audio, input_has_video, input_has_audio, i;
3193
    AVFormatParameters params, *ap = &params;
3194

    
3195
    if (!strcmp(filename, "-"))
3196
        filename = "pipe:";
3197

    
3198
    oc = av_alloc_format_context();
3199

    
3200
    if (!file_oformat) {
3201
        file_oformat = guess_format(NULL, filename, NULL);
3202
        if (!file_oformat) {
3203
            fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3204
                    filename);
3205
            exit(1);
3206
        }
3207
    }
3208

    
3209
    oc->oformat = file_oformat;
3210
    pstrcpy(oc->filename, sizeof(oc->filename), filename);
3211

    
3212
    if (!strcmp(file_oformat->name, "ffm") &&
3213
        strstart(filename, "http:", NULL)) {
3214
        /* special case for files sent to ffserver: we get the stream
3215
           parameters from ffserver */
3216
        if (read_ffserver_streams(oc, filename) < 0) {
3217
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3218
            exit(1);
3219
        }
3220
    } else {
3221
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3222
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3223

    
3224
        /* disable if no corresponding type found and at least one
3225
           input file */
3226
        if (nb_input_files > 0) {
3227
            check_audio_video_inputs(&input_has_video, &input_has_audio);
3228
            if (!input_has_video)
3229
                use_video = 0;
3230
            if (!input_has_audio)
3231
                use_audio = 0;
3232
        }
3233

    
3234
        /* manual disable */
3235
        if (audio_disable) {
3236
            use_audio = 0;
3237
        }
3238
        if (video_disable) {
3239
            use_video = 0;
3240
        }
3241

    
3242
        if (use_video) {
3243
            new_video_stream(oc);
3244
        }
3245

    
3246
        if (use_audio) {
3247
            new_audio_stream(oc);
3248
        }
3249

    
3250
        if (!oc->nb_streams) {
3251
            fprintf(stderr, "No audio or video streams available\n");
3252
            exit(1);
3253
        }
3254

    
3255
        oc->timestamp = rec_timestamp;
3256

    
3257
        if (str_title)
3258
            pstrcpy(oc->title, sizeof(oc->title), str_title);
3259
        if (str_author)
3260
            pstrcpy(oc->author, sizeof(oc->author), str_author);
3261
        if (str_copyright)
3262
            pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3263
        if (str_comment)
3264
            pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3265
        if (str_album)
3266
            pstrcpy(oc->album, sizeof(oc->album), str_album);
3267
    }
3268

    
3269
    output_files[nb_output_files++] = oc;
3270

    
3271
    /* check filename in case of an image number is expected */
3272
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3273
        if (!av_filename_number_test(oc->filename)) {
3274
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3275
            exit(1);
3276
        }
3277
    }
3278

    
3279
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3280
        /* test if it already exists to avoid loosing precious files */
3281
        if (!file_overwrite &&
3282
            (strchr(filename, ':') == NULL ||
3283
             strstart(filename, "file:", NULL))) {
3284
            if (url_exist(filename)) {
3285
                int c;
3286

    
3287
                if ( !using_stdin ) {
3288
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3289
                    fflush(stderr);
3290
                    c = getchar();
3291
                    if (toupper(c) != 'Y') {
3292
                        fprintf(stderr, "Not overwriting - exiting\n");
3293
                        exit(1);
3294
                    }
3295
                                }
3296
                                else {
3297
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3298
                    exit(1);
3299
                                }
3300
            }
3301
        }
3302

    
3303
        /* open the file */
3304
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3305
            fprintf(stderr, "Could not open '%s'\n", filename);
3306
            exit(1);
3307
        }
3308
    }
3309

    
3310
    memset(ap, 0, sizeof(*ap));
3311
    ap->image_format = image_format;
3312
    if (av_set_parameters(oc, ap) < 0) {
3313
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3314
                oc->filename);
3315
        exit(1);
3316
    }
3317

    
3318
    oc->packet_size= mux_packet_size;
3319
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3320
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3321
    oc->loop_output = loop_output;
3322

    
3323
    for(i=0; i<opt_name_count; i++){
3324
        AVOption *opt;
3325
        double d = av_get_double(avformat_opts, opt_names[i], &opt);
3326
        if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3327
            av_set_double(oc, opt_names[i], d);
3328
    }
3329

    
3330
    /* reset some options */
3331
    file_oformat = NULL;
3332
    file_iformat = NULL;
3333
    image_format = NULL;
3334
}
3335

    
3336
/* prepare dummy protocols for grab */
3337
static void prepare_grab(void)
3338
{
3339
    int has_video, has_audio, i, j;
3340
    AVFormatContext *oc;
3341
    AVFormatContext *ic;
3342
    AVFormatParameters vp1, *vp = &vp1;
3343
    AVFormatParameters ap1, *ap = &ap1;
3344

    
3345
    /* see if audio/video inputs are needed */
3346
    has_video = 0;
3347
    has_audio = 0;
3348
    memset(ap, 0, sizeof(*ap));
3349
    memset(vp, 0, sizeof(*vp));
3350
    vp->time_base.num= 1;
3351
    for(j=0;j<nb_output_files;j++) {
3352
        oc = output_files[j];
3353
        for(i=0;i<oc->nb_streams;i++) {
3354
            AVCodecContext *enc = oc->streams[i]->codec;
3355
            switch(enc->codec_type) {
3356
            case CODEC_TYPE_AUDIO:
3357
                if (enc->sample_rate > ap->sample_rate)
3358
                    ap->sample_rate = enc->sample_rate;
3359
                if (enc->channels > ap->channels)
3360
                    ap->channels = enc->channels;
3361
                has_audio = 1;
3362
                break;
3363
            case CODEC_TYPE_VIDEO:
3364
                if (enc->width > vp->width)
3365
                    vp->width = enc->width;
3366
                if (enc->height > vp->height)
3367
                    vp->height = enc->height;
3368

    
3369
                if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3370
                    vp->time_base = enc->time_base;
3371
                    vp->width += frame_leftBand + frame_rightBand;
3372
                    vp->width -= (frame_padleft + frame_padright);
3373
                    vp->height += frame_topBand + frame_bottomBand;
3374
                    vp->height -= (frame_padtop + frame_padbottom);
3375
                }
3376
                has_video = 1;
3377
                break;
3378
            default:
3379
                av_abort();
3380
            }
3381
        }
3382
    }
3383

    
3384
    if (has_video == 0 && has_audio == 0) {
3385
        fprintf(stderr, "Output file must have at least one audio or video stream\n");
3386
        exit(1);
3387
    }
3388

    
3389
    if (has_video) {
3390
        AVInputFormat *fmt1;
3391
        fmt1 = av_find_input_format(video_grab_format);
3392
        vp->device  = video_device;
3393
        vp->channel = video_channel;
3394
        vp->standard = video_standard;
3395
        vp->pix_fmt = frame_pix_fmt;
3396
        if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3397
            fprintf(stderr, "Could not find video grab device\n");
3398
            exit(1);
3399
        }
3400
        /* If not enough info to get the stream parameters, we decode the
3401
           first frames to get it. */
3402
        if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3403
            fprintf(stderr, "Could not find video grab parameters\n");
3404
            exit(1);
3405
        }
3406
        /* by now video grab has one stream */
3407
        ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3408
        ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3409
        input_files[nb_input_files] = ic;
3410

    
3411
        if (verbose >= 0)
3412
            dump_format(ic, nb_input_files, "", 0);
3413

    
3414
        nb_input_files++;
3415
    }
3416
    if (has_audio && audio_grab_format) {
3417
        AVInputFormat *fmt1;
3418
        fmt1 = av_find_input_format(audio_grab_format);
3419
        ap->device = audio_device;
3420
        if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3421
            fprintf(stderr, "Could not find audio grab device\n");
3422
            exit(1);
3423
        }
3424
        input_files[nb_input_files] = ic;
3425

    
3426
        if (verbose >= 0)
3427
            dump_format(ic, nb_input_files, "", 0);
3428

    
3429
        nb_input_files++;
3430
    }
3431
}
3432

    
3433
/* same option as mencoder */
3434
static void opt_pass(const char *pass_str)
3435
{
3436
    int pass;
3437
    pass = atoi(pass_str);
3438
    if (pass != 1 && pass != 2) {
3439
        fprintf(stderr, "pass number can be only 1 or 2\n");
3440
        exit(1);
3441
    }
3442
    do_pass = pass;
3443
}
3444

    
3445
#if defined(__MINGW32__) || defined(CONFIG_OS2)
3446
static int64_t getutime(void)
3447
{
3448
  return av_gettime();
3449
}
3450
#else
3451
static int64_t getutime(void)
3452
{
3453
    struct rusage rusage;
3454

    
3455
    getrusage(RUSAGE_SELF, &rusage);
3456
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3457
}
3458
#endif
3459

    
3460
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3461
extern int ffm_nopts;
3462
#endif
3463

    
3464
static void show_formats(void)
3465
{
3466
    AVInputFormat *ifmt;
3467
    AVOutputFormat *ofmt;
3468
    AVImageFormat *image_fmt;
3469
    URLProtocol *up;
3470
    AVCodec *p, *p2;
3471
    const char **pp, *last_name;
3472

    
3473
    printf("File formats:\n");
3474
    last_name= "000";
3475
    for(;;){
3476
        int decode=0;
3477
        int encode=0;
3478
        const char *name=NULL;
3479
        const char *long_name=NULL;
3480

    
3481
        for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3482
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3483
                strcmp(ofmt->name, last_name)>0){
3484
                name= ofmt->name;
3485
                long_name= ofmt->long_name;
3486
                encode=1;
3487
            }
3488
        }
3489
        for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3490
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3491
                strcmp(ifmt->name, last_name)>0){
3492
                name= ifmt->name;
3493
                long_name= ifmt->long_name;
3494
                encode=0;
3495
            }
3496
            if(name && strcmp(ifmt->name, name)==0)
3497
                decode=1;
3498
        }
3499
        if(name==NULL)
3500
            break;
3501
        last_name= name;
3502

    
3503
        printf(
3504
            " %s%s %-15s %s\n",
3505
            decode ? "D":" ",
3506
            encode ? "E":" ",
3507
            name,
3508
            long_name ? long_name:" ");
3509
    }
3510
    printf("\n");
3511

    
3512
    printf("Image formats (filename extensions, if any, follow):\n");
3513
    for(image_fmt = first_image_format; image_fmt != NULL;
3514
        image_fmt = image_fmt->next) {
3515
        printf(
3516
            " %s%s %-6s %s\n",
3517
            image_fmt->img_read  ? "D":" ",
3518
            image_fmt->img_write ? "E":" ",
3519
            image_fmt->name,
3520
            image_fmt->extensions ? image_fmt->extensions:" ");
3521
    }
3522
    printf("\n");
3523

    
3524
    printf("Codecs:\n");
3525
    last_name= "000";
3526
    for(;;){
3527
        int decode=0;
3528
        int encode=0;
3529
        int cap=0;
3530
        const char *type_str;
3531

    
3532
        p2=NULL;
3533
        for(p = first_avcodec; p != NULL; p = p->next) {
3534
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3535
                strcmp(p->name, last_name)>0){
3536
                p2= p;
3537
                decode= encode= cap=0;
3538
            }
3539
            if(p2 && strcmp(p->name, p2->name)==0){
3540
                if(p->decode) decode=1;
3541
                if(p->encode) encode=1;
3542
                cap |= p->capabilities;
3543
            }
3544
        }
3545
        if(p2==NULL)
3546
            break;
3547
        last_name= p2->name;
3548

    
3549
        switch(p2->type) {
3550
        case CODEC_TYPE_VIDEO:
3551
            type_str = "V";
3552
            break;
3553
        case CODEC_TYPE_AUDIO:
3554
            type_str = "A";
3555
            break;
3556
        case CODEC_TYPE_SUBTITLE:
3557
            type_str = "S";
3558
            break;
3559
        default:
3560
            type_str = "?";
3561
            break;
3562
        }
3563
        printf(
3564
            " %s%s%s%s%s%s %s",
3565
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3566
            encode ? "E":" ",
3567
            type_str,
3568
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3569
            cap & CODEC_CAP_DR1 ? "D":" ",
3570
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3571
            p2->name);
3572
       /* if(p2->decoder && decode==0)
3573
            printf(" use %s for decoding", p2->decoder->name);*/
3574
        printf("\n");
3575
    }
3576
    printf("\n");
3577

    
3578
    printf("Supported file protocols:\n");
3579
    for(up = first_protocol; up != NULL; up = up->next)
3580
        printf(" %s:", up->name);
3581
    printf("\n");
3582

    
3583
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3584
    printf("Motion estimation methods:\n");
3585
    pp = motion_str;
3586
    while (*pp) {
3587
        printf(" %s", *pp);
3588
        if ((pp - motion_str + 1) == ME_ZERO)
3589
            printf("(fastest)");
3590
        else if ((pp - motion_str + 1) == ME_FULL)
3591
            printf("(slowest)");
3592
        else if ((pp - motion_str + 1) == ME_EPZS)
3593
            printf("(default)");
3594
        pp++;
3595
    }
3596
    printf("\n\n");
3597
    printf(
3598
"Note, the names of encoders and decoders dont always match, so there are\n"
3599
"several cases where the above table shows encoder only or decoder only entries\n"
3600
"even though both encoding and decoding are supported for example, the h263\n"
3601
"decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3602
"worse\n");
3603
    exit(1);
3604
}
3605

    
3606
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3607
{
3608
    int i;
3609
    const char *p = str;
3610
    for(i = 0;; i++) {
3611
        dest[i] = atoi(p);
3612
        if(i == 63)
3613
            break;
3614
        p = strchr(p, ',');
3615
        if(!p) {
3616
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3617
            exit(1);
3618
        }
3619
        p++;
3620
    }
3621
}
3622

    
3623
static void opt_inter_matrix(const char *arg)
3624
{
3625
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3626
    parse_matrix_coeffs(inter_matrix, arg);
3627
}
3628

    
3629
static void opt_intra_matrix(const char *arg)
3630
{
3631
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3632
    parse_matrix_coeffs(intra_matrix, arg);
3633
}
3634

    
3635
static void opt_target(const char *arg)
3636
{
3637
    int norm = -1;
3638
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3639

    
3640
    if(!strncmp(arg, "pal-", 4)) {
3641
        norm = 0;
3642
        arg += 4;
3643
    } else if(!strncmp(arg, "ntsc-", 5)) {
3644
        norm = 1;
3645
        arg += 5;
3646
    } else if(!strncmp(arg, "film-", 5)) {
3647
        norm = 2;
3648
        arg += 5;
3649
    } else {
3650
        int fr;
3651
        /* Calculate FR via float to avoid int overflow */
3652
        fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3653
        if(fr == 25000) {
3654
            norm = 0;
3655
        } else if((fr == 29970) || (fr == 23976)) {
3656
            norm = 1;
3657
        } else {
3658
            /* Try to determine PAL/NTSC by peeking in the input files */
3659
            if(nb_input_files) {
3660
                int i, j;
3661
                for(j = 0; j < nb_input_files; j++) {
3662
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3663
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3664
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3665
                            continue;
3666
                        fr = c->time_base.den * 1000 / c->time_base.num;
3667
                        if(fr == 25000) {
3668
                            norm = 0;
3669
                            break;
3670
                        } else if((fr == 29970) || (fr == 23976)) {
3671
                            norm = 1;
3672
                            break;
3673
                        }
3674
                    }
3675
                    if(norm >= 0)
3676
                        break;
3677
                }
3678
            }
3679
        }
3680
        if(verbose && norm >= 0)
3681
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3682
    }
3683

    
3684
    if(norm < 0) {
3685
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3686
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3687
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3688
        exit(1);
3689
    }
3690

    
3691
    if(!strcmp(arg, "vcd")) {
3692

    
3693
        opt_video_codec("mpeg1video");
3694
        opt_audio_codec("mp2");
3695
        opt_format("vcd");
3696

    
3697
        opt_frame_size(norm ? "352x240" : "352x288");
3698
        opt_frame_rate(frame_rates[norm]);
3699
        opt_default("gop", norm ? "18" : "15");
3700

    
3701
        opt_default("b", "1150000");
3702
        opt_default("maxrate", "1150000");
3703
        opt_default("minrate", "1150000");
3704
        opt_default("bufsize", "327680"); // 40*1024*8;
3705

    
3706
        audio_bit_rate = 224000;
3707
        audio_sample_rate = 44100;
3708

    
3709
        mux_packet_size= 2324;
3710
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3711

    
3712
        /* We have to offset the PTS, so that it is consistent with the SCR.
3713
           SCR starts at 36000, but the first two packs contain only padding
3714
           and the first pack from the other stream, respectively, may also have
3715
           been written before.
3716
           So the real data starts at SCR 36000+3*1200. */
3717
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3718
    } else if(!strcmp(arg, "svcd")) {
3719

    
3720
        opt_video_codec("mpeg2video");
3721
        opt_audio_codec("mp2");
3722
        opt_format("svcd");
3723

    
3724
        opt_frame_size(norm ? "480x480" : "480x576");
3725
        opt_frame_rate(frame_rates[norm]);
3726
        opt_default("gop", norm ? "18" : "15");
3727

    
3728
        opt_default("b", "2040000");
3729
        opt_default("maxrate", "2516000");
3730
        opt_default("minrate", "0"); //1145000;
3731
        opt_default("bufsize", "1835008"); //224*1024*8;
3732
        opt_default("flags", "+SCAN_OFFSET");
3733

    
3734

    
3735
        audio_bit_rate = 224000;
3736
        audio_sample_rate = 44100;
3737

    
3738
        mux_packet_size= 2324;
3739

    
3740
    } else if(!strcmp(arg, "dvd")) {
3741

    
3742
        opt_video_codec("mpeg2video");
3743
        opt_audio_codec("ac3");
3744
        opt_format("dvd");
3745

    
3746
        opt_frame_size(norm ? "720x480" : "720x576");
3747
        opt_frame_rate(frame_rates[norm]);
3748
        opt_default("gop", norm ? "18" : "15");
3749

    
3750
        opt_default("b", "6000000");
3751
        opt_default("maxrate", "9000000");
3752
        opt_default("minrate", "0"); //1500000;
3753
        opt_default("bufsize", "1835008"); //224*1024*8;
3754

    
3755
        mux_packet_size= 2048;  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3756
        opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3757

    
3758
        audio_bit_rate = 448000;
3759
        audio_sample_rate = 48000;
3760

    
3761
    } else if(!strncmp(arg, "dv", 2)) {
3762

    
3763
        opt_format("dv");
3764

    
3765
        opt_frame_size(norm ? "720x480" : "720x576");
3766
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3767
                                             (norm ? "yuv411p" : "yuv420p"));
3768
        opt_frame_rate(frame_rates[norm]);
3769

    
3770
        audio_sample_rate = 48000;
3771
        audio_channels = 2;
3772

    
3773
    } else {
3774
        fprintf(stderr, "Unknown target: %s\n", arg);
3775
        exit(1);
3776
    }
3777
}
3778

    
3779
static void opt_video_bsf(const char *arg)
3780
{
3781
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3782
    AVBitStreamFilterContext **bsfp;
3783

    
3784
    if(!bsfc){
3785
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3786
        exit(1);
3787
    }
3788

    
3789
    bsfp= &video_bitstream_filters;
3790
    while(*bsfp)
3791
        bsfp= &(*bsfp)->next;
3792

    
3793
    *bsfp= bsfc;
3794
}
3795

    
3796
//FIXME avoid audio - video code duplication
3797
static void opt_audio_bsf(const char *arg)
3798
{
3799
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3800
    AVBitStreamFilterContext **bsfp;
3801

    
3802
    if(!bsfc){
3803
        fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3804
        exit(1);
3805
    }
3806

    
3807
    bsfp= &audio_bitstream_filters;
3808
    while(*bsfp)
3809
        bsfp= &(*bsfp)->next;
3810

    
3811
    *bsfp= bsfc;
3812
}
3813

    
3814
static void show_version(void)
3815
{
3816
    /* TODO: add function interface to avutil and avformat */
3817
    fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3818
           "libavutil   %d\n"
3819
           "libavcodec  %d\n"
3820
           "libavformat %d\n",
3821
           LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3822
    exit(1);
3823
}
3824

    
3825
static int opt_default(const char *opt, const char *arg){
3826
    AVOption *o= av_set_string(avctx_opts, opt, arg);
3827
    if(!o)
3828
        o = av_set_string(avformat_opts, opt, arg);
3829
    if(!o)
3830
        return -1;
3831

    
3832
//    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));
3833

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

    
3838
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3839
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
3840
    if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3841
        ffm_nopts = 1;
3842
#endif
3843

    
3844
    if(avctx_opts->debug)
3845
        av_log_set_level(AV_LOG_DEBUG);
3846
    return 0;
3847
}
3848

    
3849
const OptionDef options[] = {
3850
    /* main options */
3851
    { "L", 0, {(void*)show_license}, "show license" },
3852
    { "h", 0, {(void*)show_help}, "show help" },
3853
    { "version", 0, {(void*)show_version}, "show version" },
3854
    { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3855
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3856
    { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3857
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3858
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3859
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3860
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3861
    { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3862
    { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3863
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3864
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3865
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3866
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3867
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3868
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3869
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3870
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3871
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3872
      "add timings for benchmarking" },
3873
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3874
      "dump each input packet" },
3875
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3876
      "when dumping packets, also dump the payload" },
3877
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3878
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3879
    { "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)", "" },
3880
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3881
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3882
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3883
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3884
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3885
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3886
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3887
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3888
    { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3889

    
3890
    /* video options */
3891
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3892
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3893
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3894
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3895
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3896
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3897
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3898
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3899
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3900
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3901
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3902
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3903
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3904
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3905
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3906
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3907
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3908
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3909
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3910
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3911
    { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3912
    { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3913
    { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3914
    { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3915
    { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3916
    { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3917
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3918
    { "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" },
3919
    { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3920
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3921
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3922
    { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3923
      "method" },
3924
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3925
    { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold",  "" },
3926
    { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3927
    { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3928
    { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3929
    { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3930
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3931
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3932
      "use same video quality as source (implies VBR)" },
3933
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3934
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3935
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3936
      "deinterlace pictures" },
3937
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3938
    { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3939
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3940
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3941
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3942
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3943
    { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3944
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3945
    { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
3946
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3947
    { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3948
    { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3949
    { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3950
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3951
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3952

    
3953
    /* audio options */
3954
    { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3955
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3956
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3957
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3958
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3959
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3960
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3961
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3962
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3963
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3964

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

    
3970
    /* grab options */
3971
    { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3972
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3973
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3974
    { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3975

    
3976
    /* G.2 grab options */
3977
    { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3978
    { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3979

    
3980
    /* muxer options */
3981
    { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
3982
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3983
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3984

    
3985
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3986
    { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3987

    
3988
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3989
    { NULL, },
3990
};
3991

    
3992
static void show_banner(void)
3993
{
3994
    fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3995
    fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3996
    fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3997
    fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3998
    fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3999
    fprintf(stderr, "  built on " __DATE__ " " __TIME__);
4000
#ifdef __GNUC__
4001
    fprintf(stderr, ", gcc: " __VERSION__ "\n");
4002
#else
4003
    fprintf(stderr, ", using a non-gcc compiler\n");
4004
#endif
4005
}
4006

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

    
4046
static void show_help(void)
4047
{
4048
    show_banner();
4049
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4050
           "Hyper fast Audio and Video encoder\n");
4051
    printf("\n");
4052
    show_help_options(options, "Main options:\n",
4053
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4054
    show_help_options(options, "\nVideo options:\n",
4055
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4056
                      OPT_VIDEO);
4057
    show_help_options(options, "\nAdvanced Video options:\n",
4058
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4059
                      OPT_VIDEO | OPT_EXPERT);
4060
    show_help_options(options, "\nAudio options:\n",
4061
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4062
                      OPT_AUDIO);
4063
    show_help_options(options, "\nAdvanced Audio options:\n",
4064
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4065
                      OPT_AUDIO | OPT_EXPERT);
4066
    show_help_options(options, "\nSubtitle options:\n",
4067
                      OPT_SUBTITLE | OPT_GRAB,
4068
                      OPT_SUBTITLE);
4069
    show_help_options(options, "\nAudio/Video grab options:\n",
4070
                      OPT_GRAB,
4071
                      OPT_GRAB);
4072
    show_help_options(options, "\nAdvanced options:\n",
4073
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4074
                      OPT_EXPERT);
4075
    av_opt_show(avctx_opts, NULL);
4076
    av_opt_show(avformat_opts, NULL);
4077

    
4078
    exit(1);
4079
}
4080

    
4081
void parse_arg_file(const char *filename)
4082
{
4083
    opt_output_file(filename);
4084
}
4085

    
4086
int main(int argc, char **argv)
4087
{
4088
    int i;
4089
    int64_t ti;
4090

    
4091
    av_register_all();
4092

    
4093
    avctx_opts= avcodec_alloc_context();
4094
    avformat_opts = av_alloc_format_context();
4095

    
4096
    if (argc <= 1)
4097
        show_help();
4098
    else
4099
        show_banner();
4100

    
4101
    /* parse options */
4102
    parse_options(argc, argv, options);
4103

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

    
4110
    if (nb_input_files == 0) {
4111
        input_sync = 1;
4112
        prepare_grab();
4113
    }
4114

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

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

    
4137
    av_free_static();
4138

    
4139
    if(intra_matrix)
4140
        av_free(intra_matrix);
4141
    if(inter_matrix)
4142
        av_free(inter_matrix);
4143

    
4144
#ifdef POWERPC_PERFORMANCE_REPORT
4145
    extern void powerpc_display_perf_report(void);
4146
    powerpc_display_perf_report();
4147
#endif /* POWERPC_PERFORMANCE_REPORT */
4148

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