Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ e1cc8339

History | View | Annotate | Download (137 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "config.h"
23
#include <ctype.h>
24
#include <string.h>
25
#include <math.h>
26
#include <stdlib.h>
27
#include <errno.h>
28
#include <signal.h>
29
#include <limits.h>
30
#include "avformat.h"
31
#include "avdevice.h"
32
#include "swscale.h"
33
#include "framehook.h"
34
#include "opt.h"
35
#include "fifo.h"
36
#include "avstring.h"
37
#include "os_support.h"
38

    
39
#if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
40
#include <windows.h>
41
#endif
42

    
43
#if defined(HAVE_TERMIOS_H)
44
#include <unistd.h>
45
#include <fcntl.h>
46
#include <sys/ioctl.h>
47
#include <sys/time.h>
48
#include <termios.h>
49
#include <sys/resource.h>
50
#elif defined(HAVE_CONIO_H)
51
#include <conio.h>
52
#endif
53
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
54
#include <time.h>
55

    
56
#include "version.h"
57
#include "cmdutils.h"
58

    
59
#undef NDEBUG
60
#include <assert.h>
61

    
62
#if !defined(INFINITY) && defined(HUGE_VAL)
63
#define INFINITY HUGE_VAL
64
#endif
65

    
66
#undef exit
67

    
68
static const char program_name[] = "FFmpeg";
69
static const int program_birth_year = 2000;
70

    
71
/* select an input stream for an output stream */
72
typedef struct AVStreamMap {
73
    int file_index;
74
    int stream_index;
75
    int sync_file_index;
76
    int sync_stream_index;
77
} AVStreamMap;
78

    
79
/** select an input file for an output file */
80
typedef struct AVMetaDataMap {
81
    int out_file;
82
    int in_file;
83
} AVMetaDataMap;
84

    
85
extern const OptionDef options[];
86

    
87
#define MAX_FILES 20
88

    
89
static AVFormatContext *input_files[MAX_FILES];
90
static int64_t input_files_ts_offset[MAX_FILES];
91
static int nb_input_files = 0;
92

    
93
static AVFormatContext *output_files[MAX_FILES];
94
static int nb_output_files = 0;
95

    
96
static AVStreamMap stream_maps[MAX_FILES];
97
static int nb_stream_maps;
98

    
99
static AVMetaDataMap meta_data_maps[MAX_FILES];
100
static int nb_meta_data_maps;
101

    
102
static AVInputFormat *file_iformat;
103
static AVOutputFormat *file_oformat;
104
static int frame_width  = 0;
105
static int frame_height = 0;
106
static float frame_aspect_ratio = 0;
107
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
108
static int frame_padtop  = 0;
109
static int frame_padbottom = 0;
110
static int frame_padleft  = 0;
111
static int frame_padright = 0;
112
static int padcolor[3] = {16,128,128}; /* default to black */
113
static int frame_topBand  = 0;
114
static int frame_bottomBand = 0;
115
static int frame_leftBand  = 0;
116
static int frame_rightBand = 0;
117
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
118
static AVRational frame_rate = (AVRational) {0,0};
119
static float video_qscale = 0;
120
static int video_qdiff = 3;
121
static uint16_t *intra_matrix = NULL;
122
static uint16_t *inter_matrix = NULL;
123
#if 0 //experimental, (can be removed)
124
static float video_rc_qsquish=1.0;
125
static float video_rc_qmod_amp=0;
126
static int video_rc_qmod_freq=0;
127
#endif
128
static const char *video_rc_override_string=NULL;
129
static int video_disable = 0;
130
static int video_discard = 0;
131
static char *video_codec_name = NULL;
132
static int video_codec_tag = 0;
133
static int same_quality = 0;
134
static int do_deinterlace = 0;
135
static int strict = 0;
136
static int top_field_first = -1;
137
static int me_threshold = 0;
138
static int intra_dc_precision = 8;
139
static int loop_input = 0;
140
static int loop_output = AVFMT_NOOUTPUTLOOP;
141
static int qp_hist = 0;
142

    
143
static int intra_only = 0;
144
static int audio_sample_rate = 44100;
145
#define QSCALE_NONE -99999
146
static float audio_qscale = QSCALE_NONE;
147
static int audio_disable = 0;
148
static int audio_channels = 1;
149
static char  *audio_codec_name = NULL;
150
static int audio_codec_tag = 0;
151
static char *audio_language = NULL;
152

    
153
static int subtitle_disable = 0;
154
static char *subtitle_codec_name = NULL;
155
static char *subtitle_language = NULL;
156

    
157
static float mux_preload= 0.5;
158
static float mux_max_delay= 0.7;
159

    
160
static int64_t recording_time = 0;
161
static int64_t start_time = 0;
162
static int64_t rec_timestamp = 0;
163
static int64_t input_ts_offset = 0;
164
static int file_overwrite = 0;
165
static char *str_title = NULL;
166
static char *str_author = NULL;
167
static char *str_copyright = NULL;
168
static char *str_comment = NULL;
169
static char *str_genre = NULL;
170
static char *str_album = NULL;
171
static int do_benchmark = 0;
172
static int do_hex_dump = 0;
173
static int do_pkt_dump = 0;
174
static int do_psnr = 0;
175
static int do_pass = 0;
176
static char *pass_logfilename = NULL;
177
static int audio_stream_copy = 0;
178
static int video_stream_copy = 0;
179
static int subtitle_stream_copy = 0;
180
static int video_sync_method= 1;
181
static int audio_sync_method= 0;
182
static float audio_drift_threshold= 0.1;
183
static int copy_ts= 0;
184
static int opt_shortest = 0; //
185
static int video_global_header = 0;
186
static char *vstats_filename;
187
static FILE *vstats_file;
188
static int opt_programid = 0;
189

    
190
static int rate_emu = 0;
191

    
192
static int  video_channel = 0;
193
static char *video_standard;
194

    
195
static int audio_volume = 256;
196

    
197
static int using_stdin = 0;
198
static int using_vhook = 0;
199
static int verbose = 1;
200
static int thread_count= 1;
201
static int q_pressed = 0;
202
static int64_t video_size = 0;
203
static int64_t audio_size = 0;
204
static int64_t extra_size = 0;
205
static int nb_frames_dup = 0;
206
static int nb_frames_drop = 0;
207
static int input_sync;
208
static uint64_t limit_filesize = 0; //
209

    
210
static int pgmyuv_compatibility_hack=0;
211
static float dts_delta_threshold = 10;
212

    
213
static int sws_flags = SWS_BICUBIC;
214

    
215
static const char **opt_names;
216
static int opt_name_count;
217
static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
218
static AVFormatContext *avformat_opts;
219
static struct SwsContext *sws_opts;
220
static int64_t timer_start;
221

    
222
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
223
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
224
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
225
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
226

    
227
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
228

    
229
struct AVInputStream;
230

    
231
typedef struct AVOutputStream {
232
    int file_index;          /* file index */
233
    int index;               /* stream index in the output file */
234
    int source_index;        /* AVInputStream index */
235
    AVStream *st;            /* stream in the output file */
236
    int encoding_needed;     /* true if encoding needed for this stream */
237
    int frame_number;
238
    /* input pts and corresponding output pts
239
       for A/V sync */
240
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
241
    struct AVInputStream *sync_ist; /* input stream to sync against */
242
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
243
    /* video only */
244
    int video_resample;
245
    AVFrame pict_tmp;      /* temporary image for resampling */
246
    struct SwsContext *img_resample_ctx; /* for image resampling */
247
    int resample_height;
248

    
249
    int video_crop;
250
    int topBand;             /* cropping area sizes */
251
    int leftBand;
252

    
253
    int video_pad;
254
    int padtop;              /* padding area sizes */
255
    int padbottom;
256
    int padleft;
257
    int padright;
258

    
259
    /* audio only */
260
    int audio_resample;
261
    ReSampleContext *resample; /* for audio resampling */
262
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
263
    FILE *logfile;
264
} AVOutputStream;
265

    
266
typedef struct AVInputStream {
267
    int file_index;
268
    int index;
269
    AVStream *st;
270
    int discard;             /* true if stream data should be discarded */
271
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
272
    int64_t sample_index;      /* current sample */
273

    
274
    int64_t       start;     /* time when read started */
275
    unsigned long frame;     /* current frame */
276
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
277
                                is not defined */
278
    int64_t       pts;       /* current pts */
279
    int is_start;            /* is 1 at the start and after a discontinuity */
280
} AVInputStream;
281

    
282
typedef struct AVInputFile {
283
    int eof_reached;      /* true if eof reached */
284
    int ist_index;        /* index of first stream in ist_table */
285
    int buffer_size;      /* current total buffer size */
286
    int nb_streams;       /* nb streams we are aware of */
287
} AVInputFile;
288

    
289
#ifdef HAVE_TERMIOS_H
290

    
291
/* init terminal so that we can grab keys */
292
static struct termios oldtty;
293
#endif
294

    
295
static void term_exit(void)
296
{
297
#ifdef HAVE_TERMIOS_H
298
    tcsetattr (0, TCSANOW, &oldtty);
299
#endif
300
}
301

    
302
static volatile sig_atomic_t received_sigterm = 0;
303

    
304
static void
305
sigterm_handler(int sig)
306
{
307
    received_sigterm = sig;
308
    term_exit();
309
}
310

    
311
static void term_init(void)
312
{
313
#ifdef HAVE_TERMIOS_H
314
    struct termios tty;
315

    
316
    tcgetattr (0, &tty);
317
    oldtty = tty;
318

    
319
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
320
                          |INLCR|IGNCR|ICRNL|IXON);
321
    tty.c_oflag |= OPOST;
322
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
323
    tty.c_cflag &= ~(CSIZE|PARENB);
324
    tty.c_cflag |= CS8;
325
    tty.c_cc[VMIN] = 1;
326
    tty.c_cc[VTIME] = 0;
327

    
328
    tcsetattr (0, TCSANOW, &tty);
329
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
330
#endif
331

    
332
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
333
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
334
    /*
335
    register a function to be called at normal program termination
336
    */
337
    atexit(term_exit);
338
#ifdef CONFIG_BEOS_NETSERVER
339
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
340
#endif
341
}
342

    
343
/* read a key without blocking */
344
static int read_key(void)
345
{
346
#if defined(HAVE_TERMIOS_H)
347
    int n = 1;
348
    unsigned char ch;
349
#ifndef CONFIG_BEOS_NETSERVER
350
    struct timeval tv;
351
    fd_set rfds;
352

    
353
    FD_ZERO(&rfds);
354
    FD_SET(0, &rfds);
355
    tv.tv_sec = 0;
356
    tv.tv_usec = 0;
357
    n = select(1, &rfds, NULL, NULL, &tv);
358
#endif
359
    if (n > 0) {
360
        n = read(0, &ch, 1);
361
        if (n == 1)
362
            return ch;
363

    
364
        return n;
365
    }
366
#elif defined(HAVE_CONIO_H)
367
    if(kbhit())
368
        return(getch());
369
#endif
370
    return -1;
371
}
372

    
373
static int decode_interrupt_cb(void)
374
{
375
    return q_pressed || (q_pressed = read_key() == 'q');
376
}
377

    
378
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
379
{
380
    int i, err;
381
    AVFormatContext *ic;
382

    
383
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
384
    if (err < 0)
385
        return err;
386
    /* copy stream format */
387
    s->nb_streams = ic->nb_streams;
388
    for(i=0;i<ic->nb_streams;i++) {
389
        AVStream *st;
390

    
391
        // FIXME: a more elegant solution is needed
392
        st = av_mallocz(sizeof(AVStream));
393
        memcpy(st, ic->streams[i], sizeof(AVStream));
394
        st->codec = avcodec_alloc_context();
395
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
396
        s->streams[i] = st;
397
    }
398

    
399
    av_close_input_file(ic);
400
    return 0;
401
}
402

    
403
static double
404
get_sync_ipts(const AVOutputStream *ost)
405
{
406
    const AVInputStream *ist = ost->sync_ist;
407
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
408
}
409

    
410
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
411
    int ret;
412

    
413
    while(bsfc){
414
        AVPacket new_pkt= *pkt;
415
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
416
                                          &new_pkt.data, &new_pkt.size,
417
                                          pkt->data, pkt->size,
418
                                          pkt->flags & PKT_FLAG_KEY);
419
        if(a>0){
420
            av_free_packet(pkt);
421
            new_pkt.destruct= av_destruct_packet;
422
        } else if(a<0){
423
            fprintf(stderr, "%s failed for stream %d, codec %s",
424
                    bsfc->filter->name, pkt->stream_index,
425
                    avctx->codec ? avctx->codec->name : "copy");
426
            print_error("", a);
427
        }
428
        *pkt= new_pkt;
429

    
430
        bsfc= bsfc->next;
431
    }
432

    
433
    ret= av_interleaved_write_frame(s, pkt);
434
    if(ret < 0){
435
        print_error("av_interleaved_write_frame()", ret);
436
        exit(1);
437
    }
438
}
439

    
440
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
441

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

    
452
    int size_out, frame_bytes, ret;
453
    AVCodecContext *enc= ost->st->codec;
454
    AVCodecContext *dec= ist->st->codec;
455

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

    
464
    if (enc->channels != dec->channels)
465
        ost->audio_resample = 1;
466

    
467
    if (ost->audio_resample && !ost->resample) {
468
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
469
                                            enc->sample_rate, dec->sample_rate);
470
        if (!ost->resample) {
471
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
472
                    dec->channels, dec->sample_rate,
473
                    enc->channels, enc->sample_rate);
474
            exit(1);
475
        }
476
    }
477

    
478
    if(audio_sync_method){
479
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
480
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
481
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
482
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
483

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

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

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

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

    
536
    /* now encode as many frames as possible */
537
    if (enc->frame_size > 1) {
538
        /* output resampled raw samples */
539
        av_fifo_write(&ost->fifo, buftmp, size_out);
540

    
541
        frame_bytes = enc->frame_size * 2 * enc->channels;
542

    
543
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
544
            AVPacket pkt;
545
            av_init_packet(&pkt);
546

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

    
558
            ost->sync_opts += enc->frame_size;
559
        }
560
    } else {
561
        AVPacket pkt;
562
        av_init_packet(&pkt);
563

    
564
        ost->sync_opts += size_out / (2 * enc->channels);
565

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

    
604
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
605
{
606
    AVCodecContext *dec;
607
    AVPicture *picture2;
608
    AVPicture picture_tmp;
609
    uint8_t *buf = 0;
610

    
611
    dec = ist->st->codec;
612

    
613
    /* deinterlace : must be done before any resize */
614
    if (do_deinterlace || using_vhook) {
615
        int size;
616

    
617
        /* create temporary picture */
618
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
619
        buf = av_malloc(size);
620
        if (!buf)
621
            return;
622

    
623
        picture2 = &picture_tmp;
624
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
625

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

    
641
    if (ENABLE_VHOOK)
642
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
643
                           1000000 * ist->pts / AV_TIME_BASE);
644

    
645
    if (picture != picture2)
646
        *picture = *picture2;
647
    *bufp = buf;
648
}
649

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

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

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

    
670
    enc = ost->st->codec;
671

    
672
    if (!subtitle_out) {
673
        subtitle_out = av_malloc(subtitle_out_max_size);
674
    }
675

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

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

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

    
705
static int bit_buffer_size= 1024*256;
706
static uint8_t *bit_buffer= NULL;
707

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

    
719
    avcodec_get_frame_defaults(&picture_crop_temp);
720
    avcodec_get_frame_defaults(&picture_pad_temp);
721

    
722
    enc = ost->st->codec;
723
    dec = ist->st->codec;
724

    
725
    /* by default, we output a single frame */
726
    nb_frames = 1;
727

    
728
    *frame_size = 0;
729

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

    
751
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
752
    if (nb_frames <= 0)
753
        return;
754

    
755
    if (ost->video_crop) {
756
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
757
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
758
            return;
759
        }
760
        formatted_picture = &picture_crop_temp;
761
    } else {
762
        formatted_picture = in_picture;
763
    }
764

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

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

    
786
    if (ost->video_pad) {
787
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
788
                enc->height, enc->width, enc->pix_fmt,
789
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
790
    }
791

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

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

    
809
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
810
            enc->coded_frame = old_frame;
811
        } else {
812
            AVFrame big_picture;
813

    
814
            big_picture= *final_picture;
815
            /* better than nothing: use input picture interlaced
816
               settings */
817
            big_picture.interlaced_frame = in_picture->interlaced_frame;
818
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
819
                if(top_field_first == -1)
820
                    big_picture.top_field_first = in_picture->top_field_first;
821
                else
822
                    big_picture.top_field_first = top_field_first;
823
            }
824

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

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

    
872
static double psnr(double d){
873
    if(d==0) return INFINITY;
874
    return -10.0*log(d)/log(10.0);
875
}
876

    
877
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
878
                           int frame_size)
879
{
880
    AVCodecContext *enc;
881
    int frame_number;
882
    double ti1, bitrate, avg_bitrate;
883

    
884
    /* this is executed just the first time do_video_stats is called */
885
    if (!vstats_file) {
886
        vstats_file = fopen(vstats_filename, "w");
887
        if (!vstats_file) {
888
            perror("fopen");
889
            exit(1);
890
        }
891
    }
892

    
893
    enc = ost->st->codec;
894
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
895
        frame_number = ost->frame_number;
896
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
897
        if (enc->flags&CODEC_FLAG_PSNR)
898
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
899

    
900
        fprintf(vstats_file,"f_size= %6d ", frame_size);
901
        /* compute pts value */
902
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
903
        if (ti1 < 0.01)
904
            ti1 = 0.01;
905

    
906
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
907
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
908
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
909
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
910
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
911
    }
912
}
913

    
914
static void print_report(AVFormatContext **output_files,
915
                         AVOutputStream **ost_table, int nb_ostreams,
916
                         int is_last_report)
917
{
918
    char buf[1024];
919
    AVOutputStream *ost;
920
    AVFormatContext *oc, *os;
921
    int64_t total_size;
922
    AVCodecContext *enc;
923
    int frame_number, vid, i;
924
    double bitrate, ti1, pts;
925
    static int64_t last_time = -1;
926
    static int qp_histogram[52];
927

    
928
    if (!is_last_report) {
929
        int64_t cur_time;
930
        /* display the report every 0.5 seconds */
931
        cur_time = av_gettime();
932
        if (last_time == -1) {
933
            last_time = cur_time;
934
            return;
935
        }
936
        if ((cur_time - last_time) < 500000)
937
            return;
938
        last_time = cur_time;
939
    }
940

    
941

    
942
    oc = output_files[0];
943

    
944
    total_size = url_fsize(oc->pb);
945
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
946
        total_size= url_ftell(oc->pb);
947

    
948
    buf[0] = '\0';
949
    ti1 = 1e10;
950
    vid = 0;
951
    for(i=0;i<nb_ostreams;i++) {
952
        ost = ost_table[i];
953
        os = output_files[ost->file_index];
954
        enc = ost->st->codec;
955
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
956
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
957
                    enc->coded_frame->quality/(float)FF_QP2LAMBDA);
958
        }
959
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
960
            float t = (av_gettime()-timer_start) / 1000000.0;
961

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

    
1007
    if (verbose || is_last_report) {
1008
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1009

    
1010
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1011
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1012
            (double)total_size / 1024, ti1, bitrate);
1013

    
1014
        if (verbose > 1)
1015
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1016
                  nb_frames_dup, nb_frames_drop);
1017

    
1018
        if (verbose >= 0)
1019
            fprintf(stderr, "%s    \r", buf);
1020

    
1021
        fflush(stderr);
1022
    }
1023

    
1024
    if (is_last_report && verbose >= 0){
1025
        int64_t raw= audio_size + video_size + extra_size;
1026
        fprintf(stderr, "\n");
1027
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1028
                video_size/1024.0,
1029
                audio_size/1024.0,
1030
                extra_size/1024.0,
1031
                100.0*(total_size - raw)/raw
1032
        );
1033
    }
1034
}
1035

    
1036
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1037
static int output_packet(AVInputStream *ist, int ist_index,
1038
                         AVOutputStream **ost_table, int nb_ostreams,
1039
                         const AVPacket *pkt)
1040
{
1041
    AVFormatContext *os;
1042
    AVOutputStream *ost;
1043
    uint8_t *ptr;
1044
    int len, ret, i;
1045
    uint8_t *data_buf;
1046
    int data_size, got_picture;
1047
    AVFrame picture;
1048
    void *buffer_to_free;
1049
    static unsigned int samples_size= 0;
1050
    static short *samples= NULL;
1051
    AVSubtitle subtitle, *subtitle_to_free;
1052
    int got_subtitle;
1053

    
1054
    if(!pkt){
1055
        ist->pts= ist->next_pts; // needed for last packet if vsync=0
1056
    } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1057
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1058
    } else {
1059
//        assert(ist->pts == ist->next_pts);
1060
    }
1061

    
1062
    if (pkt == NULL) {
1063
        /* EOF handling */
1064
        ptr = NULL;
1065
        len = 0;
1066
        goto handle_eof;
1067
    }
1068

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

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

    
1156
        buffer_to_free = NULL;
1157
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1158
            pre_process_video_frame(ist, (AVPicture *)&picture,
1159
                                    &buffer_to_free);
1160
        }
1161

    
1162
        // preprocess audio (volume)
1163
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1164
            if (audio_volume != 256) {
1165
                short *volp;
1166
                volp = samples;
1167
                for(i=0;i<(data_size / sizeof(short));i++) {
1168
                    int v = ((*volp) * audio_volume + 128) >> 8;
1169
                    if (v < -32768) v = -32768;
1170
                    if (v >  32767) v = 32767;
1171
                    *volp++ = v;
1172
                }
1173
            }
1174
        }
1175

    
1176
        /* frame rate emulation */
1177
        if (ist->st->codec->rate_emu) {
1178
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1179
            int64_t now = av_gettime() - ist->start;
1180
            if (pts > now)
1181
                usleep(pts - now);
1182

    
1183
            ist->frame++;
1184
        }
1185

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

    
1205
                ost = ost_table[i];
1206
                if (ost->source_index == ist_index) {
1207
                    os = output_files[ost->file_index];
1208

    
1209
#if 0
1210
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1211
                           (double)pkt->pts / AV_TIME_BASE,
1212
                           ((double)ist->pts / AV_TIME_BASE) -
1213
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1214
#endif
1215
                    /* set the input output pts pairs */
1216
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1217

    
1218
                    if (ost->encoding_needed) {
1219
                        switch(ost->st->codec->codec_type) {
1220
                        case CODEC_TYPE_AUDIO:
1221
                            do_audio_out(os, ost, ist, data_buf, data_size);
1222
                            break;
1223
                        case CODEC_TYPE_VIDEO:
1224
                            do_video_out(os, ost, ist, &picture, &frame_size);
1225
                            video_size += frame_size;
1226
                            if (vstats_filename && frame_size)
1227
                                do_video_stats(os, ost, frame_size);
1228
                            break;
1229
                        case CODEC_TYPE_SUBTITLE:
1230
                            do_subtitle_out(os, ost, ist, &subtitle,
1231
                                            pkt->pts);
1232
                            break;
1233
                        default:
1234
                            abort();
1235
                        }
1236
                    } else {
1237
                        AVFrame avframe; //FIXME/XXX remove this
1238
                        AVPacket opkt;
1239
                        av_init_packet(&opkt);
1240

    
1241
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1242
                            continue;
1243

    
1244
                        /* no reencoding needed : output the packet directly */
1245
                        /* force the input stream PTS */
1246

    
1247
                        avcodec_get_frame_defaults(&avframe);
1248
                        ost->st->codec->coded_frame= &avframe;
1249
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1250

    
1251
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1252
                            audio_size += data_size;
1253
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1254
                            video_size += data_size;
1255
                            ost->sync_opts++;
1256
                        }
1257

    
1258
                        opkt.stream_index= ost->index;
1259
                        if(pkt->pts != AV_NOPTS_VALUE)
1260
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1261
                        else
1262
                            opkt.pts= AV_NOPTS_VALUE;
1263

    
1264
                            if (pkt->dts == AV_NOPTS_VALUE)
1265
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1266
                            else
1267
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1268

    
1269
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1270
                        opkt.flags= pkt->flags;
1271

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

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

    
1301
        for(i=0;i<nb_ostreams;i++) {
1302
            ost = ost_table[i];
1303
            if (ost->source_index == ist_index) {
1304
                AVCodecContext *enc= ost->st->codec;
1305
                os = output_files[ost->file_index];
1306

    
1307
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1308
                    continue;
1309
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1310
                    continue;
1311

    
1312
                if (ost->encoding_needed) {
1313
                    for(;;) {
1314
                        AVPacket pkt;
1315
                        int fifo_bytes;
1316
                        av_init_packet(&pkt);
1317
                        pkt.stream_index= ost->index;
1318

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

    
1351
                        if(ret<=0)
1352
                            break;
1353
                        pkt.data= bit_buffer;
1354
                        pkt.size= ret;
1355
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1356
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1357
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1358
                    }
1359
                }
1360
            }
1361
        }
1362
    }
1363

    
1364
    return 0;
1365
 fail_decode:
1366
    return -1;
1367
}
1368

    
1369
static void print_sdp(AVFormatContext **avc, int n)
1370
{
1371
    char sdp[2048];
1372

    
1373
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1374
    printf("SDP:\n%s\n", sdp);
1375
}
1376

    
1377
static int stream_index_from_inputs(AVFormatContext **input_files,
1378
                                    int nb_input_files,
1379
                                    AVInputFile *file_table,
1380
                                    AVInputStream **ist_table,
1381
                                    enum CodecType type,
1382
                                    int programid)
1383
{
1384
    int p, q, z;
1385
    for(z=0; z<nb_input_files; z++) {
1386
        AVFormatContext *ic = input_files[z];
1387
        for(p=0; p<ic->nb_programs; p++) {
1388
            AVProgram *program = ic->programs[p];
1389
            if(program->id != programid)
1390
                continue;
1391
            for(q=0; q<program->nb_stream_indexes; q++) {
1392
                int sidx = program->stream_index[q];
1393
                int ris = file_table[z].ist_index + sidx;
1394
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1395
                    return ris;
1396
            }
1397
        }
1398
    }
1399

    
1400
    return -1;
1401
}
1402

    
1403
/*
1404
 * The following code is the main loop of the file converter
1405
 */
1406
static int av_encode(AVFormatContext **output_files,
1407
                     int nb_output_files,
1408
                     AVFormatContext **input_files,
1409
                     int nb_input_files,
1410
                     AVStreamMap *stream_maps, int nb_stream_maps)
1411
{
1412
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1413
    AVFormatContext *is, *os;
1414
    AVCodecContext *codec, *icodec;
1415
    AVOutputStream *ost, **ost_table = NULL;
1416
    AVInputStream *ist, **ist_table = NULL;
1417
    AVInputFile *file_table;
1418
    int key;
1419
    int want_sdp = 1;
1420

    
1421
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1422
    if (!file_table)
1423
        goto fail;
1424

    
1425
    /* input stream init */
1426
    j = 0;
1427
    for(i=0;i<nb_input_files;i++) {
1428
        is = input_files[i];
1429
        file_table[i].ist_index = j;
1430
        file_table[i].nb_streams = is->nb_streams;
1431
        j += is->nb_streams;
1432
    }
1433
    nb_istreams = j;
1434

    
1435
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1436
    if (!ist_table)
1437
        goto fail;
1438

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

    
1456
            if (ist->st->codec->rate_emu) {
1457
                ist->start = av_gettime();
1458
                ist->frame = 0;
1459
            }
1460
        }
1461
    }
1462

    
1463
    /* output stream init */
1464
    nb_ostreams = 0;
1465
    for(i=0;i<nb_output_files;i++) {
1466
        os = output_files[i];
1467
        if (!os->nb_streams) {
1468
            fprintf(stderr, "Output file does not contain any stream\n");
1469
            exit(1);
1470
        }
1471
        nb_ostreams += os->nb_streams;
1472
    }
1473
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1474
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1475
        exit(1);
1476
    }
1477

    
1478
    /* Sanity check the mapping args -- do the input files & streams exist? */
1479
    for(i=0;i<nb_stream_maps;i++) {
1480
        int fi = stream_maps[i].file_index;
1481
        int si = stream_maps[i].stream_index;
1482

    
1483
        if (fi < 0 || fi > nb_input_files - 1 ||
1484
            si < 0 || si > file_table[fi].nb_streams - 1) {
1485
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1486
            exit(1);
1487
        }
1488
        fi = stream_maps[i].sync_file_index;
1489
        si = stream_maps[i].sync_stream_index;
1490
        if (fi < 0 || fi > nb_input_files - 1 ||
1491
            si < 0 || si > file_table[fi].nb_streams - 1) {
1492
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1493
            exit(1);
1494
        }
1495
    }
1496

    
1497
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1498
    if (!ost_table)
1499
        goto fail;
1500
    for(i=0;i<nb_ostreams;i++) {
1501
        ost = av_mallocz(sizeof(AVOutputStream));
1502
        if (!ost)
1503
            goto fail;
1504
        ost_table[i] = ost;
1505
    }
1506

    
1507
    n = 0;
1508
    for(k=0;k<nb_output_files;k++) {
1509
        os = output_files[k];
1510
        for(i=0;i<os->nb_streams;i++) {
1511
            int found;
1512
            ost = ost_table[n++];
1513
            ost->file_index = k;
1514
            ost->index = i;
1515
            ost->st = os->streams[i];
1516
            if (nb_stream_maps > 0) {
1517
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1518
                    stream_maps[n-1].stream_index;
1519

    
1520
                /* Sanity check that the stream types match */
1521
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1522
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1523
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1524
                        ost->file_index, ost->index);
1525
                    exit(1);
1526
                }
1527

    
1528
            } else {
1529
                if(opt_programid) {
1530
                    found = 0;
1531
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1532
                    if(j != -1) {
1533
                        ost->source_index = j;
1534
                        found = 1;
1535
                    }
1536
                } else {
1537
                    /* get corresponding input stream index : we select the first one with the right type */
1538
                    found = 0;
1539
                    for(j=0;j<nb_istreams;j++) {
1540
                        ist = ist_table[j];
1541
                        if (ist->discard &&
1542
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1543
                            ost->source_index = j;
1544
                            found = 1;
1545
                            break;
1546
                        }
1547
                    }
1548
                }
1549

    
1550
                if (!found) {
1551
                    if(! opt_programid) {
1552
                        /* try again and reuse existing stream */
1553
                        for(j=0;j<nb_istreams;j++) {
1554
                            ist = ist_table[j];
1555
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1556
                                ost->source_index = j;
1557
                                found = 1;
1558
                            }
1559
                        }
1560
                    }
1561
                    if (!found) {
1562
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1563
                                ost->file_index, ost->index);
1564
                        exit(1);
1565
                    }
1566
                }
1567
            }
1568
            ist = ist_table[ost->source_index];
1569
            ist->discard = 0;
1570
            ost->sync_ist = (nb_stream_maps > 0) ?
1571
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1572
                         stream_maps[n-1].sync_stream_index] : ist;
1573
        }
1574
    }
1575

    
1576
    /* for each output stream, we compute the right encoding parameters */
1577
    for(i=0;i<nb_ostreams;i++) {
1578
        ost = ost_table[i];
1579
        os = output_files[ost->file_index];
1580
        ist = ist_table[ost->source_index];
1581

    
1582
        codec = ost->st->codec;
1583
        icodec = ist->st->codec;
1584

    
1585
        if (!ost->st->language[0])
1586
            av_strlcpy(ost->st->language, ist->st->language,
1587
                       sizeof(ost->st->language));
1588

    
1589
        if (ost->st->stream_copy) {
1590
            /* if stream_copy is selected, no need to decode or encode */
1591
            codec->codec_id = icodec->codec_id;
1592
            codec->codec_type = icodec->codec_type;
1593

    
1594
            if(!codec->codec_tag){
1595
                if(   !os->oformat->codec_tag
1596
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1597
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1598
                    codec->codec_tag = icodec->codec_tag;
1599
            }
1600

    
1601
            codec->bit_rate = icodec->bit_rate;
1602
            codec->extradata= icodec->extradata;
1603
            codec->extradata_size= icodec->extradata_size;
1604
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1605
                codec->time_base = icodec->time_base;
1606
            else
1607
                codec->time_base = ist->st->time_base;
1608
            switch(codec->codec_type) {
1609
            case CODEC_TYPE_AUDIO:
1610
                codec->sample_rate = icodec->sample_rate;
1611
                codec->channels = icodec->channels;
1612
                codec->frame_size = icodec->frame_size;
1613
                codec->block_align= icodec->block_align;
1614
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1615
                    codec->block_align= 0;
1616
                break;
1617
            case CODEC_TYPE_VIDEO:
1618
                if(using_vhook) {
1619
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1620
                    exit(1);
1621
                }
1622
                codec->pix_fmt = icodec->pix_fmt;
1623
                codec->width = icodec->width;
1624
                codec->height = icodec->height;
1625
                codec->has_b_frames = icodec->has_b_frames;
1626
                break;
1627
            case CODEC_TYPE_SUBTITLE:
1628
                break;
1629
            default:
1630
                abort();
1631
            }
1632
        } else {
1633
            switch(codec->codec_type) {
1634
            case CODEC_TYPE_AUDIO:
1635
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1636
                    goto fail;
1637
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1638
                icodec->request_channels = codec->channels;
1639
                ist->decoding_needed = 1;
1640
                ost->encoding_needed = 1;
1641
                break;
1642
            case CODEC_TYPE_VIDEO:
1643
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1644
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1645
                ost->video_resample = ((codec->width != icodec->width -
1646
                                (frame_leftBand + frame_rightBand) +
1647
                                (frame_padleft + frame_padright)) ||
1648
                        (codec->height != icodec->height -
1649
                                (frame_topBand  + frame_bottomBand) +
1650
                                (frame_padtop + frame_padbottom)) ||
1651
                        (codec->pix_fmt != icodec->pix_fmt));
1652
                if (ost->video_crop) {
1653
                    ost->topBand = frame_topBand;
1654
                    ost->leftBand = frame_leftBand;
1655
                }
1656
                if (ost->video_pad) {
1657
                    ost->padtop = frame_padtop;
1658
                    ost->padleft = frame_padleft;
1659
                    ost->padbottom = frame_padbottom;
1660
                    ost->padright = frame_padright;
1661
                    if (!ost->video_resample) {
1662
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1663
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1664
                                         codec->width, codec->height ) )
1665
                            goto fail;
1666
                    }
1667
                }
1668
                if (ost->video_resample) {
1669
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1670
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1671
                                         codec->width, codec->height ) ) {
1672
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1673
                        exit(1);
1674
                    }
1675
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1676
                    ost->img_resample_ctx = sws_getContext(
1677
                            icodec->width - (frame_leftBand + frame_rightBand),
1678
                            icodec->height - (frame_topBand + frame_bottomBand),
1679
                            icodec->pix_fmt,
1680
                            codec->width - (frame_padleft + frame_padright),
1681
                            codec->height - (frame_padtop + frame_padbottom),
1682
                            codec->pix_fmt,
1683
                            sws_flags, NULL, NULL, NULL);
1684
                    if (ost->img_resample_ctx == NULL) {
1685
                        fprintf(stderr, "Cannot get resampling context\n");
1686
                        exit(1);
1687
                    }
1688
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1689
                }
1690
                ost->encoding_needed = 1;
1691
                ist->decoding_needed = 1;
1692
                break;
1693
            case CODEC_TYPE_SUBTITLE:
1694
                ost->encoding_needed = 1;
1695
                ist->decoding_needed = 1;
1696
                break;
1697
            default:
1698
                abort();
1699
                break;
1700
            }
1701
            /* two pass mode */
1702
            if (ost->encoding_needed &&
1703
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1704
                char logfilename[1024];
1705
                FILE *f;
1706
                int size;
1707
                char *logbuffer;
1708

    
1709
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1710
                         pass_logfilename ?
1711
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1712
                if (codec->flags & CODEC_FLAG_PASS1) {
1713
                    f = fopen(logfilename, "w");
1714
                    if (!f) {
1715
                        perror(logfilename);
1716
                        exit(1);
1717
                    }
1718
                    ost->logfile = f;
1719
                } else {
1720
                    /* read the log file */
1721
                    f = fopen(logfilename, "r");
1722
                    if (!f) {
1723
                        perror(logfilename);
1724
                        exit(1);
1725
                    }
1726
                    fseek(f, 0, SEEK_END);
1727
                    size = ftell(f);
1728
                    fseek(f, 0, SEEK_SET);
1729
                    logbuffer = av_malloc(size + 1);
1730
                    if (!logbuffer) {
1731
                        fprintf(stderr, "Could not allocate log buffer\n");
1732
                        exit(1);
1733
                    }
1734
                    size = fread(logbuffer, 1, size, f);
1735
                    fclose(f);
1736
                    logbuffer[size] = '\0';
1737
                    codec->stats_in = logbuffer;
1738
                }
1739
            }
1740
        }
1741
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1742
            int size= codec->width * codec->height;
1743
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1744
        }
1745
    }
1746

    
1747
    if (!bit_buffer)
1748
        bit_buffer = av_malloc(bit_buffer_size);
1749
    if (!bit_buffer)
1750
        goto fail;
1751

    
1752
    /* dump the file output parameters - cannot be done before in case
1753
       of stream copy */
1754
    for(i=0;i<nb_output_files;i++) {
1755
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1756
    }
1757

    
1758
    /* dump the stream mapping */
1759
    if (verbose >= 0) {
1760
        fprintf(stderr, "Stream mapping:\n");
1761
        for(i=0;i<nb_ostreams;i++) {
1762
            ost = ost_table[i];
1763
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1764
                    ist_table[ost->source_index]->file_index,
1765
                    ist_table[ost->source_index]->index,
1766
                    ost->file_index,
1767
                    ost->index);
1768
            if (ost->sync_ist != ist_table[ost->source_index])
1769
                fprintf(stderr, " [sync #%d.%d]",
1770
                        ost->sync_ist->file_index,
1771
                        ost->sync_ist->index);
1772
            fprintf(stderr, "\n");
1773
        }
1774
    }
1775

    
1776
    /* open each encoder */
1777
    for(i=0;i<nb_ostreams;i++) {
1778
        ost = ost_table[i];
1779
        if (ost->encoding_needed) {
1780
            AVCodec *codec;
1781
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1782
            if (!codec) {
1783
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1784
                        ost->file_index, ost->index);
1785
                exit(1);
1786
            }
1787
            if (avcodec_open(ost->st->codec, codec) < 0) {
1788
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1789
                        ost->file_index, ost->index);
1790
                exit(1);
1791
            }
1792
            extra_size += ost->st->codec->extradata_size;
1793
        }
1794
    }
1795

    
1796
    /* open each decoder */
1797
    for(i=0;i<nb_istreams;i++) {
1798
        ist = ist_table[i];
1799
        if (ist->decoding_needed) {
1800
            AVCodec *codec;
1801
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1802
            if (!codec) {
1803
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1804
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1805
                exit(1);
1806
            }
1807
            if (avcodec_open(ist->st->codec, codec) < 0) {
1808
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1809
                        ist->file_index, ist->index);
1810
                exit(1);
1811
            }
1812
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1813
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1814
        }
1815
    }
1816

    
1817
    /* init pts */
1818
    for(i=0;i<nb_istreams;i++) {
1819
        ist = ist_table[i];
1820
        is = input_files[ist->file_index];
1821
        ist->pts = 0;
1822
        ist->next_pts=0;
1823
        if(   input_files_ts_offset[ist->file_index] != -is->start_time
1824
           && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1825
            ist->next_pts= AV_NOPTS_VALUE;
1826
        ist->is_start = 1;
1827
    }
1828

    
1829
    /* set meta data information from input file if required */
1830
    for (i=0;i<nb_meta_data_maps;i++) {
1831
        AVFormatContext *out_file;
1832
        AVFormatContext *in_file;
1833

    
1834
        int out_file_index = meta_data_maps[i].out_file;
1835
        int in_file_index = meta_data_maps[i].in_file;
1836
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1837
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1838
            ret = AVERROR(EINVAL);
1839
            goto fail;
1840
        }
1841
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1842
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1843
            ret = AVERROR(EINVAL);
1844
            goto fail;
1845
        }
1846

    
1847
        out_file = output_files[out_file_index];
1848
        in_file = input_files[in_file_index];
1849

    
1850
        strcpy(out_file->title, in_file->title);
1851
        strcpy(out_file->author, in_file->author);
1852
        strcpy(out_file->copyright, in_file->copyright);
1853
        strcpy(out_file->comment, in_file->comment);
1854
        strcpy(out_file->album, in_file->album);
1855
        out_file->year = in_file->year;
1856
        out_file->track = in_file->track;
1857
        strcpy(out_file->genre, in_file->genre);
1858
    }
1859

    
1860
    /* open files and write file headers */
1861
    for(i=0;i<nb_output_files;i++) {
1862
        os = output_files[i];
1863
        if (av_write_header(os) < 0) {
1864
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1865
            ret = AVERROR(EINVAL);
1866
            goto fail;
1867
        }
1868
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1869
            want_sdp = 0;
1870
        }
1871
    }
1872
    if (want_sdp) {
1873
        print_sdp(output_files, nb_output_files);
1874
    }
1875

    
1876
    if ( !using_stdin && verbose >= 0) {
1877
        fprintf(stderr, "Press [q] to stop encoding\n");
1878
        url_set_interrupt_cb(decode_interrupt_cb);
1879
    }
1880
    term_init();
1881

    
1882
    key = -1;
1883
    timer_start = av_gettime();
1884

    
1885
    for(; received_sigterm == 0;) {
1886
        int file_index, ist_index;
1887
        AVPacket pkt;
1888
        double ipts_min;
1889
        double opts_min;
1890

    
1891
    redo:
1892
        ipts_min= 1e100;
1893
        opts_min= 1e100;
1894
        /* if 'q' pressed, exits */
1895
        if (!using_stdin) {
1896
            if (q_pressed)
1897
                break;
1898
            /* read_key() returns 0 on EOF */
1899
            key = read_key();
1900
            if (key == 'q')
1901
                break;
1902
        }
1903

    
1904
        /* select the stream that we must read now by looking at the
1905
           smallest output pts */
1906
        file_index = -1;
1907
        for(i=0;i<nb_ostreams;i++) {
1908
            double ipts, opts;
1909
            ost = ost_table[i];
1910
            os = output_files[ost->file_index];
1911
            ist = ist_table[ost->source_index];
1912
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1913
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1914
            else
1915
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1916
            ipts = (double)ist->pts;
1917
            if (!file_table[ist->file_index].eof_reached){
1918
                if(ipts < ipts_min) {
1919
                    ipts_min = ipts;
1920
                    if(input_sync ) file_index = ist->file_index;
1921
                }
1922
                if(opts < opts_min) {
1923
                    opts_min = opts;
1924
                    if(!input_sync) file_index = ist->file_index;
1925
                }
1926
            }
1927
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1928
                file_index= -1;
1929
                break;
1930
            }
1931
        }
1932
        /* if none, if is finished */
1933
        if (file_index < 0) {
1934
            break;
1935
        }
1936

    
1937
        /* finish if recording time exhausted */
1938
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1939
            break;
1940

    
1941
        /* finish if limit size exhausted */
1942
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1943
            break;
1944

    
1945
        /* read a frame from it and output it in the fifo */
1946
        is = input_files[file_index];
1947
        if (av_read_frame(is, &pkt) < 0) {
1948
            file_table[file_index].eof_reached = 1;
1949
            if (opt_shortest)
1950
                break;
1951
            else
1952
                continue;
1953
        }
1954

    
1955
        if (do_pkt_dump) {
1956
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1957
        }
1958
        /* the following test is needed in case new streams appear
1959
           dynamically in stream : we ignore them */
1960
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1961
            goto discard_packet;
1962
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1963
        ist = ist_table[ist_index];
1964
        if (ist->discard)
1965
            goto discard_packet;
1966

    
1967
        if (pkt.dts != AV_NOPTS_VALUE)
1968
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1969
        if (pkt.pts != AV_NOPTS_VALUE)
1970
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1971

    
1972
//        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1973
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1974
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1975
            int64_t delta= pkt_dts - ist->next_pts;
1976
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1977
                input_files_ts_offset[ist->file_index]-= delta;
1978
                if (verbose > 2)
1979
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1980
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1981
                if(pkt.pts != AV_NOPTS_VALUE)
1982
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1983
            }
1984
        }
1985

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

    
1989
            if (verbose >= 0)
1990
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1991
                        ist->file_index, ist->index);
1992

    
1993
            av_free_packet(&pkt);
1994
            goto redo;
1995
        }
1996

    
1997
    discard_packet:
1998
        av_free_packet(&pkt);
1999

    
2000
        /* dump report by using the output first video and audio streams */
2001
        print_report(output_files, ost_table, nb_ostreams, 0);
2002
    }
2003

    
2004
    /* at the end of stream, we must flush the decoder buffers */
2005
    for(i=0;i<nb_istreams;i++) {
2006
        ist = ist_table[i];
2007
        if (ist->decoding_needed) {
2008
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2009
        }
2010
    }
2011

    
2012
    term_exit();
2013

    
2014
    /* write the trailer if needed and close file */
2015
    for(i=0;i<nb_output_files;i++) {
2016
        os = output_files[i];
2017
        av_write_trailer(os);
2018
    }
2019

    
2020
    /* dump report by using the first video and audio streams */
2021
    print_report(output_files, ost_table, nb_ostreams, 1);
2022

    
2023
    /* close each encoder */
2024
    for(i=0;i<nb_ostreams;i++) {
2025
        ost = ost_table[i];
2026
        if (ost->encoding_needed) {
2027
            av_freep(&ost->st->codec->stats_in);
2028
            avcodec_close(ost->st->codec);
2029
        }
2030
    }
2031

    
2032
    /* close each decoder */
2033
    for(i=0;i<nb_istreams;i++) {
2034
        ist = ist_table[i];
2035
        if (ist->decoding_needed) {
2036
            avcodec_close(ist->st->codec);
2037
        }
2038
    }
2039

    
2040
    /* finished ! */
2041

    
2042
    ret = 0;
2043
 fail1:
2044
    av_freep(&bit_buffer);
2045
    av_free(file_table);
2046

    
2047
    if (ist_table) {
2048
        for(i=0;i<nb_istreams;i++) {
2049
            ist = ist_table[i];
2050
            av_free(ist);
2051
        }
2052
        av_free(ist_table);
2053
    }
2054
    if (ost_table) {
2055
        for(i=0;i<nb_ostreams;i++) {
2056
            ost = ost_table[i];
2057
            if (ost) {
2058
                if (ost->logfile) {
2059
                    fclose(ost->logfile);
2060
                    ost->logfile = NULL;
2061
                }
2062
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2063
                                             initialized but set to zero */
2064
                av_free(ost->pict_tmp.data[0]);
2065
                if (ost->video_resample)
2066
                    sws_freeContext(ost->img_resample_ctx);
2067
                if (ost->resample)
2068
                    audio_resample_close(ost->resample);
2069
                av_free(ost);
2070
            }
2071
        }
2072
        av_free(ost_table);
2073
    }
2074
    return ret;
2075
 fail:
2076
    ret = AVERROR(ENOMEM);
2077
    goto fail1;
2078
}
2079

    
2080
#if 0
2081
int file_read(const char *filename)
2082
{
2083
    URLContext *h;
2084
    unsigned char buffer[1024];
2085
    int len, i;
2086

2087
    if (url_open(&h, filename, O_RDONLY) < 0) {
2088
        printf("could not open '%s'\n", filename);
2089
        return -1;
2090
    }
2091
    for(;;) {
2092
        len = url_read(h, buffer, sizeof(buffer));
2093
        if (len <= 0)
2094
            break;
2095
        for(i=0;i<len;i++) putchar(buffer[i]);
2096
    }
2097
    url_close(h);
2098
    return 0;
2099
}
2100
#endif
2101

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

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

    
2120
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2121
extern int ffm_nopts;
2122
#endif
2123

    
2124
static int opt_default(const char *opt, const char *arg){
2125
    int type;
2126
    const AVOption *o= NULL;
2127
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2128

    
2129
    for(type=0; type<CODEC_TYPE_NB; type++){
2130
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2131
        if(o2)
2132
            o = av_set_string(avctx_opts[type], opt, arg);
2133
    }
2134
    if(!o)
2135
        o = av_set_string(avformat_opts, opt, arg);
2136
    if(!o)
2137
        o = av_set_string(sws_opts, opt, arg);
2138
    if(!o){
2139
        if(opt[0] == 'a')
2140
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2141
        else if(opt[0] == 'v')
2142
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2143
        else if(opt[0] == 's')
2144
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2145
    }
2146
    if(!o)
2147
        return -1;
2148

    
2149
//    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));
2150

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

    
2155
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2156
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
2157
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2158
        ffm_nopts = 1;
2159
#endif
2160

    
2161
    if(avctx_opts[0]->debug)
2162
        av_log_set_level(AV_LOG_DEBUG);
2163
    return 0;
2164
}
2165

    
2166
static void opt_video_rc_override_string(const char *arg)
2167
{
2168
    video_rc_override_string = arg;
2169
}
2170

    
2171
static void opt_me_threshold(const char *arg)
2172
{
2173
    me_threshold = atoi(arg);
2174
}
2175

    
2176
static void opt_verbose(const char *arg)
2177
{
2178
    verbose = atoi(arg);
2179
    av_log_set_level(atoi(arg));
2180
}
2181

    
2182
static void opt_frame_rate(const char *arg)
2183
{
2184
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2185
        fprintf(stderr, "Incorrect frame rate\n");
2186
        exit(1);
2187
    }
2188
}
2189

    
2190
static int opt_bitrate(const char *opt, const char *arg)
2191
{
2192
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2193

    
2194
    opt_default(opt, arg);
2195

    
2196
    if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2197
        fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2198

    
2199
    return 0;
2200
}
2201

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

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

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

    
2256
static void opt_frame_crop_right(const char *arg)
2257
{
2258
    frame_rightBand = atoi(arg);
2259
    if (frame_rightBand < 0) {
2260
        fprintf(stderr, "Incorrect right crop size\n");
2261
        exit(1);
2262
    }
2263
    if ((frame_rightBand % 2) != 0) {
2264
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2265
        exit(1);
2266
    }
2267
    if ((frame_rightBand) >= frame_width){
2268
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2269
        exit(1);
2270
    }
2271
    frame_width -= frame_rightBand;
2272
}
2273

    
2274
static void opt_frame_size(const char *arg)
2275
{
2276
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2277
        fprintf(stderr, "Incorrect frame size\n");
2278
        exit(1);
2279
    }
2280
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2281
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2282
        exit(1);
2283
    }
2284
}
2285

    
2286

    
2287
#define SCALEBITS 10
2288
#define ONE_HALF  (1 << (SCALEBITS - 1))
2289
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2290

    
2291
#define RGB_TO_Y(r, g, b) \
2292
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2293
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2294

    
2295
#define RGB_TO_U(r1, g1, b1, shift)\
2296
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2297
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2298

    
2299
#define RGB_TO_V(r1, g1, b1, shift)\
2300
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2301
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2302

    
2303
static void opt_pad_color(const char *arg) {
2304
    /* Input is expected to be six hex digits similar to
2305
       how colors are expressed in html tags (but without the #) */
2306
    int rgb = strtol(arg, NULL, 16);
2307
    int r,g,b;
2308

    
2309
    r = (rgb >> 16);
2310
    g = ((rgb >> 8) & 255);
2311
    b = (rgb & 255);
2312

    
2313
    padcolor[0] = RGB_TO_Y(r,g,b);
2314
    padcolor[1] = RGB_TO_U(r,g,b,0);
2315
    padcolor[2] = RGB_TO_V(r,g,b,0);
2316
}
2317

    
2318
static void opt_frame_pad_top(const char *arg)
2319
{
2320
    frame_padtop = atoi(arg);
2321
    if (frame_padtop < 0) {
2322
        fprintf(stderr, "Incorrect top pad size\n");
2323
        exit(1);
2324
    }
2325
    if ((frame_padtop % 2) != 0) {
2326
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2327
        exit(1);
2328
    }
2329
}
2330

    
2331
static void opt_frame_pad_bottom(const char *arg)
2332
{
2333
    frame_padbottom = atoi(arg);
2334
    if (frame_padbottom < 0) {
2335
        fprintf(stderr, "Incorrect bottom pad size\n");
2336
        exit(1);
2337
    }
2338
    if ((frame_padbottom % 2) != 0) {
2339
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2340
        exit(1);
2341
    }
2342
}
2343

    
2344

    
2345
static void opt_frame_pad_left(const char *arg)
2346
{
2347
    frame_padleft = atoi(arg);
2348
    if (frame_padleft < 0) {
2349
        fprintf(stderr, "Incorrect left pad size\n");
2350
        exit(1);
2351
    }
2352
    if ((frame_padleft % 2) != 0) {
2353
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2354
        exit(1);
2355
    }
2356
}
2357

    
2358

    
2359
static void opt_frame_pad_right(const char *arg)
2360
{
2361
    frame_padright = atoi(arg);
2362
    if (frame_padright < 0) {
2363
        fprintf(stderr, "Incorrect right pad size\n");
2364
        exit(1);
2365
    }
2366
    if ((frame_padright % 2) != 0) {
2367
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2368
        exit(1);
2369
    }
2370
}
2371

    
2372
void list_pix_fmts(void)
2373
{
2374
    int i;
2375
    char pix_fmt_str[128];
2376
    for (i=-1; i < PIX_FMT_NB; i++) {
2377
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2378
        fprintf(stdout, "%s\n", pix_fmt_str);
2379
    }
2380
}
2381

    
2382
static void opt_frame_pix_fmt(const char *arg)
2383
{
2384
    if (strcmp(arg, "list"))
2385
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2386
    else {
2387
        list_pix_fmts();
2388
        exit(0);
2389
    }
2390
}
2391

    
2392
static void opt_frame_aspect_ratio(const char *arg)
2393
{
2394
    int x = 0, y = 0;
2395
    double ar = 0;
2396
    const char *p;
2397

    
2398
    p = strchr(arg, ':');
2399
    if (p) {
2400
        x = strtol(arg, (char **)&arg, 10);
2401
        if (arg == p)
2402
            y = strtol(arg+1, (char **)&arg, 10);
2403
        if (x > 0 && y > 0)
2404
            ar = (double)x / (double)y;
2405
    } else
2406
        ar = strtod(arg, (char **)&arg);
2407

    
2408
    if (!ar) {
2409
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2410
        exit(1);
2411
    }
2412
    frame_aspect_ratio = ar;
2413
}
2414

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

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

    
2435
static void opt_strict(const char *arg)
2436
{
2437
    strict= atoi(arg);
2438
}
2439

    
2440
static void opt_top_field_first(const char *arg)
2441
{
2442
    top_field_first= atoi(arg);
2443
}
2444

    
2445
static void opt_thread_count(const char *arg)
2446
{
2447
    thread_count= atoi(arg);
2448
#if !defined(HAVE_THREADS)
2449
    if (verbose >= 0)
2450
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2451
#endif
2452
}
2453

    
2454
static void opt_audio_rate(const char *arg)
2455
{
2456
    audio_sample_rate = atoi(arg);
2457
}
2458

    
2459
static void opt_audio_channels(const char *arg)
2460
{
2461
    audio_channels = atoi(arg);
2462
}
2463

    
2464
static void opt_video_channel(const char *arg)
2465
{
2466
    video_channel = strtol(arg, NULL, 0);
2467
}
2468

    
2469
static void opt_video_standard(const char *arg)
2470
{
2471
    video_standard = av_strdup(arg);
2472
}
2473

    
2474
static void opt_codec(int *pstream_copy, char **pcodec_name,
2475
                      int codec_type, const char *arg)
2476
{
2477
    av_freep(pcodec_name);
2478
    if (!strcmp(arg, "copy")) {
2479
        *pstream_copy = 1;
2480
    } else {
2481
        *pcodec_name = av_strdup(arg);
2482
    }
2483
}
2484

    
2485
static void opt_audio_codec(const char *arg)
2486
{
2487
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2488
}
2489

    
2490
static void opt_audio_tag(const char *arg)
2491
{
2492
    char *tail;
2493
    audio_codec_tag= strtol(arg, &tail, 0);
2494

    
2495
    if(!tail || *tail)
2496
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2497
}
2498

    
2499
static void opt_video_tag(const char *arg)
2500
{
2501
    char *tail;
2502
    video_codec_tag= strtol(arg, &tail, 0);
2503

    
2504
    if(!tail || *tail)
2505
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2506
}
2507

    
2508
#ifdef CONFIG_VHOOK
2509
static void add_frame_hooker(const char *arg)
2510
{
2511
    int argc = 0;
2512
    char *argv[64];
2513
    int i;
2514
    char *args = av_strdup(arg);
2515

    
2516
    using_vhook = 1;
2517

    
2518
    argv[0] = strtok(args, " ");
2519
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2520
    }
2521

    
2522
    i = frame_hook_add(argc, argv);
2523

    
2524
    if (i != 0) {
2525
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2526
        exit(1);
2527
    }
2528
}
2529
#endif
2530

    
2531
static void opt_video_codec(const char *arg)
2532
{
2533
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2534
}
2535

    
2536
static void opt_subtitle_codec(const char *arg)
2537
{
2538
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2539
}
2540

    
2541
static void opt_map(const char *arg)
2542
{
2543
    AVStreamMap *m;
2544
    const char *p;
2545

    
2546
    p = arg;
2547
    m = &stream_maps[nb_stream_maps++];
2548

    
2549
    m->file_index = strtol(arg, (char **)&p, 0);
2550
    if (*p)
2551
        p++;
2552

    
2553
    m->stream_index = strtol(p, (char **)&p, 0);
2554
    if (*p) {
2555
        p++;
2556
        m->sync_file_index = strtol(p, (char **)&p, 0);
2557
        if (*p)
2558
            p++;
2559
        m->sync_stream_index = strtol(p, (char **)&p, 0);
2560
    } else {
2561
        m->sync_file_index = m->file_index;
2562
        m->sync_stream_index = m->stream_index;
2563
    }
2564
}
2565

    
2566
static void opt_map_meta_data(const char *arg)
2567
{
2568
    AVMetaDataMap *m;
2569
    const char *p;
2570

    
2571
    p = arg;
2572
    m = &meta_data_maps[nb_meta_data_maps++];
2573

    
2574
    m->out_file = strtol(arg, (char **)&p, 0);
2575
    if (*p)
2576
        p++;
2577

    
2578
    m->in_file = strtol(p, (char **)&p, 0);
2579
}
2580

    
2581
static int64_t parse_time_or_die(const char *timestr, int is_duration)
2582
{
2583
    int64_t us = parse_date(timestr, is_duration);
2584
    if (us == INT64_MIN) {
2585
        fprintf(stderr, "Invalid %s specification: %s\n",
2586
                is_duration ? "duration" : "date", timestr);
2587
        exit(1);
2588
    }
2589
    return us;
2590
}
2591

    
2592
static void opt_recording_time(const char *arg)
2593
{
2594
    recording_time = parse_time_or_die(arg, 1);
2595
}
2596

    
2597
static void opt_start_time(const char *arg)
2598
{
2599
    start_time = parse_time_or_die(arg, 1);
2600
}
2601

    
2602
static void opt_rec_timestamp(const char *arg)
2603
{
2604
    rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2605
}
2606

    
2607
static void opt_input_ts_offset(const char *arg)
2608
{
2609
    input_ts_offset = parse_time_or_die(arg, 1);
2610
}
2611

    
2612
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2613
{
2614
    char *codec_string = encoder ? "encoder" : "decoder";
2615
    AVCodec *codec;
2616

    
2617
    if(!name)
2618
        return CODEC_ID_NONE;
2619
    codec = encoder ?
2620
        avcodec_find_encoder_by_name(name) :
2621
        avcodec_find_decoder_by_name(name);
2622
    if(!codec) {
2623
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2624
        exit(1);
2625
    }
2626
    if(codec->type != type) {
2627
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2628
        exit(1);
2629
    }
2630
    return codec->id;
2631
}
2632

    
2633
static void opt_input_file(const char *filename)
2634
{
2635
    AVFormatContext *ic;
2636
    AVFormatParameters params, *ap = &params;
2637
    int err, i, ret, rfps, rfps_base;
2638
    int64_t timestamp;
2639

    
2640
    if (!strcmp(filename, "-"))
2641
        filename = "pipe:";
2642

    
2643
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2644
                   !strcmp( filename, "/dev/stdin" );
2645

    
2646
    /* get default parameters from command line */
2647
    ic = av_alloc_format_context();
2648

    
2649
    memset(ap, 0, sizeof(*ap));
2650
    ap->prealloced_context = 1;
2651
    ap->sample_rate = audio_sample_rate;
2652
    ap->channels = audio_channels;
2653
    ap->time_base.den = frame_rate.num;
2654
    ap->time_base.num = frame_rate.den;
2655
    ap->width = frame_width + frame_padleft + frame_padright;
2656
    ap->height = frame_height + frame_padtop + frame_padbottom;
2657
    ap->pix_fmt = frame_pix_fmt;
2658
    ap->channel = video_channel;
2659
    ap->standard = video_standard;
2660
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2661
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2662
    if(pgmyuv_compatibility_hack)
2663
        ap->video_codec_id= CODEC_ID_PGMYUV;
2664

    
2665
    for(i=0; i<opt_name_count; i++){
2666
        char buf[256];
2667
        const AVOption *opt;
2668
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2669
        if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2670
            av_set_string(ic, opt_names[i], str);
2671
    }
2672

    
2673
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2674
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2675
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2676

    
2677
    /* open the input file with generic libav function */
2678
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2679
    if (err < 0) {
2680
        print_error(filename, err);
2681
        exit(1);
2682
    }
2683
    if(opt_programid) {
2684
        int i;
2685
        for(i=0; i<ic->nb_programs; i++)
2686
            if(ic->programs[i]->id != opt_programid)
2687
                ic->programs[i]->discard = AVDISCARD_ALL;
2688
    }
2689

    
2690
    ic->loop_input = loop_input;
2691

    
2692
    /* If not enough info to get the stream parameters, we decode the
2693
       first frames to get it. (used in mpeg case for example) */
2694
    ret = av_find_stream_info(ic);
2695
    if (ret < 0 && verbose >= 0) {
2696
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2697
        exit(1);
2698
    }
2699

    
2700
    timestamp = start_time;
2701
    /* add the stream start time */
2702
    if (ic->start_time != AV_NOPTS_VALUE)
2703
        timestamp += ic->start_time;
2704

    
2705
    /* if seeking requested, we execute it */
2706
    if (start_time != 0) {
2707
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2708
        if (ret < 0) {
2709
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2710
                    filename, (double)timestamp / AV_TIME_BASE);
2711
        }
2712
        /* reset seek info */
2713
        start_time = 0;
2714
    }
2715

    
2716
    /* update the current parameters so that they match the one of the input stream */
2717
    for(i=0;i<ic->nb_streams;i++) {
2718
        int j;
2719
        AVCodecContext *enc = ic->streams[i]->codec;
2720
        if(thread_count>1)
2721
            avcodec_thread_init(enc, thread_count);
2722
        enc->thread_count= thread_count;
2723
        switch(enc->codec_type) {
2724
        case CODEC_TYPE_AUDIO:
2725
            for(j=0; j<opt_name_count; j++){
2726
                char buf[256];
2727
                const AVOption *opt;
2728
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2729
                if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2730
                    av_set_string(enc, opt_names[j], str);
2731
            }
2732
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2733
            audio_channels = enc->channels;
2734
            audio_sample_rate = enc->sample_rate;
2735
            if(audio_disable)
2736
                ic->streams[i]->discard= AVDISCARD_ALL;
2737
            break;
2738
        case CODEC_TYPE_VIDEO:
2739
            for(j=0; j<opt_name_count; j++){
2740
                char buf[256];
2741
                const AVOption *opt;
2742
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2743
                if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2744
                    av_set_string(enc, opt_names[j], str);
2745
            }
2746
            frame_height = enc->height;
2747
            frame_width = enc->width;
2748
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2749
            frame_pix_fmt = enc->pix_fmt;
2750
            rfps      = ic->streams[i]->r_frame_rate.num;
2751
            rfps_base = ic->streams[i]->r_frame_rate.den;
2752
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2753
            if(me_threshold)
2754
                enc->debug |= FF_DEBUG_MV;
2755

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

    
2758
                if (verbose >= 0)
2759
                    fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2760
                            i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2761

    
2762
                    (float)rfps / rfps_base, rfps, rfps_base);
2763
            }
2764
            /* update the current frame rate to match the stream frame rate */
2765
            frame_rate.num = rfps;
2766
            frame_rate.den = rfps_base;
2767

    
2768
            enc->rate_emu = rate_emu;
2769
            if(video_disable)
2770
                ic->streams[i]->discard= AVDISCARD_ALL;
2771
            else if(video_discard)
2772
                ic->streams[i]->discard= video_discard;
2773
            break;
2774
        case CODEC_TYPE_DATA:
2775
            break;
2776
        case CODEC_TYPE_SUBTITLE:
2777
            if(subtitle_disable)
2778
                ic->streams[i]->discard = AVDISCARD_ALL;
2779
            break;
2780
        case CODEC_TYPE_ATTACHMENT:
2781
        case CODEC_TYPE_UNKNOWN:
2782
            break;
2783
        default:
2784
            abort();
2785
        }
2786
    }
2787

    
2788
    input_files[nb_input_files] = ic;
2789
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2790
    /* dump the file content */
2791
    if (verbose >= 0)
2792
        dump_format(ic, nb_input_files, filename, 0);
2793

    
2794
    nb_input_files++;
2795
    file_iformat = NULL;
2796
    file_oformat = NULL;
2797

    
2798
    video_channel = 0;
2799

    
2800
    rate_emu = 0;
2801
    av_freep(&video_codec_name);
2802
    av_freep(&audio_codec_name);
2803
    av_freep(&subtitle_codec_name);
2804
}
2805

    
2806
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2807
                                         int *has_subtitle_ptr)
2808
{
2809
    int has_video, has_audio, has_subtitle, i, j;
2810
    AVFormatContext *ic;
2811

    
2812
    has_video = 0;
2813
    has_audio = 0;
2814
    has_subtitle = 0;
2815
    for(j=0;j<nb_input_files;j++) {
2816
        ic = input_files[j];
2817
        for(i=0;i<ic->nb_streams;i++) {
2818
            AVCodecContext *enc = ic->streams[i]->codec;
2819
            switch(enc->codec_type) {
2820
            case CODEC_TYPE_AUDIO:
2821
                has_audio = 1;
2822
                break;
2823
            case CODEC_TYPE_VIDEO:
2824
                has_video = 1;
2825
                break;
2826
            case CODEC_TYPE_SUBTITLE:
2827
                has_subtitle = 1;
2828
                break;
2829
            case CODEC_TYPE_DATA:
2830
            case CODEC_TYPE_ATTACHMENT:
2831
            case CODEC_TYPE_UNKNOWN:
2832
                break;
2833
            default:
2834
                abort();
2835
            }
2836
        }
2837
    }
2838
    *has_video_ptr = has_video;
2839
    *has_audio_ptr = has_audio;
2840
    *has_subtitle_ptr = has_subtitle;
2841
}
2842

    
2843
static void new_video_stream(AVFormatContext *oc)
2844
{
2845
    AVStream *st;
2846
    AVCodecContext *video_enc;
2847
    int codec_id;
2848

    
2849
    st = av_new_stream(oc, oc->nb_streams);
2850
    if (!st) {
2851
        fprintf(stderr, "Could not alloc stream\n");
2852
        exit(1);
2853
    }
2854
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2855
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2856
    video_bitstream_filters= NULL;
2857

    
2858
    if(thread_count>1)
2859
        avcodec_thread_init(st->codec, thread_count);
2860

    
2861
    video_enc = st->codec;
2862

    
2863
    if(video_codec_tag)
2864
        video_enc->codec_tag= video_codec_tag;
2865

    
2866
    if(   (video_global_header&1)
2867
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2868
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2869
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2870
    }
2871
    if(video_global_header&2){
2872
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2873
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2874
    }
2875

    
2876
    if (video_stream_copy) {
2877
        st->stream_copy = 1;
2878
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2879
    } else {
2880
        const char *p;
2881
        int i;
2882
        AVCodec *codec;
2883
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2884

    
2885
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2886
        if (video_codec_name)
2887
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2888

    
2889
        video_enc->codec_id = codec_id;
2890
        codec = avcodec_find_encoder(codec_id);
2891

    
2892
        for(i=0; i<opt_name_count; i++){
2893
            char buf[256];
2894
            const AVOption *opt;
2895
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2896
            if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2897
                av_set_string(video_enc, opt_names[i], str);
2898
        }
2899

    
2900
        video_enc->time_base.den = fps.num;
2901
        video_enc->time_base.num = fps.den;
2902
        if(codec && codec->supported_framerates){
2903
            const AVRational *p= codec->supported_framerates;
2904
            const AVRational *best=NULL;
2905
            AVRational best_error= (AVRational){INT_MAX, 1};
2906
            for(; p->den!=0; p++){
2907
                AVRational error= av_sub_q(fps, *p);
2908
                if(error.num <0) error.num *= -1;
2909
                if(av_cmp_q(error, best_error) < 0){
2910
                    best_error= error;
2911
                    best= p;
2912
                }
2913
            }
2914
            video_enc->time_base.den= best->num;
2915
            video_enc->time_base.num= best->den;
2916
        }
2917

    
2918
        video_enc->width = frame_width + frame_padright + frame_padleft;
2919
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2920
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2921
        video_enc->pix_fmt = frame_pix_fmt;
2922

    
2923
        if(codec && codec->pix_fmts){
2924
            const enum PixelFormat *p= codec->pix_fmts;
2925
            for(; *p!=-1; p++){
2926
                if(*p == video_enc->pix_fmt)
2927
                    break;
2928
            }
2929
            if(*p == -1)
2930
                video_enc->pix_fmt = codec->pix_fmts[0];
2931
        }
2932

    
2933
        if (intra_only)
2934
            video_enc->gop_size = 0;
2935
        if (video_qscale || same_quality) {
2936
            video_enc->flags |= CODEC_FLAG_QSCALE;
2937
            video_enc->global_quality=
2938
                st->quality = FF_QP2LAMBDA * video_qscale;
2939
        }
2940

    
2941
        if(intra_matrix)
2942
            video_enc->intra_matrix = intra_matrix;
2943
        if(inter_matrix)
2944
            video_enc->inter_matrix = inter_matrix;
2945

    
2946
        video_enc->max_qdiff = video_qdiff;
2947
        video_enc->thread_count = thread_count;
2948
        p= video_rc_override_string;
2949
        for(i=0; p; i++){
2950
            int start, end, q;
2951
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2952
            if(e!=3){
2953
                fprintf(stderr, "error parsing rc_override\n");
2954
                exit(1);
2955
            }
2956
            video_enc->rc_override=
2957
                av_realloc(video_enc->rc_override,
2958
                           sizeof(RcOverride)*(i+1));
2959
            video_enc->rc_override[i].start_frame= start;
2960
            video_enc->rc_override[i].end_frame  = end;
2961
            if(q>0){
2962
                video_enc->rc_override[i].qscale= q;
2963
                video_enc->rc_override[i].quality_factor= 1.0;
2964
            }
2965
            else{
2966
                video_enc->rc_override[i].qscale= 0;
2967
                video_enc->rc_override[i].quality_factor= -q/100.0;
2968
            }
2969
            p= strchr(p, '/');
2970
            if(p) p++;
2971
        }
2972
        video_enc->rc_override_count=i;
2973
        if (!video_enc->rc_initial_buffer_occupancy)
2974
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2975
        video_enc->me_threshold= me_threshold;
2976
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2977
        video_enc->strict_std_compliance = strict;
2978

    
2979
        if (do_psnr)
2980
            video_enc->flags|= CODEC_FLAG_PSNR;
2981

    
2982
        /* two pass mode */
2983
        if (do_pass) {
2984
            if (do_pass == 1) {
2985
                video_enc->flags |= CODEC_FLAG_PASS1;
2986
            } else {
2987
                video_enc->flags |= CODEC_FLAG_PASS2;
2988
            }
2989
        }
2990
    }
2991

    
2992
    /* reset some key parameters */
2993
    video_disable = 0;
2994
    av_freep(&video_codec_name);
2995
    video_stream_copy = 0;
2996
}
2997

    
2998
static void new_audio_stream(AVFormatContext *oc)
2999
{
3000
    AVStream *st;
3001
    AVCodecContext *audio_enc;
3002
    int codec_id, i;
3003

    
3004
    st = av_new_stream(oc, oc->nb_streams);
3005
    if (!st) {
3006
        fprintf(stderr, "Could not alloc stream\n");
3007
        exit(1);
3008
    }
3009
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3010

    
3011
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3012
    audio_bitstream_filters= NULL;
3013

    
3014
    if(thread_count>1)
3015
        avcodec_thread_init(st->codec, thread_count);
3016

    
3017
    audio_enc = st->codec;
3018
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3019
    audio_enc->strict_std_compliance = strict;
3020

    
3021
    if(audio_codec_tag)
3022
        audio_enc->codec_tag= audio_codec_tag;
3023

    
3024
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3025
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3026
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3027
    }
3028
    if (audio_stream_copy) {
3029
        st->stream_copy = 1;
3030
        audio_enc->channels = audio_channels;
3031
    } else {
3032
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3033

    
3034
        for(i=0; i<opt_name_count; i++){
3035
            char buf[256];
3036
            const AVOption *opt;
3037
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3038
            if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3039
                av_set_string(audio_enc, opt_names[i], str);
3040
        }
3041

    
3042
        if (audio_codec_name)
3043
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3044
        audio_enc->codec_id = codec_id;
3045

    
3046
        if (audio_qscale > QSCALE_NONE) {
3047
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3048
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3049
        }
3050
        audio_enc->thread_count = thread_count;
3051
        audio_enc->channels = audio_channels;
3052
    }
3053
    audio_enc->sample_rate = audio_sample_rate;
3054
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3055
    if (audio_language) {
3056
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3057
        av_free(audio_language);
3058
        audio_language = NULL;
3059
    }
3060

    
3061
    /* reset some key parameters */
3062
    audio_disable = 0;
3063
    av_freep(&audio_codec_name);
3064
    audio_stream_copy = 0;
3065
}
3066

    
3067
static void new_subtitle_stream(AVFormatContext *oc)
3068
{
3069
    AVStream *st;
3070
    AVCodecContext *subtitle_enc;
3071
    int i;
3072

    
3073
    st = av_new_stream(oc, oc->nb_streams);
3074
    if (!st) {
3075
        fprintf(stderr, "Could not alloc stream\n");
3076
        exit(1);
3077
    }
3078
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3079

    
3080
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3081
    subtitle_bitstream_filters= NULL;
3082

    
3083
    subtitle_enc = st->codec;
3084
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3085
    if (subtitle_stream_copy) {
3086
        st->stream_copy = 1;
3087
    } else {
3088
        for(i=0; i<opt_name_count; i++){
3089
            char buf[256];
3090
            const AVOption *opt;
3091
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3092
            if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3093
                av_set_string(subtitle_enc, opt_names[i], str);
3094
        }
3095
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3096
    }
3097

    
3098
    if (subtitle_language) {
3099
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3100
        av_free(subtitle_language);
3101
        subtitle_language = NULL;
3102
    }
3103

    
3104
    subtitle_disable = 0;
3105
    av_freep(&subtitle_codec_name);
3106
    subtitle_stream_copy = 0;
3107
}
3108

    
3109
static void opt_new_audio_stream(void)
3110
{
3111
    AVFormatContext *oc;
3112
    if (nb_output_files <= 0) {
3113
        fprintf(stderr, "At least one output file must be specified\n");
3114
        exit(1);
3115
    }
3116
    oc = output_files[nb_output_files - 1];
3117
    new_audio_stream(oc);
3118
}
3119

    
3120
static void opt_new_video_stream(void)
3121
{
3122
    AVFormatContext *oc;
3123
    if (nb_output_files <= 0) {
3124
        fprintf(stderr, "At least one output file must be specified\n");
3125
        exit(1);
3126
    }
3127
    oc = output_files[nb_output_files - 1];
3128
    new_video_stream(oc);
3129
}
3130

    
3131
static void opt_new_subtitle_stream(void)
3132
{
3133
    AVFormatContext *oc;
3134
    if (nb_output_files <= 0) {
3135
        fprintf(stderr, "At least one output file must be specified\n");
3136
        exit(1);
3137
    }
3138
    oc = output_files[nb_output_files - 1];
3139
    new_subtitle_stream(oc);
3140
}
3141

    
3142
static void opt_output_file(const char *filename)
3143
{
3144
    AVFormatContext *oc;
3145
    int use_video, use_audio, use_subtitle;
3146
    int input_has_video, input_has_audio, input_has_subtitle, i;
3147
    AVFormatParameters params, *ap = &params;
3148

    
3149
    if (!strcmp(filename, "-"))
3150
        filename = "pipe:";
3151

    
3152
    oc = av_alloc_format_context();
3153

    
3154
    if (!file_oformat) {
3155
        file_oformat = guess_format(NULL, filename, NULL);
3156
        if (!file_oformat) {
3157
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3158
                    filename);
3159
            exit(1);
3160
        }
3161
    }
3162

    
3163
    oc->oformat = file_oformat;
3164
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3165

    
3166
    if (!strcmp(file_oformat->name, "ffm") &&
3167
        av_strstart(filename, "http:", NULL)) {
3168
        /* special case for files sent to ffserver: we get the stream
3169
           parameters from ffserver */
3170
        if (read_ffserver_streams(oc, filename) < 0) {
3171
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3172
            exit(1);
3173
        }
3174
    } else {
3175
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3176
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3177
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3178

    
3179
        /* disable if no corresponding type found and at least one
3180
           input file */
3181
        if (nb_input_files > 0) {
3182
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3183
                                         &input_has_subtitle);
3184
            if (!input_has_video)
3185
                use_video = 0;
3186
            if (!input_has_audio)
3187
                use_audio = 0;
3188
            if (!input_has_subtitle)
3189
                use_subtitle = 0;
3190
        }
3191

    
3192
        /* manual disable */
3193
        if (audio_disable) {
3194
            use_audio = 0;
3195
        }
3196
        if (video_disable) {
3197
            use_video = 0;
3198
        }
3199
        if (subtitle_disable) {
3200
            use_subtitle = 0;
3201
        }
3202

    
3203
        if (use_video) {
3204
            new_video_stream(oc);
3205
        }
3206

    
3207
        if (use_audio) {
3208
            new_audio_stream(oc);
3209
        }
3210

    
3211
        if (use_subtitle) {
3212
            new_subtitle_stream(oc);
3213
        }
3214

    
3215
        oc->timestamp = rec_timestamp;
3216

    
3217
        if (str_title)
3218
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3219
        if (str_author)
3220
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3221
        if (str_copyright)
3222
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3223
        if (str_comment)
3224
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3225
        if (str_album)
3226
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3227
        if (str_genre)
3228
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3229
    }
3230

    
3231
    output_files[nb_output_files++] = oc;
3232

    
3233
    /* check filename in case of an image number is expected */
3234
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3235
        if (!av_filename_number_test(oc->filename)) {
3236
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3237
            exit(1);
3238
        }
3239
    }
3240

    
3241
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3242
        /* test if it already exists to avoid loosing precious files */
3243
        if (!file_overwrite &&
3244
            (strchr(filename, ':') == NULL ||
3245
             filename[1] == ':' ||
3246
             av_strstart(filename, "file:", NULL))) {
3247
            if (url_exist(filename)) {
3248
                int c;
3249

    
3250
                if ( !using_stdin ) {
3251
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3252
                    fflush(stderr);
3253
                    c = getchar();
3254
                    if (toupper(c) != 'Y') {
3255
                        fprintf(stderr, "Not overwriting - exiting\n");
3256
                        exit(1);
3257
                    }
3258
                                }
3259
                                else {
3260
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3261
                    exit(1);
3262
                                }
3263
            }
3264
        }
3265

    
3266
        /* open the file */
3267
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3268
            fprintf(stderr, "Could not open '%s'\n", filename);
3269
            exit(1);
3270
        }
3271
    }
3272

    
3273
    memset(ap, 0, sizeof(*ap));
3274
    if (av_set_parameters(oc, ap) < 0) {
3275
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3276
                oc->filename);
3277
        exit(1);
3278
    }
3279

    
3280
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3281
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3282
    oc->loop_output = loop_output;
3283

    
3284
    for(i=0; i<opt_name_count; i++){
3285
        char buf[256];
3286
        const AVOption *opt;
3287
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3288
        if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3289
            av_set_string(oc, opt_names[i], str);
3290
    }
3291

    
3292
    /* reset some options */
3293
    file_oformat = NULL;
3294
    file_iformat = NULL;
3295
}
3296

    
3297
/* same option as mencoder */
3298
static void opt_pass(const char *pass_str)
3299
{
3300
    int pass;
3301
    pass = atoi(pass_str);
3302
    if (pass != 1 && pass != 2) {
3303
        fprintf(stderr, "pass number can be only 1 or 2\n");
3304
        exit(1);
3305
    }
3306
    do_pass = pass;
3307
}
3308

    
3309
static int64_t getutime(void)
3310
{
3311
#ifdef HAVE_GETRUSAGE
3312
    struct rusage rusage;
3313

    
3314
    getrusage(RUSAGE_SELF, &rusage);
3315
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3316
#elif defined(HAVE_GETPROCESSTIMES)
3317
    HANDLE proc;
3318
    FILETIME c, e, k, u;
3319
    proc = GetCurrentProcess();
3320
    GetProcessTimes(proc, &c, &e, &k, &u);
3321
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3322
#else
3323
    return av_gettime();
3324
#endif
3325
}
3326

    
3327
static void opt_show_formats(void)
3328
{
3329
    AVInputFormat *ifmt=NULL;
3330
    AVOutputFormat *ofmt=NULL;
3331
    URLProtocol *up=NULL;
3332
    AVCodec *p=NULL, *p2;
3333
    AVBitStreamFilter *bsf=NULL;
3334
    const char *last_name;
3335

    
3336
    printf("File formats:\n");
3337
    last_name= "000";
3338
    for(;;){
3339
        int decode=0;
3340
        int encode=0;
3341
        const char *name=NULL;
3342
        const char *long_name=NULL;
3343

    
3344
        while((ofmt= av_oformat_next(ofmt))) {
3345
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3346
                strcmp(ofmt->name, last_name)>0){
3347
                name= ofmt->name;
3348
                long_name= ofmt->long_name;
3349
                encode=1;
3350
            }
3351
        }
3352
        while((ifmt= av_iformat_next(ifmt))) {
3353
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3354
                strcmp(ifmt->name, last_name)>0){
3355
                name= ifmt->name;
3356
                long_name= ifmt->long_name;
3357
                encode=0;
3358
            }
3359
            if(name && strcmp(ifmt->name, name)==0)
3360
                decode=1;
3361
        }
3362
        if(name==NULL)
3363
            break;
3364
        last_name= name;
3365

    
3366
        printf(
3367
            " %s%s %-15s %s\n",
3368
            decode ? "D":" ",
3369
            encode ? "E":" ",
3370
            name,
3371
            long_name ? long_name:" ");
3372
    }
3373
    printf("\n");
3374

    
3375
    printf("Codecs:\n");
3376
    last_name= "000";
3377
    for(;;){
3378
        int decode=0;
3379
        int encode=0;
3380
        int cap=0;
3381
        const char *type_str;
3382

    
3383
        p2=NULL;
3384
        while((p= av_codec_next(p))) {
3385
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3386
                strcmp(p->name, last_name)>0){
3387
                p2= p;
3388
                decode= encode= cap=0;
3389
            }
3390
            if(p2 && strcmp(p->name, p2->name)==0){
3391
                if(p->decode) decode=1;
3392
                if(p->encode) encode=1;
3393
                cap |= p->capabilities;
3394
            }
3395
        }
3396
        if(p2==NULL)
3397
            break;
3398
        last_name= p2->name;
3399

    
3400
        switch(p2->type) {
3401
        case CODEC_TYPE_VIDEO:
3402
            type_str = "V";
3403
            break;
3404
        case CODEC_TYPE_AUDIO:
3405
            type_str = "A";
3406
            break;
3407
        case CODEC_TYPE_SUBTITLE:
3408
            type_str = "S";
3409
            break;
3410
        default:
3411
            type_str = "?";
3412
            break;
3413
        }
3414
        printf(
3415
            " %s%s%s%s%s%s %s",
3416
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3417
            encode ? "E":" ",
3418
            type_str,
3419
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3420
            cap & CODEC_CAP_DR1 ? "D":" ",
3421
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3422
            p2->name);
3423
       /* if(p2->decoder && decode==0)
3424
            printf(" use %s for decoding", p2->decoder->name);*/
3425
        printf("\n");
3426
    }
3427
    printf("\n");
3428

    
3429
    printf("Bitstream filters:\n");
3430
    while((bsf = av_bitstream_filter_next(bsf)))
3431
        printf(" %s", bsf->name);
3432
    printf("\n");
3433

    
3434
    printf("Supported file protocols:\n");
3435
    while((up = av_protocol_next(up)))
3436
        printf(" %s:", up->name);
3437
    printf("\n");
3438

    
3439
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3440
    printf("\n");
3441
    printf(
3442
"Note, the names of encoders and decoders do not always match, so there are\n"
3443
"several cases where the above table shows encoder only or decoder only entries\n"
3444
"even though both encoding and decoding are supported. For example, the h263\n"
3445
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3446
"worse.\n");
3447
    exit(0);
3448
}
3449

    
3450
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3451
{
3452
    int i;
3453
    const char *p = str;
3454
    for(i = 0;; i++) {
3455
        dest[i] = atoi(p);
3456
        if(i == 63)
3457
            break;
3458
        p = strchr(p, ',');
3459
        if(!p) {
3460
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3461
            exit(1);
3462
        }
3463
        p++;
3464
    }
3465
}
3466

    
3467
static void opt_inter_matrix(const char *arg)
3468
{
3469
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3470
    parse_matrix_coeffs(inter_matrix, arg);
3471
}
3472

    
3473
static void opt_intra_matrix(const char *arg)
3474
{
3475
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3476
    parse_matrix_coeffs(intra_matrix, arg);
3477
}
3478

    
3479
/**
3480
 * Trivial log callback.
3481
 * Only suitable for show_help and similar since it lacks prefix handling.
3482
 */
3483
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3484
{
3485
    vfprintf(stdout, fmt, vl);
3486
}
3487

    
3488
static void show_help(void)
3489
{
3490
    av_log_set_callback(log_callback_help);
3491
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3492
           "Hyper fast Audio and Video encoder\n");
3493
    printf("\n");
3494
    show_help_options(options, "Main options:\n",
3495
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3496
    show_help_options(options, "\nVideo options:\n",
3497
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3498
                      OPT_VIDEO);
3499
    show_help_options(options, "\nAdvanced Video options:\n",
3500
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3501
                      OPT_VIDEO | OPT_EXPERT);
3502
    show_help_options(options, "\nAudio options:\n",
3503
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3504
                      OPT_AUDIO);
3505
    show_help_options(options, "\nAdvanced Audio options:\n",
3506
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3507
                      OPT_AUDIO | OPT_EXPERT);
3508
    show_help_options(options, "\nSubtitle options:\n",
3509
                      OPT_SUBTITLE | OPT_GRAB,
3510
                      OPT_SUBTITLE);
3511
    show_help_options(options, "\nAudio/Video grab options:\n",
3512
                      OPT_GRAB,
3513
                      OPT_GRAB);
3514
    show_help_options(options, "\nAdvanced options:\n",
3515
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3516
                      OPT_EXPERT);
3517
    av_opt_show(avctx_opts[0], NULL);
3518
    av_opt_show(avformat_opts, NULL);
3519
    av_opt_show(sws_opts, NULL);
3520
}
3521

    
3522
static void opt_show_help(void)
3523
{
3524
    show_help();
3525
    exit(0);
3526
}
3527

    
3528
static void opt_target(const char *arg)
3529
{
3530
    int norm = -1;
3531
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3532

    
3533
    if(!strncmp(arg, "pal-", 4)) {
3534
        norm = 0;
3535
        arg += 4;
3536
    } else if(!strncmp(arg, "ntsc-", 5)) {
3537
        norm = 1;
3538
        arg += 5;
3539
    } else if(!strncmp(arg, "film-", 5)) {
3540
        norm = 2;
3541
        arg += 5;
3542
    } else {
3543
        int fr;
3544
        /* Calculate FR via float to avoid int overflow */
3545
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3546
        if(fr == 25000) {
3547
            norm = 0;
3548
        } else if((fr == 29970) || (fr == 23976)) {
3549
            norm = 1;
3550
        } else {
3551
            /* Try to determine PAL/NTSC by peeking in the input files */
3552
            if(nb_input_files) {
3553
                int i, j;
3554
                for(j = 0; j < nb_input_files; j++) {
3555
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3556
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3557
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3558
                            continue;
3559
                        fr = c->time_base.den * 1000 / c->time_base.num;
3560
                        if(fr == 25000) {
3561
                            norm = 0;
3562
                            break;
3563
                        } else if((fr == 29970) || (fr == 23976)) {
3564
                            norm = 1;
3565
                            break;
3566
                        }
3567
                    }
3568
                    if(norm >= 0)
3569
                        break;
3570
                }
3571
            }
3572
        }
3573
        if(verbose && norm >= 0)
3574
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3575
    }
3576

    
3577
    if(norm < 0) {
3578
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3579
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3580
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3581
        exit(1);
3582
    }
3583

    
3584
    if(!strcmp(arg, "vcd")) {
3585

    
3586
        opt_video_codec("mpeg1video");
3587
        opt_audio_codec("mp2");
3588
        opt_format("vcd");
3589

    
3590
        opt_frame_size(norm ? "352x240" : "352x288");
3591
        opt_frame_rate(frame_rates[norm]);
3592
        opt_default("gop", norm ? "18" : "15");
3593

    
3594
        opt_default("b", "1150000");
3595
        opt_default("maxrate", "1150000");
3596
        opt_default("minrate", "1150000");
3597
        opt_default("bufsize", "327680"); // 40*1024*8;
3598

    
3599
        opt_default("ab", "224000");
3600
        audio_sample_rate = 44100;
3601
        audio_channels = 2;
3602

    
3603
        opt_default("packetsize", "2324");
3604
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3605

    
3606
        /* We have to offset the PTS, so that it is consistent with the SCR.
3607
           SCR starts at 36000, but the first two packs contain only padding
3608
           and the first pack from the other stream, respectively, may also have
3609
           been written before.
3610
           So the real data starts at SCR 36000+3*1200. */
3611
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3612
    } else if(!strcmp(arg, "svcd")) {
3613

    
3614
        opt_video_codec("mpeg2video");
3615
        opt_audio_codec("mp2");
3616
        opt_format("svcd");
3617

    
3618
        opt_frame_size(norm ? "480x480" : "480x576");
3619
        opt_frame_rate(frame_rates[norm]);
3620
        opt_default("gop", norm ? "18" : "15");
3621

    
3622
        opt_default("b", "2040000");
3623
        opt_default("maxrate", "2516000");
3624
        opt_default("minrate", "0"); //1145000;
3625
        opt_default("bufsize", "1835008"); //224*1024*8;
3626
        opt_default("flags", "+SCAN_OFFSET");
3627

    
3628

    
3629
        opt_default("ab", "224000");
3630
        audio_sample_rate = 44100;
3631

    
3632
        opt_default("packetsize", "2324");
3633

    
3634
    } else if(!strcmp(arg, "dvd")) {
3635

    
3636
        opt_video_codec("mpeg2video");
3637
        opt_audio_codec("ac3");
3638
        opt_format("dvd");
3639

    
3640
        opt_frame_size(norm ? "720x480" : "720x576");
3641
        opt_frame_rate(frame_rates[norm]);
3642
        opt_default("gop", norm ? "18" : "15");
3643

    
3644
        opt_default("b", "6000000");
3645
        opt_default("maxrate", "9000000");
3646
        opt_default("minrate", "0"); //1500000;
3647
        opt_default("bufsize", "1835008"); //224*1024*8;
3648

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

    
3652
        opt_default("ab", "448000");
3653
        audio_sample_rate = 48000;
3654

    
3655
    } else if(!strncmp(arg, "dv", 2)) {
3656

    
3657
        opt_format("dv");
3658

    
3659
        opt_frame_size(norm ? "720x480" : "720x576");
3660
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3661
                                             (norm ? "yuv411p" : "yuv420p"));
3662
        opt_frame_rate(frame_rates[norm]);
3663

    
3664
        audio_sample_rate = 48000;
3665
        audio_channels = 2;
3666

    
3667
    } else {
3668
        fprintf(stderr, "Unknown target: %s\n", arg);
3669
        exit(1);
3670
    }
3671
}
3672

    
3673
static void opt_vstats_file (const char *arg)
3674
{
3675
    av_free (vstats_filename);
3676
    vstats_filename=av_strdup (arg);
3677
}
3678

    
3679
static void opt_vstats (void)
3680
{
3681
    char filename[40];
3682
    time_t today2 = time(NULL);
3683
    struct tm *today = localtime(&today2);
3684

    
3685
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3686
             today->tm_sec);
3687
    opt_vstats_file(filename);
3688
}
3689

    
3690
static int opt_bsf(const char *opt, const char *arg)
3691
{
3692
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3693
    AVBitStreamFilterContext **bsfp;
3694

    
3695
    if(!bsfc){
3696
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3697
        exit(1);
3698
    }
3699

    
3700
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3701
          *opt == 'a' ? &audio_bitstream_filters :
3702
                        &subtitle_bitstream_filters;
3703
    while(*bsfp)
3704
        bsfp= &(*bsfp)->next;
3705

    
3706
    *bsfp= bsfc;
3707

    
3708
    return 0;
3709
}
3710

    
3711
static void opt_show_license(void)
3712
{
3713
    show_license();
3714
    exit(0);
3715
}
3716

    
3717
static void opt_show_version(void)
3718
{
3719
    show_version(program_name);
3720
    exit(0);
3721
}
3722

    
3723
const OptionDef options[] = {
3724
    /* main options */
3725
    { "L", 0, {(void*)opt_show_license}, "show license" },
3726
    { "h", 0, {(void*)opt_show_help}, "show help" },
3727
    { "version", 0, {(void*)opt_show_version}, "show version" },
3728
    { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3729
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3730
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3731
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3732
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3733
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3734
    { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3735
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3736
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3737
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3738
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3739
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3740
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3741
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3742
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3743
    { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3744
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3745
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3746
      "add timings for benchmarking" },
3747
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3748
      "dump each input packet" },
3749
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3750
      "when dumping packets, also dump the payload" },
3751
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3752
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3753
    { "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)", "" },
3754
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3755
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3756
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3757
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3758
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3759
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3760
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3761
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3762
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3763
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3764
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3765

    
3766
    /* video options */
3767
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3768
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3769
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3770
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3771
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3772
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3773
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3774
    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3775
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3776
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3777
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3778
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3779
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3780
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3781
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3782
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3783
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3784
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3785
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3786
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3787
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3788
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3789
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3790
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3791
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3792
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3793
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3794
      "use same video quality as source (implies VBR)" },
3795
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3796
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3797
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3798
      "deinterlace pictures" },
3799
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3800
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3801
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3802
#ifdef CONFIG_VHOOK
3803
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3804
#endif
3805
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3806
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3807
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3808
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3809
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3810
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3811
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3812

    
3813
    /* audio options */
3814
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3815
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3816
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3817
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3818
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3819
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3820
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3821
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3822
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3823
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3824
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3825

    
3826
    /* subtitle options */
3827
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3828
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3829
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3830
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3831

    
3832
    /* grab options */
3833
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3834
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3835
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3836

    
3837
    /* muxer options */
3838
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3839
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3840

    
3841
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3842
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3843
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3844

    
3845
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3846
    { NULL, },
3847
};
3848

    
3849
static int av_exit()
3850
{
3851
    int i;
3852

    
3853
    /* close files */
3854
    for(i=0;i<nb_output_files;i++) {
3855
        /* maybe av_close_output_file ??? */
3856
        AVFormatContext *s = output_files[i];
3857
        int j;
3858
        if (!(s->oformat->flags & AVFMT_NOFILE))
3859
            url_fclose(s->pb);
3860
        for(j=0;j<s->nb_streams;j++) {
3861
            av_free(s->streams[j]->codec);
3862
            av_free(s->streams[j]);
3863
        }
3864
        av_free(s);
3865
    }
3866
    for(i=0;i<nb_input_files;i++)
3867
        av_close_input_file(input_files[i]);
3868

    
3869
    av_free_static();
3870

    
3871
    av_free(intra_matrix);
3872
    av_free(inter_matrix);
3873

    
3874
    if (vstats_file)
3875
        fclose(vstats_file);
3876
    av_free(vstats_filename);
3877

    
3878
    av_free(opt_names);
3879

    
3880
    av_free(video_codec_name);
3881
    av_free(audio_codec_name);
3882
    av_free(subtitle_codec_name);
3883

    
3884
    av_free(video_standard);
3885

    
3886
#ifdef CONFIG_POWERPC_PERF
3887
    extern void powerpc_display_perf_report(void);
3888
    powerpc_display_perf_report();
3889
#endif /* CONFIG_POWERPC_PERF */
3890

    
3891
    if (received_sigterm) {
3892
        fprintf(stderr,
3893
            "Received signal %d: terminating.\n",
3894
            (int) received_sigterm);
3895
        exit (255);
3896
    }
3897

    
3898
    exit(0); /* not all OS-es handle main() return value */
3899
    return 0;
3900
}
3901

    
3902
int main(int argc, char **argv)
3903
{
3904
    int i;
3905
    int64_t ti;
3906

    
3907
    avcodec_register_all();
3908
    avdevice_register_all();
3909
    av_register_all();
3910

    
3911
    for(i=0; i<CODEC_TYPE_NB; i++){
3912
        avctx_opts[i]= avcodec_alloc_context2(i);
3913
    }
3914
    avformat_opts = av_alloc_format_context();
3915
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3916

    
3917
    show_banner(program_name, program_birth_year);
3918
    if (argc <= 1) {
3919
        show_help();
3920
        exit(1);
3921
    }
3922

    
3923
    /* parse options */
3924
    parse_options(argc, argv, options, opt_output_file);
3925

    
3926
    /* file converter / grab */
3927
    if (nb_output_files <= 0) {
3928
        fprintf(stderr, "Must supply at least one output file\n");
3929
        exit(1);
3930
    }
3931

    
3932
    if (nb_input_files == 0) {
3933
        fprintf(stderr, "Must supply at least one input file\n");
3934
        exit(1);
3935
    }
3936

    
3937
    ti = getutime();
3938
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3939
              stream_maps, nb_stream_maps);
3940
    ti = getutime() - ti;
3941
    if (do_benchmark) {
3942
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3943
    }
3944

    
3945
    return av_exit();
3946
}