Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b3574faa

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
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
548

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

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

    
566
        ost->sync_opts += size_out / (2 * enc->channels);
567

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

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

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

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

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

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

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

    
644
    if (ENABLE_VHOOK)
645
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
646
                           1000000 * ist->pts / AV_TIME_BASE);
647

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
731
    *frame_size = 0;
732

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

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

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

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

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

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

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

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

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

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

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

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

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

    
882
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
883
                           int frame_size)
884
{
885
    AVCodecContext *enc;
886
    int frame_number;
887
    double ti1, bitrate, avg_bitrate;
888

    
889
    /* this is executed just the first time do_video_stats is called */
890
    if (!vstats_file) {
891
        vstats_file = fopen(vstats_filename, "w");
892
        if (!vstats_file) {
893
            perror("fopen");
894
            exit(1);
895
        }
896
    }
897

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

    
905
        fprintf(vstats_file,"f_size= %6d ", frame_size);
906
        /* compute pts value */
907
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
908
        if (ti1 < 0.01)
909
            ti1 = 0.01;
910

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

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

    
933
    if (!is_last_report) {
934
        int64_t cur_time;
935
        /* display the report every 0.5 seconds */
936
        cur_time = av_gettime();
937
        if (last_time == -1) {
938
            last_time = cur_time;
939
            return;
940
        }
941
        if ((cur_time - last_time) < 500000)
942
            return;
943
        last_time = cur_time;
944
    }
945

    
946

    
947
    oc = output_files[0];
948

    
949
    total_size = url_fsize(oc->pb);
950
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
951
        total_size= url_ftell(oc->pb);
952

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

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

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

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

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

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

    
1028
        fflush(stderr);
1029
    }
1030

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

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

    
1061
    if(ist->next_pts == AV_NOPTS_VALUE)
1062
        ist->next_pts= ist->pts;
1063

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

    
1071
    if(pkt->dts != AV_NOPTS_VALUE)
1072
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1073

    
1074
    len = pkt->size;
1075
    ptr = pkt->data;
1076
    while (len > 0) {
1077
    handle_eof:
1078
        ist->pts= ist->next_pts;
1079

    
1080
        if(len && len != pkt->size && verbose>0)
1081
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1082

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

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

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

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

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

    
1193
            ist->frame++;
1194
        }
1195

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

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

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

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

    
1251
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1252
                            continue;
1253

    
1254
                        /* no reencoding needed : output the packet directly */
1255
                        /* force the input stream PTS */
1256

    
1257
                        avcodec_get_frame_defaults(&avframe);
1258
                        ost->st->codec->coded_frame= &avframe;
1259
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1260

    
1261
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1262
                            audio_size += data_size;
1263
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1264
                            video_size += data_size;
1265
                            ost->sync_opts++;
1266
                        }
1267

    
1268
                        opkt.stream_index= ost->index;
1269
                        if(pkt->pts != AV_NOPTS_VALUE)
1270
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1271
                        else
1272
                            opkt.pts= AV_NOPTS_VALUE;
1273

    
1274
                            if (pkt->dts == AV_NOPTS_VALUE)
1275
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1276
                            else
1277
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1278

    
1279
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1280
                        opkt.flags= pkt->flags;
1281

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

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

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

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

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

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

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

    
1374
    return 0;
1375
 fail_decode:
1376
    return -1;
1377
}
1378

    
1379
static void print_sdp(AVFormatContext **avc, int n)
1380
{
1381
    char sdp[2048];
1382

    
1383
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1384
    printf("SDP:\n%s\n", sdp);
1385
}
1386

    
1387
static int stream_index_from_inputs(AVFormatContext **input_files,
1388
                                    int nb_input_files,
1389
                                    AVInputFile *file_table,
1390
                                    AVInputStream **ist_table,
1391
                                    enum CodecType type,
1392
                                    int programid)
1393
{
1394
    int p, q, z;
1395
    for(z=0; z<nb_input_files; z++) {
1396
        AVFormatContext *ic = input_files[z];
1397
        for(p=0; p<ic->nb_programs; p++) {
1398
            AVProgram *program = ic->programs[p];
1399
            if(program->id != programid)
1400
                continue;
1401
            for(q=0; q<program->nb_stream_indexes; q++) {
1402
                int sidx = program->stream_index[q];
1403
                int ris = file_table[z].ist_index + sidx;
1404
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1405
                    return ris;
1406
            }
1407
        }
1408
    }
1409

    
1410
    return -1;
1411
}
1412

    
1413
/*
1414
 * The following code is the main loop of the file converter
1415
 */
1416
static int av_encode(AVFormatContext **output_files,
1417
                     int nb_output_files,
1418
                     AVFormatContext **input_files,
1419
                     int nb_input_files,
1420
                     AVStreamMap *stream_maps, int nb_stream_maps)
1421
{
1422
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1423
    AVFormatContext *is, *os;
1424
    AVCodecContext *codec, *icodec;
1425
    AVOutputStream *ost, **ost_table = NULL;
1426
    AVInputStream *ist, **ist_table = NULL;
1427
    AVInputFile *file_table;
1428
    int key;
1429
    int want_sdp = 1;
1430

    
1431
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1432
    if (!file_table)
1433
        goto fail;
1434

    
1435
    /* input stream init */
1436
    j = 0;
1437
    for(i=0;i<nb_input_files;i++) {
1438
        is = input_files[i];
1439
        file_table[i].ist_index = j;
1440
        file_table[i].nb_streams = is->nb_streams;
1441
        j += is->nb_streams;
1442
    }
1443
    nb_istreams = j;
1444

    
1445
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1446
    if (!ist_table)
1447
        goto fail;
1448

    
1449
    for(i=0;i<nb_istreams;i++) {
1450
        ist = av_mallocz(sizeof(AVInputStream));
1451
        if (!ist)
1452
            goto fail;
1453
        ist_table[i] = ist;
1454
    }
1455
    j = 0;
1456
    for(i=0;i<nb_input_files;i++) {
1457
        is = input_files[i];
1458
        for(k=0;k<is->nb_streams;k++) {
1459
            ist = ist_table[j++];
1460
            ist->st = is->streams[k];
1461
            ist->file_index = i;
1462
            ist->index = k;
1463
            ist->discard = 1; /* the stream is discarded by default
1464
                                 (changed later) */
1465

    
1466
            if (ist->st->codec->rate_emu) {
1467
                ist->start = av_gettime();
1468
                ist->frame = 0;
1469
            }
1470
        }
1471
    }
1472

    
1473
    /* output stream init */
1474
    nb_ostreams = 0;
1475
    for(i=0;i<nb_output_files;i++) {
1476
        os = output_files[i];
1477
        if (!os->nb_streams) {
1478
            fprintf(stderr, "Output file does not contain any stream\n");
1479
            exit(1);
1480
        }
1481
        nb_ostreams += os->nb_streams;
1482
    }
1483
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1484
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1485
        exit(1);
1486
    }
1487

    
1488
    /* Sanity check the mapping args -- do the input files & streams exist? */
1489
    for(i=0;i<nb_stream_maps;i++) {
1490
        int fi = stream_maps[i].file_index;
1491
        int si = stream_maps[i].stream_index;
1492

    
1493
        if (fi < 0 || fi > nb_input_files - 1 ||
1494
            si < 0 || si > file_table[fi].nb_streams - 1) {
1495
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1496
            exit(1);
1497
        }
1498
        fi = stream_maps[i].sync_file_index;
1499
        si = stream_maps[i].sync_stream_index;
1500
        if (fi < 0 || fi > nb_input_files - 1 ||
1501
            si < 0 || si > file_table[fi].nb_streams - 1) {
1502
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1503
            exit(1);
1504
        }
1505
    }
1506

    
1507
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1508
    if (!ost_table)
1509
        goto fail;
1510
    for(i=0;i<nb_ostreams;i++) {
1511
        ost = av_mallocz(sizeof(AVOutputStream));
1512
        if (!ost)
1513
            goto fail;
1514
        ost_table[i] = ost;
1515
    }
1516

    
1517
    n = 0;
1518
    for(k=0;k<nb_output_files;k++) {
1519
        os = output_files[k];
1520
        for(i=0;i<os->nb_streams;i++) {
1521
            int found;
1522
            ost = ost_table[n++];
1523
            ost->file_index = k;
1524
            ost->index = i;
1525
            ost->st = os->streams[i];
1526
            if (nb_stream_maps > 0) {
1527
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1528
                    stream_maps[n-1].stream_index;
1529

    
1530
                /* Sanity check that the stream types match */
1531
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1532
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1533
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1534
                        ost->file_index, ost->index);
1535
                    exit(1);
1536
                }
1537

    
1538
            } else {
1539
                if(opt_programid) {
1540
                    found = 0;
1541
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1542
                    if(j != -1) {
1543
                        ost->source_index = j;
1544
                        found = 1;
1545
                    }
1546
                } else {
1547
                    /* get corresponding input stream index : we select the first one with the right type */
1548
                    found = 0;
1549
                    for(j=0;j<nb_istreams;j++) {
1550
                        ist = ist_table[j];
1551
                        if (ist->discard &&
1552
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1553
                            ost->source_index = j;
1554
                            found = 1;
1555
                            break;
1556
                        }
1557
                    }
1558
                }
1559

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

    
1586
    /* for each output stream, we compute the right encoding parameters */
1587
    for(i=0;i<nb_ostreams;i++) {
1588
        ost = ost_table[i];
1589
        os = output_files[ost->file_index];
1590
        ist = ist_table[ost->source_index];
1591

    
1592
        codec = ost->st->codec;
1593
        icodec = ist->st->codec;
1594

    
1595
        if (!ost->st->language[0])
1596
            av_strlcpy(ost->st->language, ist->st->language,
1597
                       sizeof(ost->st->language));
1598

    
1599
        if (ost->st->stream_copy) {
1600
            /* if stream_copy is selected, no need to decode or encode */
1601
            codec->codec_id = icodec->codec_id;
1602
            codec->codec_type = icodec->codec_type;
1603

    
1604
            if(!codec->codec_tag){
1605
                if(   !os->oformat->codec_tag
1606
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1607
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1608
                    codec->codec_tag = icodec->codec_tag;
1609
            }
1610

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

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

    
1757
    if (!bit_buffer)
1758
        bit_buffer = av_malloc(bit_buffer_size);
1759
    if (!bit_buffer)
1760
        goto fail;
1761

    
1762
    /* dump the file output parameters - cannot be done before in case
1763
       of stream copy */
1764
    for(i=0;i<nb_output_files;i++) {
1765
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1766
    }
1767

    
1768
    /* dump the stream mapping */
1769
    if (verbose >= 0) {
1770
        fprintf(stderr, "Stream mapping:\n");
1771
        for(i=0;i<nb_ostreams;i++) {
1772
            ost = ost_table[i];
1773
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1774
                    ist_table[ost->source_index]->file_index,
1775
                    ist_table[ost->source_index]->index,
1776
                    ost->file_index,
1777
                    ost->index);
1778
            if (ost->sync_ist != ist_table[ost->source_index])
1779
                fprintf(stderr, " [sync #%d.%d]",
1780
                        ost->sync_ist->file_index,
1781
                        ost->sync_ist->index);
1782
            fprintf(stderr, "\n");
1783
        }
1784
    }
1785

    
1786
    /* open each encoder */
1787
    for(i=0;i<nb_ostreams;i++) {
1788
        ost = ost_table[i];
1789
        if (ost->encoding_needed) {
1790
            AVCodec *codec;
1791
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1792
            if (!codec) {
1793
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1794
                        ost->file_index, ost->index);
1795
                exit(1);
1796
            }
1797
            if (avcodec_open(ost->st->codec, codec) < 0) {
1798
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1799
                        ost->file_index, ost->index);
1800
                exit(1);
1801
            }
1802
            extra_size += ost->st->codec->extradata_size;
1803
        }
1804
    }
1805

    
1806
    /* open each decoder */
1807
    for(i=0;i<nb_istreams;i++) {
1808
        ist = ist_table[i];
1809
        if (ist->decoding_needed) {
1810
            AVCodec *codec;
1811
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1812
            if (!codec) {
1813
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1814
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1815
                exit(1);
1816
            }
1817
            if (avcodec_open(ist->st->codec, codec) < 0) {
1818
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1819
                        ist->file_index, ist->index);
1820
                exit(1);
1821
            }
1822
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1823
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1824
        }
1825
    }
1826

    
1827
    /* init pts */
1828
    for(i=0;i<nb_istreams;i++) {
1829
        ist = ist_table[i];
1830
        is = input_files[ist->file_index];
1831
        ist->pts = 0;
1832
        ist->next_pts = AV_NOPTS_VALUE;
1833
        ist->is_start = 1;
1834
    }
1835

    
1836
    /* set meta data information from input file if required */
1837
    for (i=0;i<nb_meta_data_maps;i++) {
1838
        AVFormatContext *out_file;
1839
        AVFormatContext *in_file;
1840

    
1841
        int out_file_index = meta_data_maps[i].out_file;
1842
        int in_file_index = meta_data_maps[i].in_file;
1843
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1844
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1845
            ret = AVERROR(EINVAL);
1846
            goto fail;
1847
        }
1848
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1849
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1850
            ret = AVERROR(EINVAL);
1851
            goto fail;
1852
        }
1853

    
1854
        out_file = output_files[out_file_index];
1855
        in_file = input_files[in_file_index];
1856

    
1857
        strcpy(out_file->title, in_file->title);
1858
        strcpy(out_file->author, in_file->author);
1859
        strcpy(out_file->copyright, in_file->copyright);
1860
        strcpy(out_file->comment, in_file->comment);
1861
        strcpy(out_file->album, in_file->album);
1862
        out_file->year = in_file->year;
1863
        out_file->track = in_file->track;
1864
        strcpy(out_file->genre, in_file->genre);
1865
    }
1866

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

    
1883
    if ( !using_stdin && verbose >= 0) {
1884
        fprintf(stderr, "Press [q] to stop encoding\n");
1885
        url_set_interrupt_cb(decode_interrupt_cb);
1886
    }
1887
    term_init();
1888

    
1889
    key = -1;
1890
    timer_start = av_gettime();
1891

    
1892
    for(; received_sigterm == 0;) {
1893
        int file_index, ist_index;
1894
        AVPacket pkt;
1895
        double ipts_min;
1896
        double opts_min;
1897

    
1898
    redo:
1899
        ipts_min= 1e100;
1900
        opts_min= 1e100;
1901
        /* if 'q' pressed, exits */
1902
        if (!using_stdin) {
1903
            if (q_pressed)
1904
                break;
1905
            /* read_key() returns 0 on EOF */
1906
            key = read_key();
1907
            if (key == 'q')
1908
                break;
1909
        }
1910

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

    
1944
        /* finish if recording time exhausted */
1945
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1946
            break;
1947

    
1948
        /* finish if limit size exhausted */
1949
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1950
            break;
1951

    
1952
        /* read a frame from it and output it in the fifo */
1953
        is = input_files[file_index];
1954
        if (av_read_frame(is, &pkt) < 0) {
1955
            file_table[file_index].eof_reached = 1;
1956
            if (opt_shortest)
1957
                break;
1958
            else
1959
                continue;
1960
        }
1961

    
1962
        if (do_pkt_dump) {
1963
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1964
        }
1965
        /* the following test is needed in case new streams appear
1966
           dynamically in stream : we ignore them */
1967
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1968
            goto discard_packet;
1969
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1970
        ist = ist_table[ist_index];
1971
        if (ist->discard)
1972
            goto discard_packet;
1973

    
1974
        if (pkt.dts != AV_NOPTS_VALUE)
1975
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1976
        if (pkt.pts != AV_NOPTS_VALUE)
1977
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1978

    
1979
//        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);
1980
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1981
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1982
            int64_t delta= pkt_dts - ist->next_pts;
1983
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1984
                input_files_ts_offset[ist->file_index]-= delta;
1985
                if (verbose > 2)
1986
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1987
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1988
                if(pkt.pts != AV_NOPTS_VALUE)
1989
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1990
            }
1991
        }
1992

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

    
1996
            if (verbose >= 0)
1997
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1998
                        ist->file_index, ist->index);
1999

    
2000
            av_free_packet(&pkt);
2001
            goto redo;
2002
        }
2003

    
2004
    discard_packet:
2005
        av_free_packet(&pkt);
2006

    
2007
        /* dump report by using the output first video and audio streams */
2008
        print_report(output_files, ost_table, nb_ostreams, 0);
2009
    }
2010

    
2011
    /* at the end of stream, we must flush the decoder buffers */
2012
    for(i=0;i<nb_istreams;i++) {
2013
        ist = ist_table[i];
2014
        if (ist->decoding_needed) {
2015
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2016
        }
2017
    }
2018

    
2019
    term_exit();
2020

    
2021
    /* write the trailer if needed and close file */
2022
    for(i=0;i<nb_output_files;i++) {
2023
        os = output_files[i];
2024
        av_write_trailer(os);
2025
    }
2026

    
2027
    /* dump report by using the first video and audio streams */
2028
    print_report(output_files, ost_table, nb_ostreams, 1);
2029

    
2030
    /* close each encoder */
2031
    for(i=0;i<nb_ostreams;i++) {
2032
        ost = ost_table[i];
2033
        if (ost->encoding_needed) {
2034
            av_freep(&ost->st->codec->stats_in);
2035
            avcodec_close(ost->st->codec);
2036
        }
2037
    }
2038

    
2039
    /* close each decoder */
2040
    for(i=0;i<nb_istreams;i++) {
2041
        ist = ist_table[i];
2042
        if (ist->decoding_needed) {
2043
            avcodec_close(ist->st->codec);
2044
        }
2045
    }
2046

    
2047
    /* finished ! */
2048

    
2049
    ret = 0;
2050
 fail1:
2051
    av_freep(&bit_buffer);
2052
    av_free(file_table);
2053

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

    
2087
#if 0
2088
int file_read(const char *filename)
2089
{
2090
    URLContext *h;
2091
    unsigned char buffer[1024];
2092
    int len, i;
2093

2094
    if (url_open(&h, filename, O_RDONLY) < 0) {
2095
        printf("could not open '%s'\n", filename);
2096
        return -1;
2097
    }
2098
    for(;;) {
2099
        len = url_read(h, buffer, sizeof(buffer));
2100
        if (len <= 0)
2101
            break;
2102
        for(i=0;i<len;i++) putchar(buffer[i]);
2103
    }
2104
    url_close(h);
2105
    return 0;
2106
}
2107
#endif
2108

    
2109
static void opt_format(const char *arg)
2110
{
2111
    /* compatibility stuff for pgmyuv */
2112
    if (!strcmp(arg, "pgmyuv")) {
2113
        pgmyuv_compatibility_hack=1;
2114
//        opt_image_format(arg);
2115
        arg = "image2";
2116
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2117
    }
2118

    
2119
    file_iformat = av_find_input_format(arg);
2120
    file_oformat = guess_format(arg, NULL, NULL);
2121
    if (!file_iformat && !file_oformat) {
2122
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2123
        exit(1);
2124
    }
2125
}
2126

    
2127
extern int ffm_nopts;
2128

    
2129
static int opt_default(const char *opt, const char *arg){
2130
    int type;
2131
    const AVOption *o= NULL;
2132
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2133

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

    
2154
//    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));
2155

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

    
2160
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2161
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
2162
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2163
        ffm_nopts = 1;
2164
#endif
2165

    
2166
    if(avctx_opts[0]->debug)
2167
        av_log_set_level(AV_LOG_DEBUG);
2168
    return 0;
2169
}
2170

    
2171
static void opt_video_rc_override_string(const char *arg)
2172
{
2173
    video_rc_override_string = arg;
2174
}
2175

    
2176
static void opt_me_threshold(const char *arg)
2177
{
2178
    me_threshold = atoi(arg);
2179
}
2180

    
2181
static void opt_verbose(const char *arg)
2182
{
2183
    verbose = atoi(arg);
2184
    av_log_set_level(verbose);
2185
}
2186

    
2187
static void opt_frame_rate(const char *arg)
2188
{
2189
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2190
        fprintf(stderr, "Incorrect frame rate\n");
2191
        exit(1);
2192
    }
2193
}
2194

    
2195
static int opt_bitrate(const char *opt, const char *arg)
2196
{
2197
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2198

    
2199
    opt_default(opt, arg);
2200

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

    
2204
    return 0;
2205
}
2206

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

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

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

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

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

    
2291

    
2292
#define SCALEBITS 10
2293
#define ONE_HALF  (1 << (SCALEBITS - 1))
2294
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2295

    
2296
#define RGB_TO_Y(r, g, b) \
2297
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2298
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2299

    
2300
#define RGB_TO_U(r1, g1, b1, shift)\
2301
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2302
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2303

    
2304
#define RGB_TO_V(r1, g1, b1, shift)\
2305
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2306
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2307

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

    
2314
    r = (rgb >> 16);
2315
    g = ((rgb >> 8) & 255);
2316
    b = (rgb & 255);
2317

    
2318
    padcolor[0] = RGB_TO_Y(r,g,b);
2319
    padcolor[1] = RGB_TO_U(r,g,b,0);
2320
    padcolor[2] = RGB_TO_V(r,g,b,0);
2321
}
2322

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

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

    
2349

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

    
2363

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

    
2377
void list_pix_fmts(void)
2378
{
2379
    int i;
2380
    char pix_fmt_str[128];
2381
    for (i=-1; i < PIX_FMT_NB; i++) {
2382
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2383
        fprintf(stdout, "%s\n", pix_fmt_str);
2384
    }
2385
}
2386

    
2387
static void opt_frame_pix_fmt(const char *arg)
2388
{
2389
    if (strcmp(arg, "list"))
2390
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2391
    else {
2392
        list_pix_fmts();
2393
        exit(0);
2394
    }
2395
}
2396

    
2397
static void opt_frame_aspect_ratio(const char *arg)
2398
{
2399
    int x = 0, y = 0;
2400
    double ar = 0;
2401
    const char *p;
2402
    char *end;
2403

    
2404
    p = strchr(arg, ':');
2405
    if (p) {
2406
        x = strtol(arg, &end, 10);
2407
        if (end == p)
2408
            y = strtol(end+1, &end, 10);
2409
        if (x > 0 && y > 0)
2410
            ar = (double)x / (double)y;
2411
    } else
2412
        ar = strtod(arg, NULL);
2413

    
2414
    if (!ar) {
2415
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2416
        exit(1);
2417
    }
2418
    frame_aspect_ratio = ar;
2419
}
2420

    
2421
static void opt_qscale(const char *arg)
2422
{
2423
    video_qscale = atof(arg);
2424
    if (video_qscale <= 0 ||
2425
        video_qscale > 255) {
2426
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2427
        exit(1);
2428
    }
2429
}
2430

    
2431
static void opt_qdiff(const char *arg)
2432
{
2433
    video_qdiff = atoi(arg);
2434
    if (video_qdiff < 0 ||
2435
        video_qdiff > 31) {
2436
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2437
        exit(1);
2438
    }
2439
}
2440

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

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

    
2451
static void opt_thread_count(const char *arg)
2452
{
2453
    thread_count= atoi(arg);
2454
#if !defined(HAVE_THREADS)
2455
    if (verbose >= 0)
2456
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2457
#endif
2458
}
2459

    
2460
static void opt_audio_rate(const char *arg)
2461
{
2462
    audio_sample_rate = atoi(arg);
2463
}
2464

    
2465
static void opt_audio_channels(const char *arg)
2466
{
2467
    audio_channels = atoi(arg);
2468
}
2469

    
2470
static void opt_video_channel(const char *arg)
2471
{
2472
    video_channel = strtol(arg, NULL, 0);
2473
}
2474

    
2475
static void opt_video_standard(const char *arg)
2476
{
2477
    video_standard = av_strdup(arg);
2478
}
2479

    
2480
static void opt_codec(int *pstream_copy, char **pcodec_name,
2481
                      int codec_type, const char *arg)
2482
{
2483
    av_freep(pcodec_name);
2484
    if (!strcmp(arg, "copy")) {
2485
        *pstream_copy = 1;
2486
    } else {
2487
        *pcodec_name = av_strdup(arg);
2488
    }
2489
}
2490

    
2491
static void opt_audio_codec(const char *arg)
2492
{
2493
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2494
}
2495

    
2496
static void opt_audio_tag(const char *arg)
2497
{
2498
    char *tail;
2499
    audio_codec_tag= strtol(arg, &tail, 0);
2500

    
2501
    if(!tail || *tail)
2502
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2503
}
2504

    
2505
static void opt_video_tag(const char *arg)
2506
{
2507
    char *tail;
2508
    video_codec_tag= strtol(arg, &tail, 0);
2509

    
2510
    if(!tail || *tail)
2511
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2512
}
2513

    
2514
#ifdef CONFIG_VHOOK
2515
static void add_frame_hooker(const char *arg)
2516
{
2517
    int argc = 0;
2518
    char *argv[64];
2519
    int i;
2520
    char *args = av_strdup(arg);
2521

    
2522
    using_vhook = 1;
2523

    
2524
    argv[0] = strtok(args, " ");
2525
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2526
    }
2527

    
2528
    i = frame_hook_add(argc, argv);
2529

    
2530
    if (i != 0) {
2531
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2532
        exit(1);
2533
    }
2534
}
2535
#endif
2536

    
2537
static void opt_video_codec(const char *arg)
2538
{
2539
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2540
}
2541

    
2542
static void opt_subtitle_codec(const char *arg)
2543
{
2544
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2545
}
2546

    
2547
static void opt_map(const char *arg)
2548
{
2549
    AVStreamMap *m;
2550
    char *p;
2551

    
2552
    m = &stream_maps[nb_stream_maps++];
2553

    
2554
    m->file_index = strtol(arg, &p, 0);
2555
    if (*p)
2556
        p++;
2557

    
2558
    m->stream_index = strtol(p, &p, 0);
2559
    if (*p) {
2560
        p++;
2561
        m->sync_file_index = strtol(p, &p, 0);
2562
        if (*p)
2563
            p++;
2564
        m->sync_stream_index = strtol(p, &p, 0);
2565
    } else {
2566
        m->sync_file_index = m->file_index;
2567
        m->sync_stream_index = m->stream_index;
2568
    }
2569
}
2570

    
2571
static void opt_map_meta_data(const char *arg)
2572
{
2573
    AVMetaDataMap *m;
2574
    char *p;
2575

    
2576
    m = &meta_data_maps[nb_meta_data_maps++];
2577

    
2578
    m->out_file = strtol(arg, &p, 0);
2579
    if (*p)
2580
        p++;
2581

    
2582
    m->in_file = strtol(p, &p, 0);
2583
}
2584

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

    
2596
static void opt_recording_time(const char *arg)
2597
{
2598
    recording_time = parse_time_or_die(arg, 1);
2599
}
2600

    
2601
static void opt_start_time(const char *arg)
2602
{
2603
    start_time = parse_time_or_die(arg, 1);
2604
}
2605

    
2606
static void opt_rec_timestamp(const char *arg)
2607
{
2608
    rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2609
}
2610

    
2611
static void opt_input_ts_offset(const char *arg)
2612
{
2613
    input_ts_offset = parse_time_or_die(arg, 1);
2614
}
2615

    
2616
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2617
{
2618
    const char *codec_string = encoder ? "encoder" : "decoder";
2619
    AVCodec *codec;
2620

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

    
2637
static void opt_input_file(const char *filename)
2638
{
2639
    AVFormatContext *ic;
2640
    AVFormatParameters params, *ap = &params;
2641
    int err, i, ret, rfps, rfps_base;
2642
    int64_t timestamp;
2643

    
2644
    if (!strcmp(filename, "-"))
2645
        filename = "pipe:";
2646

    
2647
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2648
                   !strcmp( filename, "/dev/stdin" );
2649

    
2650
    /* get default parameters from command line */
2651
    ic = av_alloc_format_context();
2652

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

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

    
2677
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2678
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2679
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2680

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

    
2694
    ic->loop_input = loop_input;
2695

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

    
2704
    timestamp = start_time;
2705
    /* add the stream start time */
2706
    if (ic->start_time != AV_NOPTS_VALUE)
2707
        timestamp += ic->start_time;
2708

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

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

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

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

    
2766
                    (float)rfps / rfps_base, rfps, rfps_base);
2767
            }
2768
            /* update the current frame rate to match the stream frame rate */
2769
            frame_rate.num = rfps;
2770
            frame_rate.den = rfps_base;
2771

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

    
2792
    input_files[nb_input_files] = ic;
2793
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2794
    /* dump the file content */
2795
    if (verbose >= 0)
2796
        dump_format(ic, nb_input_files, filename, 0);
2797

    
2798
    nb_input_files++;
2799
    file_iformat = NULL;
2800
    file_oformat = NULL;
2801

    
2802
    video_channel = 0;
2803

    
2804
    rate_emu = 0;
2805
    av_freep(&video_codec_name);
2806
    av_freep(&audio_codec_name);
2807
    av_freep(&subtitle_codec_name);
2808
}
2809

    
2810
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2811
                                         int *has_subtitle_ptr)
2812
{
2813
    int has_video, has_audio, has_subtitle, i, j;
2814
    AVFormatContext *ic;
2815

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

    
2847
static void new_video_stream(AVFormatContext *oc)
2848
{
2849
    AVStream *st;
2850
    AVCodecContext *video_enc;
2851
    int codec_id;
2852

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

    
2862
    if(thread_count>1)
2863
        avcodec_thread_init(st->codec, thread_count);
2864

    
2865
    video_enc = st->codec;
2866

    
2867
    if(video_codec_tag)
2868
        video_enc->codec_tag= video_codec_tag;
2869

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

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

    
2889
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2890
        if (video_codec_name)
2891
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2892

    
2893
        video_enc->codec_id = codec_id;
2894
        codec = avcodec_find_encoder(codec_id);
2895

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

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

    
2922
        video_enc->width = frame_width + frame_padright + frame_padleft;
2923
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2924
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2925
        video_enc->pix_fmt = frame_pix_fmt;
2926

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

    
2937
        if (intra_only)
2938
            video_enc->gop_size = 0;
2939
        if (video_qscale || same_quality) {
2940
            video_enc->flags |= CODEC_FLAG_QSCALE;
2941
            video_enc->global_quality=
2942
                st->quality = FF_QP2LAMBDA * video_qscale;
2943
        }
2944

    
2945
        if(intra_matrix)
2946
            video_enc->intra_matrix = intra_matrix;
2947
        if(inter_matrix)
2948
            video_enc->inter_matrix = inter_matrix;
2949

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

    
2983
        if (do_psnr)
2984
            video_enc->flags|= CODEC_FLAG_PSNR;
2985

    
2986
        /* two pass mode */
2987
        if (do_pass) {
2988
            if (do_pass == 1) {
2989
                video_enc->flags |= CODEC_FLAG_PASS1;
2990
            } else {
2991
                video_enc->flags |= CODEC_FLAG_PASS2;
2992
            }
2993
        }
2994
    }
2995

    
2996
    /* reset some key parameters */
2997
    video_disable = 0;
2998
    av_freep(&video_codec_name);
2999
    video_stream_copy = 0;
3000
}
3001

    
3002
static void new_audio_stream(AVFormatContext *oc)
3003
{
3004
    AVStream *st;
3005
    AVCodecContext *audio_enc;
3006
    int codec_id, i;
3007

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

    
3015
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3016
    audio_bitstream_filters= NULL;
3017

    
3018
    if(thread_count>1)
3019
        avcodec_thread_init(st->codec, thread_count);
3020

    
3021
    audio_enc = st->codec;
3022
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3023
    audio_enc->strict_std_compliance = strict;
3024

    
3025
    if(audio_codec_tag)
3026
        audio_enc->codec_tag= audio_codec_tag;
3027

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

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

    
3046
        if (audio_codec_name)
3047
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3048
        audio_enc->codec_id = codec_id;
3049

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

    
3065
    /* reset some key parameters */
3066
    audio_disable = 0;
3067
    av_freep(&audio_codec_name);
3068
    audio_stream_copy = 0;
3069
}
3070

    
3071
static void new_subtitle_stream(AVFormatContext *oc)
3072
{
3073
    AVStream *st;
3074
    AVCodecContext *subtitle_enc;
3075
    int i;
3076

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

    
3084
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3085
    subtitle_bitstream_filters= NULL;
3086

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

    
3102
    if (subtitle_language) {
3103
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3104
        av_free(subtitle_language);
3105
        subtitle_language = NULL;
3106
    }
3107

    
3108
    subtitle_disable = 0;
3109
    av_freep(&subtitle_codec_name);
3110
    subtitle_stream_copy = 0;
3111
}
3112

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

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

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

    
3146
static void opt_output_file(const char *filename)
3147
{
3148
    AVFormatContext *oc;
3149
    int use_video, use_audio, use_subtitle;
3150
    int input_has_video, input_has_audio, input_has_subtitle, i;
3151
    AVFormatParameters params, *ap = &params;
3152

    
3153
    if (!strcmp(filename, "-"))
3154
        filename = "pipe:";
3155

    
3156
    oc = av_alloc_format_context();
3157

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

    
3167
    oc->oformat = file_oformat;
3168
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3169

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

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

    
3196
        /* manual disable */
3197
        if (audio_disable) {
3198
            use_audio = 0;
3199
        }
3200
        if (video_disable) {
3201
            use_video = 0;
3202
        }
3203
        if (subtitle_disable) {
3204
            use_subtitle = 0;
3205
        }
3206

    
3207
        if (use_video) {
3208
            new_video_stream(oc);
3209
        }
3210

    
3211
        if (use_audio) {
3212
            new_audio_stream(oc);
3213
        }
3214

    
3215
        if (use_subtitle) {
3216
            new_subtitle_stream(oc);
3217
        }
3218

    
3219
        oc->timestamp = rec_timestamp;
3220

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

    
3235
    output_files[nb_output_files++] = oc;
3236

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

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

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

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

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

    
3284
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3285
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3286
    oc->loop_output = loop_output;
3287

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

    
3296
    /* reset some options */
3297
    file_oformat = NULL;
3298
    file_iformat = NULL;
3299
}
3300

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

    
3313
static int64_t getutime(void)
3314
{
3315
#ifdef HAVE_GETRUSAGE
3316
    struct rusage rusage;
3317

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

    
3331
static void opt_show_formats(void)
3332
{
3333
    AVInputFormat *ifmt=NULL;
3334
    AVOutputFormat *ofmt=NULL;
3335
    URLProtocol *up=NULL;
3336
    AVCodec *p=NULL, *p2;
3337
    AVBitStreamFilter *bsf=NULL;
3338
    const char *last_name;
3339

    
3340
    printf("File formats:\n");
3341
    last_name= "000";
3342
    for(;;){
3343
        int decode=0;
3344
        int encode=0;
3345
        const char *name=NULL;
3346
        const char *long_name=NULL;
3347

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

    
3370
        printf(
3371
            " %s%s %-15s %s\n",
3372
            decode ? "D":" ",
3373
            encode ? "E":" ",
3374
            name,
3375
            long_name ? long_name:" ");
3376
    }
3377
    printf("\n");
3378

    
3379
    printf("Codecs:\n");
3380
    last_name= "000";
3381
    for(;;){
3382
        int decode=0;
3383
        int encode=0;
3384
        int cap=0;
3385
        const char *type_str;
3386

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

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

    
3433
    printf("Bitstream filters:\n");
3434
    while((bsf = av_bitstream_filter_next(bsf)))
3435
        printf(" %s", bsf->name);
3436
    printf("\n");
3437

    
3438
    printf("Supported file protocols:\n");
3439
    while((up = av_protocol_next(up)))
3440
        printf(" %s:", up->name);
3441
    printf("\n");
3442

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

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

    
3471
static void opt_inter_matrix(const char *arg)
3472
{
3473
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3474
    parse_matrix_coeffs(inter_matrix, arg);
3475
}
3476

    
3477
static void opt_intra_matrix(const char *arg)
3478
{
3479
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3480
    parse_matrix_coeffs(intra_matrix, arg);
3481
}
3482

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

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

    
3526
static void opt_show_help(void)
3527
{
3528
    show_help();
3529
    exit(0);
3530
}
3531

    
3532
static void opt_target(const char *arg)
3533
{
3534
    int norm = -1;
3535
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3536

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

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

    
3588
    if(!strcmp(arg, "vcd")) {
3589

    
3590
        opt_video_codec("mpeg1video");
3591
        opt_audio_codec("mp2");
3592
        opt_format("vcd");
3593

    
3594
        opt_frame_size(norm ? "352x240" : "352x288");
3595
        opt_frame_rate(frame_rates[norm]);
3596
        opt_default("gop", norm ? "18" : "15");
3597

    
3598
        opt_default("b", "1150000");
3599
        opt_default("maxrate", "1150000");
3600
        opt_default("minrate", "1150000");
3601
        opt_default("bufsize", "327680"); // 40*1024*8;
3602

    
3603
        opt_default("ab", "224000");
3604
        audio_sample_rate = 44100;
3605
        audio_channels = 2;
3606

    
3607
        opt_default("packetsize", "2324");
3608
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3609

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

    
3618
        opt_video_codec("mpeg2video");
3619
        opt_audio_codec("mp2");
3620
        opt_format("svcd");
3621

    
3622
        opt_frame_size(norm ? "480x480" : "480x576");
3623
        opt_frame_rate(frame_rates[norm]);
3624
        opt_default("gop", norm ? "18" : "15");
3625

    
3626
        opt_default("b", "2040000");
3627
        opt_default("maxrate", "2516000");
3628
        opt_default("minrate", "0"); //1145000;
3629
        opt_default("bufsize", "1835008"); //224*1024*8;
3630
        opt_default("flags", "+SCAN_OFFSET");
3631

    
3632

    
3633
        opt_default("ab", "224000");
3634
        audio_sample_rate = 44100;
3635

    
3636
        opt_default("packetsize", "2324");
3637

    
3638
    } else if(!strcmp(arg, "dvd")) {
3639

    
3640
        opt_video_codec("mpeg2video");
3641
        opt_audio_codec("ac3");
3642
        opt_format("dvd");
3643

    
3644
        opt_frame_size(norm ? "720x480" : "720x576");
3645
        opt_frame_rate(frame_rates[norm]);
3646
        opt_default("gop", norm ? "18" : "15");
3647

    
3648
        opt_default("b", "6000000");
3649
        opt_default("maxrate", "9000000");
3650
        opt_default("minrate", "0"); //1500000;
3651
        opt_default("bufsize", "1835008"); //224*1024*8;
3652

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

    
3656
        opt_default("ab", "448000");
3657
        audio_sample_rate = 48000;
3658

    
3659
    } else if(!strncmp(arg, "dv", 2)) {
3660

    
3661
        opt_format("dv");
3662

    
3663
        opt_frame_size(norm ? "720x480" : "720x576");
3664
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3665
                                             (norm ? "yuv411p" : "yuv420p"));
3666
        opt_frame_rate(frame_rates[norm]);
3667

    
3668
        audio_sample_rate = 48000;
3669
        audio_channels = 2;
3670

    
3671
    } else {
3672
        fprintf(stderr, "Unknown target: %s\n", arg);
3673
        exit(1);
3674
    }
3675
}
3676

    
3677
static void opt_vstats_file (const char *arg)
3678
{
3679
    av_free (vstats_filename);
3680
    vstats_filename=av_strdup (arg);
3681
}
3682

    
3683
static void opt_vstats (void)
3684
{
3685
    char filename[40];
3686
    time_t today2 = time(NULL);
3687
    struct tm *today = localtime(&today2);
3688

    
3689
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3690
             today->tm_sec);
3691
    opt_vstats_file(filename);
3692
}
3693

    
3694
static int opt_bsf(const char *opt, const char *arg)
3695
{
3696
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3697
    AVBitStreamFilterContext **bsfp;
3698

    
3699
    if(!bsfc){
3700
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3701
        exit(1);
3702
    }
3703

    
3704
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3705
          *opt == 'a' ? &audio_bitstream_filters :
3706
                        &subtitle_bitstream_filters;
3707
    while(*bsfp)
3708
        bsfp= &(*bsfp)->next;
3709

    
3710
    *bsfp= bsfc;
3711

    
3712
    return 0;
3713
}
3714

    
3715
static void opt_show_license(void)
3716
{
3717
    show_license();
3718
    exit(0);
3719
}
3720

    
3721
static void opt_show_version(void)
3722
{
3723
    show_version(program_name);
3724
    exit(0);
3725
}
3726

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

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

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

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

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

    
3841
    /* muxer options */
3842
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3843
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3844

    
3845
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3846
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3847
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3848

    
3849
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3850
    { NULL, },
3851
};
3852

    
3853
static int av_exit()
3854
{
3855
    int i;
3856

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

    
3873
    av_free_static();
3874

    
3875
    av_free(intra_matrix);
3876
    av_free(inter_matrix);
3877

    
3878
    if (vstats_file)
3879
        fclose(vstats_file);
3880
    av_free(vstats_filename);
3881

    
3882
    av_free(opt_names);
3883

    
3884
    av_free(video_codec_name);
3885
    av_free(audio_codec_name);
3886
    av_free(subtitle_codec_name);
3887

    
3888
    av_free(video_standard);
3889

    
3890
#ifdef CONFIG_POWERPC_PERF
3891
    extern void powerpc_display_perf_report(void);
3892
    powerpc_display_perf_report();
3893
#endif /* CONFIG_POWERPC_PERF */
3894

    
3895
    if (received_sigterm) {
3896
        fprintf(stderr,
3897
            "Received signal %d: terminating.\n",
3898
            (int) received_sigterm);
3899
        exit (255);
3900
    }
3901

    
3902
    exit(0); /* not all OS-es handle main() return value */
3903
    return 0;
3904
}
3905

    
3906
int main(int argc, char **argv)
3907
{
3908
    int i;
3909
    int64_t ti;
3910

    
3911
    avcodec_register_all();
3912
    avdevice_register_all();
3913
    av_register_all();
3914

    
3915
    for(i=0; i<CODEC_TYPE_NB; i++){
3916
        avctx_opts[i]= avcodec_alloc_context2(i);
3917
    }
3918
    avformat_opts = av_alloc_format_context();
3919
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3920

    
3921
    show_banner(program_name, program_birth_year);
3922
    if (argc <= 1) {
3923
        show_help();
3924
        exit(1);
3925
    }
3926

    
3927
    /* parse options */
3928
    parse_options(argc, argv, options, opt_output_file);
3929

    
3930
    /* file converter / grab */
3931
    if (nb_output_files <= 0) {
3932
        fprintf(stderr, "Must supply at least one output file\n");
3933
        exit(1);
3934
    }
3935

    
3936
    if (nb_input_files == 0) {
3937
        fprintf(stderr, "Must supply at least one input file\n");
3938
        exit(1);
3939
    }
3940

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

    
3949
    return av_exit();
3950
}