Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 01a3c821

History | View | Annotate | Download (144 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
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

    
25
#include "config.h"
26
#include <ctype.h>
27
#include <string.h>
28
#include <math.h>
29
#include <stdlib.h>
30
#include <errno.h>
31
#include <signal.h>
32
#include <limits.h>
33
#include <unistd.h>
34
#include "libavformat/avformat.h"
35
#include "libavdevice/avdevice.h"
36
#include "libswscale/swscale.h"
37
#include "libavcodec/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavcodec/colorspace.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/avstring.h"
42
#include "libavformat/os_support.h"
43

    
44
#if HAVE_SYS_RESOURCE_H
45
#include <sys/types.h>
46
#include <sys/resource.h>
47
#elif HAVE_GETPROCESSTIMES
48
#include <windows.h>
49
#endif
50

    
51
#if HAVE_SYS_SELECT_H
52
#include <sys/select.h>
53
#endif
54

    
55
#if HAVE_TERMIOS_H
56
#include <fcntl.h>
57
#include <sys/ioctl.h>
58
#include <sys/time.h>
59
#include <termios.h>
60
#elif HAVE_CONIO_H
61
#include <conio.h>
62
#endif
63
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
64
#include <time.h>
65

    
66
#include "cmdutils.h"
67

    
68
#undef NDEBUG
69
#include <assert.h>
70

    
71
#undef exit
72

    
73
const char program_name[] = "FFmpeg";
74
const int program_birth_year = 2000;
75

    
76
/* select an input stream for an output stream */
77
typedef struct AVStreamMap {
78
    int file_index;
79
    int stream_index;
80
    int sync_file_index;
81
    int sync_stream_index;
82
} AVStreamMap;
83

    
84
/** select an input file for an output file */
85
typedef struct AVMetaDataMap {
86
    int out_file;
87
    int in_file;
88
} AVMetaDataMap;
89

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

    
94
static AVFormatContext *input_files[MAX_FILES];
95
static int64_t input_files_ts_offset[MAX_FILES];
96
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
97
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
98
static int nb_input_files = 0;
99
static int nb_icodecs;
100

    
101
static AVFormatContext *output_files[MAX_FILES];
102
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
103
static int nb_output_files = 0;
104
static int nb_ocodecs;
105

    
106
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
107
static int nb_stream_maps;
108

    
109
static AVMetaDataMap meta_data_maps[MAX_FILES];
110
static int nb_meta_data_maps;
111

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

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

    
163
static int subtitle_disable = 0;
164
static char *subtitle_codec_name = NULL;
165
static char *subtitle_language = NULL;
166
static int subtitle_codec_tag = 0;
167

    
168
static float mux_preload= 0.5;
169
static float mux_max_delay= 0.7;
170

    
171
static int64_t recording_time = INT64_MAX;
172
static int64_t start_time = 0;
173
static int64_t rec_timestamp = 0;
174
static int64_t input_ts_offset = 0;
175
static int file_overwrite = 0;
176
static int metadata_count;
177
static AVMetadataTag *metadata;
178
static int do_benchmark = 0;
179
static int do_hex_dump = 0;
180
static int do_pkt_dump = 0;
181
static int do_psnr = 0;
182
static int do_pass = 0;
183
static char *pass_logfilename_prefix = NULL;
184
static int audio_stream_copy = 0;
185
static int video_stream_copy = 0;
186
static int subtitle_stream_copy = 0;
187
static int video_sync_method= -1;
188
static int audio_sync_method= 0;
189
static float audio_drift_threshold= 0.1;
190
static int copy_ts= 0;
191
static int opt_shortest = 0;
192
static int video_global_header = 0;
193
static char *vstats_filename;
194
static FILE *vstats_file;
195
static int opt_programid = 0;
196
static int copy_initial_nonkeyframes = 0;
197

    
198
static int rate_emu = 0;
199

    
200
static int  video_channel = 0;
201
static char *video_standard;
202

    
203
static int audio_volume = 256;
204

    
205
static int exit_on_error = 0;
206
static int using_stdin = 0;
207
static int verbose = 1;
208
static int thread_count= 1;
209
static int q_pressed = 0;
210
static int64_t video_size = 0;
211
static int64_t audio_size = 0;
212
static int64_t extra_size = 0;
213
static int nb_frames_dup = 0;
214
static int nb_frames_drop = 0;
215
static int input_sync;
216
static uint64_t limit_filesize = 0;
217
static int force_fps = 0;
218

    
219
static int pgmyuv_compatibility_hack=0;
220
static float dts_delta_threshold = 10;
221

    
222
static unsigned int sws_flags = SWS_BICUBIC;
223

    
224
static int64_t timer_start;
225

    
226
static uint8_t *audio_buf;
227
static uint8_t *audio_out;
228
static uint8_t *audio_out2;
229

    
230
static short *samples;
231

    
232
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
233
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
234
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
235
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
236

    
237
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
238

    
239
struct AVInputStream;
240

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

    
261
    /* full frame size of first frame */
262
    int original_height;
263
    int original_width;
264

    
265
    /* cropping area sizes */
266
    int video_crop;
267
    int topBand;
268
    int bottomBand;
269
    int leftBand;
270
    int rightBand;
271

    
272
    /* cropping area of first frame */
273
    int original_topBand;
274
    int original_bottomBand;
275
    int original_leftBand;
276
    int original_rightBand;
277

    
278
    /* padding area sizes */
279
    int video_pad;
280
    int padtop;
281
    int padbottom;
282
    int padleft;
283
    int padright;
284

    
285
    /* audio only */
286
    int audio_resample;
287
    ReSampleContext *resample; /* for audio resampling */
288
    int reformat_pair;
289
    AVAudioConvert *reformat_ctx;
290
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
291
    FILE *logfile;
292
} AVOutputStream;
293

    
294
typedef struct AVInputStream {
295
    int file_index;
296
    int index;
297
    AVStream *st;
298
    int discard;             /* true if stream data should be discarded */
299
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
300
    int64_t sample_index;      /* current sample */
301

    
302
    int64_t       start;     /* time when read started */
303
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
304
                                is not defined */
305
    int64_t       pts;       /* current pts */
306
    int is_start;            /* is 1 at the start and after a discontinuity */
307
} AVInputStream;
308

    
309
typedef struct AVInputFile {
310
    int eof_reached;      /* true if eof reached */
311
    int ist_index;        /* index of first stream in ist_table */
312
    int buffer_size;      /* current total buffer size */
313
    int nb_streams;       /* nb streams we are aware of */
314
} AVInputFile;
315

    
316
#if HAVE_TERMIOS_H
317

    
318
/* init terminal so that we can grab keys */
319
static struct termios oldtty;
320
#endif
321

    
322
static void term_exit(void)
323
{
324
#if HAVE_TERMIOS_H
325
    tcsetattr (0, TCSANOW, &oldtty);
326
#endif
327
}
328

    
329
static volatile sig_atomic_t received_sigterm = 0;
330

    
331
static void
332
sigterm_handler(int sig)
333
{
334
    received_sigterm = sig;
335
    term_exit();
336
}
337

    
338
static void term_init(void)
339
{
340
#if HAVE_TERMIOS_H
341
    struct termios tty;
342

    
343
    tcgetattr (0, &tty);
344
    oldtty = tty;
345

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

    
355
    tcsetattr (0, TCSANOW, &tty);
356
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
357
#endif
358

    
359
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
360
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
361
    /*
362
    register a function to be called at normal program termination
363
    */
364
    atexit(term_exit);
365
#if CONFIG_BEOS_NETSERVER
366
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
367
#endif
368
}
369

    
370
/* read a key without blocking */
371
static int read_key(void)
372
{
373
#if HAVE_TERMIOS_H
374
    int n = 1;
375
    unsigned char ch;
376
#if !CONFIG_BEOS_NETSERVER
377
    struct timeval tv;
378
    fd_set rfds;
379

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

    
391
        return n;
392
    }
393
#elif HAVE_CONIO_H
394
    if(kbhit())
395
        return(getch());
396
#endif
397
    return -1;
398
}
399

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

    
405
static int av_exit(int ret)
406
{
407
    int i;
408

    
409
    /* close files */
410
    for(i=0;i<nb_output_files;i++) {
411
        /* maybe av_close_output_file ??? */
412
        AVFormatContext *s = output_files[i];
413
        int j;
414
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
415
            url_fclose(s->pb);
416
        for(j=0;j<s->nb_streams;j++) {
417
            av_metadata_free(&s->streams[j]->metadata);
418
            av_free(s->streams[j]->codec);
419
            av_free(s->streams[j]);
420
        }
421
        for(j=0;j<s->nb_programs;j++) {
422
            av_metadata_free(&s->programs[j]->metadata);
423
        }
424
        for(j=0;j<s->nb_chapters;j++) {
425
            av_metadata_free(&s->chapters[j]->metadata);
426
        }
427
        av_metadata_free(&s->metadata);
428
        av_free(s);
429
    }
430
    for(i=0;i<nb_input_files;i++)
431
        av_close_input_file(input_files[i]);
432

    
433
    av_free(intra_matrix);
434
    av_free(inter_matrix);
435

    
436
    if (vstats_file)
437
        fclose(vstats_file);
438
    av_free(vstats_filename);
439

    
440
    av_free(opt_names);
441

    
442
    av_free(video_codec_name);
443
    av_free(audio_codec_name);
444
    av_free(subtitle_codec_name);
445

    
446
    av_free(video_standard);
447

    
448
#if CONFIG_POWERPC_PERF
449
    void powerpc_display_perf_report(void);
450
    powerpc_display_perf_report();
451
#endif /* CONFIG_POWERPC_PERF */
452

    
453
    for (i=0;i<CODEC_TYPE_NB;i++)
454
        av_free(avcodec_opts[i]);
455
    av_free(avformat_opts);
456
    av_free(sws_opts);
457
    av_free(audio_buf);
458
    av_free(audio_out);
459
    av_free(audio_out2);
460
    av_free(samples);
461

    
462
    if (received_sigterm) {
463
        fprintf(stderr,
464
            "Received signal %d: terminating.\n",
465
            (int) received_sigterm);
466
        exit (255);
467
    }
468

    
469
    exit(ret); /* not all OS-es handle main() return value */
470
    return ret;
471
}
472

    
473
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
474
{
475
    int i, err;
476
    AVFormatContext *ic;
477
    int nopts = 0;
478

    
479
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
480
    if (err < 0)
481
        return err;
482
    /* copy stream format */
483
    s->nb_streams = ic->nb_streams;
484
    for(i=0;i<ic->nb_streams;i++) {
485
        AVStream *st;
486

    
487
        // FIXME: a more elegant solution is needed
488
        st = av_mallocz(sizeof(AVStream));
489
        memcpy(st, ic->streams[i], sizeof(AVStream));
490
        st->codec = avcodec_alloc_context();
491
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
492
        s->streams[i] = st;
493

    
494
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
495
            st->stream_copy = 1;
496
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
497
            st->stream_copy = 1;
498

    
499
        if(!st->codec->thread_count)
500
            st->codec->thread_count = 1;
501
        if(st->codec->thread_count>1)
502
            avcodec_thread_init(st->codec, st->codec->thread_count);
503

    
504
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
505
            nopts = 1;
506
    }
507

    
508
    if (!nopts)
509
        s->timestamp = av_gettime();
510

    
511
    av_close_input_file(ic);
512
    return 0;
513
}
514

    
515
static double
516
get_sync_ipts(const AVOutputStream *ost)
517
{
518
    const AVInputStream *ist = ost->sync_ist;
519
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
520
}
521

    
522
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
523
    int ret;
524

    
525
    while(bsfc){
526
        AVPacket new_pkt= *pkt;
527
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
528
                                          &new_pkt.data, &new_pkt.size,
529
                                          pkt->data, pkt->size,
530
                                          pkt->flags & PKT_FLAG_KEY);
531
        if(a>0){
532
            av_free_packet(pkt);
533
            new_pkt.destruct= av_destruct_packet;
534
        } else if(a<0){
535
            fprintf(stderr, "%s failed for stream %d, codec %s",
536
                    bsfc->filter->name, pkt->stream_index,
537
                    avctx->codec ? avctx->codec->name : "copy");
538
            print_error("", a);
539
            if (exit_on_error)
540
                av_exit(1);
541
        }
542
        *pkt= new_pkt;
543

    
544
        bsfc= bsfc->next;
545
    }
546

    
547
    ret= av_interleaved_write_frame(s, pkt);
548
    if(ret < 0){
549
        print_error("av_interleaved_write_frame()", ret);
550
        av_exit(1);
551
    }
552
}
553

    
554
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
555

    
556
static void do_audio_out(AVFormatContext *s,
557
                         AVOutputStream *ost,
558
                         AVInputStream *ist,
559
                         unsigned char *buf, int size)
560
{
561
    uint8_t *buftmp;
562
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
563

    
564
    int size_out, frame_bytes, ret;
565
    AVCodecContext *enc= ost->st->codec;
566
    AVCodecContext *dec= ist->st->codec;
567
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
568
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
569

    
570
    /* SC: dynamic allocation of buffers */
571
    if (!audio_buf)
572
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
573
    if (!audio_out)
574
        audio_out = av_malloc(audio_out_size);
575
    if (!audio_buf || !audio_out)
576
        return;               /* Should signal an error ! */
577

    
578
    if (enc->channels != dec->channels)
579
        ost->audio_resample = 1;
580

    
581
    if (ost->audio_resample && !ost->resample) {
582
        if (dec->sample_fmt != SAMPLE_FMT_S16)
583
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
584
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
585
                                               enc->sample_rate, dec->sample_rate,
586
                                               enc->sample_fmt,  dec->sample_fmt,
587
                                               16, 10, 0, 0.8);
588
        if (!ost->resample) {
589
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
590
                    dec->channels, dec->sample_rate,
591
                    enc->channels, enc->sample_rate);
592
            av_exit(1);
593
        }
594
    }
595

    
596
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
597
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
598
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
599
        if (!audio_out2)
600
            audio_out2 = av_malloc(audio_out_size);
601
        if (!audio_out2)
602
            av_exit(1);
603
        if (ost->reformat_ctx)
604
            av_audio_convert_free(ost->reformat_ctx);
605
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
606
                                                   dec->sample_fmt, 1, NULL, 0);
607
        if (!ost->reformat_ctx) {
608
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
609
                avcodec_get_sample_fmt_name(dec->sample_fmt),
610
                avcodec_get_sample_fmt_name(enc->sample_fmt));
611
            av_exit(1);
612
        }
613
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
614
    }
615

    
616
    if(audio_sync_method){
617
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
618
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
619
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
620
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
621

    
622
        //FIXME resample delay
623
        if(fabs(delta) > 50){
624
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
625
                if(byte_delta < 0){
626
                    byte_delta= FFMAX(byte_delta, -size);
627
                    size += byte_delta;
628
                    buf  -= byte_delta;
629
                    if(verbose > 2)
630
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
631
                    if(!size)
632
                        return;
633
                    ist->is_start=0;
634
                }else{
635
                    static uint8_t *input_tmp= NULL;
636
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
637

    
638
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
639
                        ist->is_start=0;
640
                    else
641
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
642

    
643
                    memset(input_tmp, 0, byte_delta);
644
                    memcpy(input_tmp + byte_delta, buf, size);
645
                    buf= input_tmp;
646
                    size += byte_delta;
647
                    if(verbose > 2)
648
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
649
                }
650
            }else if(audio_sync_method>1){
651
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
652
                assert(ost->audio_resample);
653
                if(verbose > 2)
654
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
655
//                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));
656
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
657
            }
658
        }
659
    }else
660
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
661
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
662

    
663
    if (ost->audio_resample) {
664
        buftmp = audio_buf;
665
        size_out = audio_resample(ost->resample,
666
                                  (short *)buftmp, (short *)buf,
667
                                  size / (ist->st->codec->channels * isize));
668
        size_out = size_out * enc->channels * osize;
669
    } else {
670
        buftmp = buf;
671
        size_out = size;
672
    }
673

    
674
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
675
        const void *ibuf[6]= {buftmp};
676
        void *obuf[6]= {audio_out2};
677
        int istride[6]= {isize};
678
        int ostride[6]= {osize};
679
        int len= size_out/istride[0];
680
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
681
            printf("av_audio_convert() failed\n");
682
            if (exit_on_error)
683
                av_exit(1);
684
            return;
685
        }
686
        buftmp = audio_out2;
687
        size_out = len*osize;
688
    }
689

    
690
    /* now encode as many frames as possible */
691
    if (enc->frame_size > 1) {
692
        /* output resampled raw samples */
693
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
694
            fprintf(stderr, "av_fifo_realloc2() failed\n");
695
            av_exit(1);
696
        }
697
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
698

    
699
        frame_bytes = enc->frame_size * osize * enc->channels;
700

    
701
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
702
            AVPacket pkt;
703
            av_init_packet(&pkt);
704

    
705
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
706

    
707
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
708

    
709
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
710
                                       (short *)audio_buf);
711
            if (ret < 0) {
712
                fprintf(stderr, "Audio encoding failed\n");
713
                av_exit(1);
714
            }
715
            audio_size += ret;
716
            pkt.stream_index= ost->index;
717
            pkt.data= audio_out;
718
            pkt.size= ret;
719
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
720
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
721
            pkt.flags |= PKT_FLAG_KEY;
722
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
723

    
724
            ost->sync_opts += enc->frame_size;
725
        }
726
    } else {
727
        AVPacket pkt;
728
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
729
        av_init_packet(&pkt);
730

    
731
        ost->sync_opts += size_out / (osize * enc->channels);
732

    
733
        /* output a pcm frame */
734
        /* determine the size of the coded buffer */
735
        size_out /= osize;
736
        if (coded_bps)
737
            size_out *= coded_bps;
738

    
739
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
740
        ret = avcodec_encode_audio(enc, audio_out, size_out,
741
                                   (short *)buftmp);
742
        if (ret < 0) {
743
            fprintf(stderr, "Audio encoding failed\n");
744
            av_exit(1);
745
        }
746
        audio_size += ret;
747
        pkt.stream_index= ost->index;
748
        pkt.data= audio_out;
749
        pkt.size= ret;
750
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
751
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
752
        pkt.flags |= PKT_FLAG_KEY;
753
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
754
    }
755
}
756

    
757
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
758
{
759
    AVCodecContext *dec;
760
    AVPicture *picture2;
761
    AVPicture picture_tmp;
762
    uint8_t *buf = 0;
763

    
764
    dec = ist->st->codec;
765

    
766
    /* deinterlace : must be done before any resize */
767
    if (do_deinterlace) {
768
        int size;
769

    
770
        /* create temporary picture */
771
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
772
        buf = av_malloc(size);
773
        if (!buf)
774
            return;
775

    
776
        picture2 = &picture_tmp;
777
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
778

    
779
        if(avpicture_deinterlace(picture2, picture,
780
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
781
            /* if error, do not deinterlace */
782
            fprintf(stderr, "Deinterlacing failed\n");
783
            av_free(buf);
784
            buf = NULL;
785
            picture2 = picture;
786
        }
787
    } else {
788
        picture2 = picture;
789
    }
790

    
791
    if (picture != picture2)
792
        *picture = *picture2;
793
    *bufp = buf;
794
}
795

    
796
/* we begin to correct av delay at this threshold */
797
#define AV_DELAY_MAX 0.100
798

    
799
static void do_subtitle_out(AVFormatContext *s,
800
                            AVOutputStream *ost,
801
                            AVInputStream *ist,
802
                            AVSubtitle *sub,
803
                            int64_t pts)
804
{
805
    static uint8_t *subtitle_out = NULL;
806
    int subtitle_out_max_size = 65536;
807
    int subtitle_out_size, nb, i;
808
    AVCodecContext *enc;
809
    AVPacket pkt;
810

    
811
    if (pts == AV_NOPTS_VALUE) {
812
        fprintf(stderr, "Subtitle packets must have a pts\n");
813
        if (exit_on_error)
814
            av_exit(1);
815
        return;
816
    }
817

    
818
    enc = ost->st->codec;
819

    
820
    if (!subtitle_out) {
821
        subtitle_out = av_malloc(subtitle_out_max_size);
822
    }
823

    
824
    /* Note: DVB subtitle need one packet to draw them and one other
825
       packet to clear them */
826
    /* XXX: signal it in the codec context ? */
827
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
828
        nb = 2;
829
    else
830
        nb = 1;
831

    
832
    for(i = 0; i < nb; i++) {
833
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
834
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
835
                                                    subtitle_out_max_size, sub);
836

    
837
        av_init_packet(&pkt);
838
        pkt.stream_index = ost->index;
839
        pkt.data = subtitle_out;
840
        pkt.size = subtitle_out_size;
841
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
842
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
843
            /* XXX: the pts correction is handled here. Maybe handling
844
               it in the codec would be better */
845
            if (i == 0)
846
                pkt.pts += 90 * sub->start_display_time;
847
            else
848
                pkt.pts += 90 * sub->end_display_time;
849
        }
850
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
851
    }
852
}
853

    
854
static int bit_buffer_size= 1024*256;
855
static uint8_t *bit_buffer= NULL;
856

    
857
static void do_video_out(AVFormatContext *s,
858
                         AVOutputStream *ost,
859
                         AVInputStream *ist,
860
                         AVFrame *in_picture,
861
                         int *frame_size)
862
{
863
    int nb_frames, i, ret;
864
    int64_t topBand, bottomBand, leftBand, rightBand;
865
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
866
    AVFrame picture_crop_temp, picture_pad_temp;
867
    AVCodecContext *enc, *dec;
868

    
869
    avcodec_get_frame_defaults(&picture_crop_temp);
870
    avcodec_get_frame_defaults(&picture_pad_temp);
871

    
872
    enc = ost->st->codec;
873
    dec = ist->st->codec;
874

    
875
    /* by default, we output a single frame */
876
    nb_frames = 1;
877

    
878
    *frame_size = 0;
879

    
880
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
881
        double vdelta;
882
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
883
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
884
        if (vdelta < -1.1)
885
            nb_frames = 0;
886
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
887
            if(vdelta<=-0.6){
888
                nb_frames=0;
889
            }else if(vdelta>0.6)
890
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
891
        }else if (vdelta > 1.1)
892
            nb_frames = lrintf(vdelta);
893
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
894
        if (nb_frames == 0){
895
            ++nb_frames_drop;
896
            if (verbose>2)
897
                fprintf(stderr, "*** drop!\n");
898
        }else if (nb_frames > 1) {
899
            nb_frames_dup += nb_frames;
900
            if (verbose>2)
901
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
902
        }
903
    }else
904
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
905

    
906
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
907
    if (nb_frames <= 0)
908
        return;
909

    
910
    if (ost->video_crop) {
911
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
912
            fprintf(stderr, "error cropping picture\n");
913
            if (exit_on_error)
914
                av_exit(1);
915
            return;
916
        }
917
        formatted_picture = &picture_crop_temp;
918
    } else {
919
        formatted_picture = in_picture;
920
    }
921

    
922
    final_picture = formatted_picture;
923
    padding_src = formatted_picture;
924
    resampling_dst = &ost->pict_tmp;
925
    if (ost->video_pad) {
926
        final_picture = &ost->pict_tmp;
927
        if (ost->video_resample) {
928
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
929
                fprintf(stderr, "error padding picture\n");
930
                if (exit_on_error)
931
                    av_exit(1);
932
                return;
933
            }
934
            resampling_dst = &picture_pad_temp;
935
        }
936
    }
937

    
938
    if (ost->video_resample) {
939
        padding_src = NULL;
940
        final_picture = &ost->pict_tmp;
941
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
942
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
943
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
944

    
945
            fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
946
            /* keep bands proportional to the frame size */
947
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
948
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
949
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
950
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
951

    
952
            /* sanity check to ensure no bad band sizes sneak in */
953
            assert(topBand    <= INT_MAX && topBand    >= 0);
954
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
955
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
956
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
957

    
958
            ost->topBand    = topBand;
959
            ost->bottomBand = bottomBand;
960
            ost->leftBand   = leftBand;
961
            ost->rightBand  = rightBand;
962

    
963
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
964
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
965
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
966

    
967
            /* initialize a new scaler context */
968
            sws_freeContext(ost->img_resample_ctx);
969
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
970
            ost->img_resample_ctx = sws_getContext(
971
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
972
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
973
                ist->st->codec->pix_fmt,
974
                ost->st->codec->width  - (ost->padleft  + ost->padright),
975
                ost->st->codec->height - (ost->padtop   + ost->padbottom),
976
                ost->st->codec->pix_fmt,
977
                sws_flags, NULL, NULL, NULL);
978
            if (ost->img_resample_ctx == NULL) {
979
                fprintf(stderr, "Cannot get resampling context\n");
980
                av_exit(1);
981
            }
982
        }
983
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
984
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
985
    }
986

    
987
    if (ost->video_pad) {
988
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
989
                enc->height, enc->width, enc->pix_fmt,
990
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
991
    }
992

    
993
    /* duplicates frame if needed */
994
    for(i=0;i<nb_frames;i++) {
995
        AVPacket pkt;
996
        av_init_packet(&pkt);
997
        pkt.stream_index= ost->index;
998

    
999
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1000
            /* raw pictures are written as AVPicture structure to
1001
               avoid any copies. We support temorarily the older
1002
               method. */
1003
            AVFrame* old_frame = enc->coded_frame;
1004
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1005
            pkt.data= (uint8_t *)final_picture;
1006
            pkt.size=  sizeof(AVPicture);
1007
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1008
            pkt.flags |= PKT_FLAG_KEY;
1009

    
1010
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1011
            enc->coded_frame = old_frame;
1012
        } else {
1013
            AVFrame big_picture;
1014

    
1015
            big_picture= *final_picture;
1016
            /* better than nothing: use input picture interlaced
1017
               settings */
1018
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1019
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1020
                if(top_field_first == -1)
1021
                    big_picture.top_field_first = in_picture->top_field_first;
1022
                else
1023
                    big_picture.top_field_first = top_field_first;
1024
            }
1025

    
1026
            /* handles sameq here. This is not correct because it may
1027
               not be a global option */
1028
            if (same_quality) {
1029
                big_picture.quality = ist->st->quality;
1030
            }else
1031
                big_picture.quality = ost->st->quality;
1032
            if(!me_threshold)
1033
                big_picture.pict_type = 0;
1034
//            big_picture.pts = AV_NOPTS_VALUE;
1035
            big_picture.pts= ost->sync_opts;
1036
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1037
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1038
            ret = avcodec_encode_video(enc,
1039
                                       bit_buffer, bit_buffer_size,
1040
                                       &big_picture);
1041
            if (ret < 0) {
1042
                fprintf(stderr, "Video encoding failed\n");
1043
                av_exit(1);
1044
            }
1045

    
1046
            if(ret>0){
1047
                pkt.data= bit_buffer;
1048
                pkt.size= ret;
1049
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1050
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1051
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1052
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1053
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1054

    
1055
                if(enc->coded_frame->key_frame)
1056
                    pkt.flags |= PKT_FLAG_KEY;
1057
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1058
                *frame_size = ret;
1059
                video_size += ret;
1060
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1061
                //        enc->frame_number-1, ret, enc->pict_type);
1062
                /* if two pass, output log */
1063
                if (ost->logfile && enc->stats_out) {
1064
                    fprintf(ost->logfile, "%s", enc->stats_out);
1065
                }
1066
            }
1067
        }
1068
        ost->sync_opts++;
1069
        ost->frame_number++;
1070
    }
1071
}
1072

    
1073
static double psnr(double d){
1074
    return -10.0*log(d)/log(10.0);
1075
}
1076

    
1077
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1078
                           int frame_size)
1079
{
1080
    AVCodecContext *enc;
1081
    int frame_number;
1082
    double ti1, bitrate, avg_bitrate;
1083

    
1084
    /* this is executed just the first time do_video_stats is called */
1085
    if (!vstats_file) {
1086
        vstats_file = fopen(vstats_filename, "w");
1087
        if (!vstats_file) {
1088
            perror("fopen");
1089
            av_exit(1);
1090
        }
1091
    }
1092

    
1093
    enc = ost->st->codec;
1094
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1095
        frame_number = ost->frame_number;
1096
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1097
        if (enc->flags&CODEC_FLAG_PSNR)
1098
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1099

    
1100
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1101
        /* compute pts value */
1102
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1103
        if (ti1 < 0.01)
1104
            ti1 = 0.01;
1105

    
1106
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1107
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1108
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1109
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1110
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1111
    }
1112
}
1113

    
1114
static void print_report(AVFormatContext **output_files,
1115
                         AVOutputStream **ost_table, int nb_ostreams,
1116
                         int is_last_report)
1117
{
1118
    char buf[1024];
1119
    AVOutputStream *ost;
1120
    AVFormatContext *oc;
1121
    int64_t total_size;
1122
    AVCodecContext *enc;
1123
    int frame_number, vid, i;
1124
    double bitrate, ti1, pts;
1125
    static int64_t last_time = -1;
1126
    static int qp_histogram[52];
1127

    
1128
    if (!is_last_report) {
1129
        int64_t cur_time;
1130
        /* display the report every 0.5 seconds */
1131
        cur_time = av_gettime();
1132
        if (last_time == -1) {
1133
            last_time = cur_time;
1134
            return;
1135
        }
1136
        if ((cur_time - last_time) < 500000)
1137
            return;
1138
        last_time = cur_time;
1139
    }
1140

    
1141

    
1142
    oc = output_files[0];
1143

    
1144
    total_size = url_fsize(oc->pb);
1145
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1146
        total_size= url_ftell(oc->pb);
1147

    
1148
    buf[0] = '\0';
1149
    ti1 = 1e10;
1150
    vid = 0;
1151
    for(i=0;i<nb_ostreams;i++) {
1152
        ost = ost_table[i];
1153
        enc = ost->st->codec;
1154
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1155
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1156
                     !ost->st->stream_copy ?
1157
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1158
        }
1159
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1160
            float t = (av_gettime()-timer_start) / 1000000.0;
1161

    
1162
            frame_number = ost->frame_number;
1163
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1164
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1165
                     !ost->st->stream_copy ?
1166
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1167
            if(is_last_report)
1168
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1169
            if(qp_hist){
1170
                int j;
1171
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1172
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1173
                    qp_histogram[qp]++;
1174
                for(j=0; j<32; j++)
1175
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1176
            }
1177
            if (enc->flags&CODEC_FLAG_PSNR){
1178
                int j;
1179
                double error, error_sum=0;
1180
                double scale, scale_sum=0;
1181
                char type[3]= {'Y','U','V'};
1182
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1183
                for(j=0; j<3; j++){
1184
                    if(is_last_report){
1185
                        error= enc->error[j];
1186
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1187
                    }else{
1188
                        error= enc->coded_frame->error[j];
1189
                        scale= enc->width*enc->height*255.0*255.0;
1190
                    }
1191
                    if(j) scale/=4;
1192
                    error_sum += error;
1193
                    scale_sum += scale;
1194
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1195
                }
1196
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1197
            }
1198
            vid = 1;
1199
        }
1200
        /* compute min output value */
1201
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1202
        if ((pts < ti1) && (pts > 0))
1203
            ti1 = pts;
1204
    }
1205
    if (ti1 < 0.01)
1206
        ti1 = 0.01;
1207

    
1208
    if (verbose || is_last_report) {
1209
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1210

    
1211
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1212
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1213
            (double)total_size / 1024, ti1, bitrate);
1214

    
1215
        if (verbose > 1)
1216
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1217
                  nb_frames_dup, nb_frames_drop);
1218

    
1219
        if (verbose >= 0)
1220
            fprintf(stderr, "%s    \r", buf);
1221

    
1222
        fflush(stderr);
1223
    }
1224

    
1225
    if (is_last_report && verbose >= 0){
1226
        int64_t raw= audio_size + video_size + extra_size;
1227
        fprintf(stderr, "\n");
1228
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1229
                video_size/1024.0,
1230
                audio_size/1024.0,
1231
                extra_size/1024.0,
1232
                100.0*(total_size - raw)/raw
1233
        );
1234
    }
1235
}
1236

    
1237
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1238
static int output_packet(AVInputStream *ist, int ist_index,
1239
                         AVOutputStream **ost_table, int nb_ostreams,
1240
                         const AVPacket *pkt)
1241
{
1242
    AVFormatContext *os;
1243
    AVOutputStream *ost;
1244
    int ret, i;
1245
    uint8_t *data_buf;
1246
    int data_size, got_picture;
1247
    AVFrame picture;
1248
    void *buffer_to_free;
1249
    static unsigned int samples_size= 0;
1250
    AVSubtitle subtitle, *subtitle_to_free;
1251
    int got_subtitle;
1252
    AVPacket avpkt;
1253

    
1254
    if(ist->next_pts == AV_NOPTS_VALUE)
1255
        ist->next_pts= ist->pts;
1256

    
1257
    if (pkt == NULL) {
1258
        /* EOF handling */
1259
        av_init_packet(&avpkt);
1260
        avpkt.data = NULL;
1261
        avpkt.size = 0;
1262
        goto handle_eof;
1263
    } else {
1264
        avpkt = *pkt;
1265
    }
1266

    
1267
    if(pkt->dts != AV_NOPTS_VALUE)
1268
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1269

    
1270
    //while we have more to decode or while the decoder did output something on EOF
1271
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1272
    handle_eof:
1273
        ist->pts= ist->next_pts;
1274

    
1275
        if(avpkt.size && avpkt.size != pkt->size && verbose>0)
1276
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1277

    
1278
        /* decode the packet if needed */
1279
        data_buf = NULL; /* fail safe */
1280
        data_size = 0;
1281
        subtitle_to_free = NULL;
1282
        if (ist->decoding_needed) {
1283
            switch(ist->st->codec->codec_type) {
1284
            case CODEC_TYPE_AUDIO:{
1285
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1286
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1287
                    av_free(samples);
1288
                    samples= av_malloc(samples_size);
1289
                }
1290
                data_size= samples_size;
1291
                    /* XXX: could avoid copy if PCM 16 bits with same
1292
                       endianness as CPU */
1293
                ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1294
                                            &avpkt);
1295
                if (ret < 0)
1296
                    goto fail_decode;
1297
                avpkt.data += ret;
1298
                avpkt.size -= ret;
1299
                /* Some bug in mpeg audio decoder gives */
1300
                /* data_size < 0, it seems they are overflows */
1301
                if (data_size <= 0) {
1302
                    /* no audio frame */
1303
                    continue;
1304
                }
1305
                data_buf = (uint8_t *)samples;
1306
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1307
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1308
                break;}
1309
            case CODEC_TYPE_VIDEO:
1310
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1311
                    /* XXX: allocate picture correctly */
1312
                    avcodec_get_frame_defaults(&picture);
1313

    
1314
                    ret = avcodec_decode_video2(ist->st->codec,
1315
                                                &picture, &got_picture, &avpkt);
1316
                    ist->st->quality= picture.quality;
1317
                    if (ret < 0)
1318
                        goto fail_decode;
1319
                    if (!got_picture) {
1320
                        /* no picture yet */
1321
                        goto discard_packet;
1322
                    }
1323
                    if (ist->st->codec->time_base.num != 0) {
1324
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1325
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1326
                                          ist->st->codec->time_base.num * ticks) /
1327
                            ist->st->codec->time_base.den;
1328
                    }
1329
                    avpkt.size = 0;
1330
                    break;
1331
            case CODEC_TYPE_SUBTITLE:
1332
                ret = avcodec_decode_subtitle2(ist->st->codec,
1333
                                               &subtitle, &got_subtitle, &avpkt);
1334
                if (ret < 0)
1335
                    goto fail_decode;
1336
                if (!got_subtitle) {
1337
                    goto discard_packet;
1338
                }
1339
                subtitle_to_free = &subtitle;
1340
                avpkt.size = 0;
1341
                break;
1342
            default:
1343
                goto fail_decode;
1344
            }
1345
        } else {
1346
            switch(ist->st->codec->codec_type) {
1347
            case CODEC_TYPE_AUDIO:
1348
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1349
                    ist->st->codec->sample_rate;
1350
                break;
1351
            case CODEC_TYPE_VIDEO:
1352
                if (ist->st->codec->time_base.num != 0) {
1353
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1354
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1355
                                      ist->st->codec->time_base.num * ticks) /
1356
                        ist->st->codec->time_base.den;
1357
                }
1358
                break;
1359
            }
1360
            data_buf = avpkt.data;
1361
            data_size = avpkt.size;
1362
            ret = avpkt.size;
1363
            avpkt.size = 0;
1364
        }
1365

    
1366
        buffer_to_free = NULL;
1367
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1368
            pre_process_video_frame(ist, (AVPicture *)&picture,
1369
                                    &buffer_to_free);
1370
        }
1371

    
1372
        // preprocess audio (volume)
1373
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1374
            if (audio_volume != 256) {
1375
                short *volp;
1376
                volp = samples;
1377
                for(i=0;i<(data_size / sizeof(short));i++) {
1378
                    int v = ((*volp) * audio_volume + 128) >> 8;
1379
                    if (v < -32768) v = -32768;
1380
                    if (v >  32767) v = 32767;
1381
                    *volp++ = v;
1382
                }
1383
            }
1384
        }
1385

    
1386
        /* frame rate emulation */
1387
        if (rate_emu) {
1388
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1389
            int64_t now = av_gettime() - ist->start;
1390
            if (pts > now)
1391
                usleep(pts - now);
1392
        }
1393

    
1394
        /* if output time reached then transcode raw format,
1395
           encode packets and output them */
1396
        if (start_time == 0 || ist->pts >= start_time)
1397
            for(i=0;i<nb_ostreams;i++) {
1398
                int frame_size;
1399

    
1400
                ost = ost_table[i];
1401
                if (ost->source_index == ist_index) {
1402
                    os = output_files[ost->file_index];
1403

    
1404
#if 0
1405
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1406
                           (double)pkt->pts / AV_TIME_BASE,
1407
                           ((double)ist->pts / AV_TIME_BASE) -
1408
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1409
#endif
1410
                    /* set the input output pts pairs */
1411
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1412

    
1413
                    if (ost->encoding_needed) {
1414
                        switch(ost->st->codec->codec_type) {
1415
                        case CODEC_TYPE_AUDIO:
1416
                            do_audio_out(os, ost, ist, data_buf, data_size);
1417
                            break;
1418
                        case CODEC_TYPE_VIDEO:
1419
                            do_video_out(os, ost, ist, &picture, &frame_size);
1420
                            if (vstats_filename && frame_size)
1421
                                do_video_stats(os, ost, frame_size);
1422
                            break;
1423
                        case CODEC_TYPE_SUBTITLE:
1424
                            do_subtitle_out(os, ost, ist, &subtitle,
1425
                                            pkt->pts);
1426
                            break;
1427
                        default:
1428
                            abort();
1429
                        }
1430
                    } else {
1431
                        AVFrame avframe; //FIXME/XXX remove this
1432
                        AVPacket opkt;
1433
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1434

    
1435
                        av_init_packet(&opkt);
1436

    
1437
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1438
                            continue;
1439

    
1440
                        /* no reencoding needed : output the packet directly */
1441
                        /* force the input stream PTS */
1442

    
1443
                        avcodec_get_frame_defaults(&avframe);
1444
                        ost->st->codec->coded_frame= &avframe;
1445
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1446

    
1447
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1448
                            audio_size += data_size;
1449
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1450
                            video_size += data_size;
1451
                            ost->sync_opts++;
1452
                        }
1453

    
1454
                        opkt.stream_index= ost->index;
1455
                        if(pkt->pts != AV_NOPTS_VALUE)
1456
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1457
                        else
1458
                            opkt.pts= AV_NOPTS_VALUE;
1459

    
1460
                        if (pkt->dts == AV_NOPTS_VALUE)
1461
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1462
                        else
1463
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1464
                        opkt.dts -= ost_tb_start_time;
1465

    
1466
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1467
                        opkt.flags= pkt->flags;
1468

    
1469
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1470
                        if(ost->st->codec->codec_id != CODEC_ID_H264) {
1471
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1472
                            opkt.destruct= av_destruct_packet;
1473
                        } else {
1474
                            opkt.data = data_buf;
1475
                            opkt.size = data_size;
1476
                        }
1477

    
1478
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1479
                        ost->st->codec->frame_number++;
1480
                        ost->frame_number++;
1481
                        av_free_packet(&opkt);
1482
                    }
1483
                }
1484
            }
1485
        av_free(buffer_to_free);
1486
        /* XXX: allocate the subtitles in the codec ? */
1487
        if (subtitle_to_free) {
1488
            if (subtitle_to_free->rects != NULL) {
1489
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1490
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1491
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1492
                    av_freep(&subtitle_to_free->rects[i]);
1493
                }
1494
                av_freep(&subtitle_to_free->rects);
1495
            }
1496
            subtitle_to_free->num_rects = 0;
1497
            subtitle_to_free = NULL;
1498
        }
1499
    }
1500
 discard_packet:
1501
    if (pkt == NULL) {
1502
        /* EOF handling */
1503

    
1504
        for(i=0;i<nb_ostreams;i++) {
1505
            ost = ost_table[i];
1506
            if (ost->source_index == ist_index) {
1507
                AVCodecContext *enc= ost->st->codec;
1508
                os = output_files[ost->file_index];
1509

    
1510
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1511
                    continue;
1512
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1513
                    continue;
1514

    
1515
                if (ost->encoding_needed) {
1516
                    for(;;) {
1517
                        AVPacket pkt;
1518
                        int fifo_bytes;
1519
                        av_init_packet(&pkt);
1520
                        pkt.stream_index= ost->index;
1521

    
1522
                        switch(ost->st->codec->codec_type) {
1523
                        case CODEC_TYPE_AUDIO:
1524
                            fifo_bytes = av_fifo_size(ost->fifo);
1525
                            ret = 0;
1526
                            /* encode any samples remaining in fifo */
1527
                            if (fifo_bytes > 0) {
1528
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1529
                                int fs_tmp = enc->frame_size;
1530

    
1531
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1532
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1533
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1534
                                } else { /* pad */
1535
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1536
                                    if (samples_size < frame_bytes)
1537
                                        av_exit(1);
1538
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1539
                                }
1540

    
1541
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1542
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1543
                                                          ost->st->time_base.num, enc->sample_rate);
1544
                                enc->frame_size = fs_tmp;
1545
                            }
1546
                            if(ret <= 0) {
1547
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1548
                            }
1549
                            if (ret < 0) {
1550
                                fprintf(stderr, "Audio encoding failed\n");
1551
                                av_exit(1);
1552
                            }
1553
                            audio_size += ret;
1554
                            pkt.flags |= PKT_FLAG_KEY;
1555
                            break;
1556
                        case CODEC_TYPE_VIDEO:
1557
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1558
                            if (ret < 0) {
1559
                                fprintf(stderr, "Video encoding failed\n");
1560
                                av_exit(1);
1561
                            }
1562
                            video_size += ret;
1563
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1564
                                pkt.flags |= PKT_FLAG_KEY;
1565
                            if (ost->logfile && enc->stats_out) {
1566
                                fprintf(ost->logfile, "%s", enc->stats_out);
1567
                            }
1568
                            break;
1569
                        default:
1570
                            ret=-1;
1571
                        }
1572

    
1573
                        if(ret<=0)
1574
                            break;
1575
                        pkt.data= bit_buffer;
1576
                        pkt.size= ret;
1577
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1578
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1579
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1580
                    }
1581
                }
1582
            }
1583
        }
1584
    }
1585

    
1586
    return 0;
1587
 fail_decode:
1588
    return -1;
1589
}
1590

    
1591
static void print_sdp(AVFormatContext **avc, int n)
1592
{
1593
    char sdp[2048];
1594

    
1595
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1596
    printf("SDP:\n%s\n", sdp);
1597
    fflush(stdout);
1598
}
1599

    
1600
static int stream_index_from_inputs(AVFormatContext **input_files,
1601
                                    int nb_input_files,
1602
                                    AVInputFile *file_table,
1603
                                    AVInputStream **ist_table,
1604
                                    enum CodecType type,
1605
                                    int programid)
1606
{
1607
    int p, q, z;
1608
    for(z=0; z<nb_input_files; z++) {
1609
        AVFormatContext *ic = input_files[z];
1610
        for(p=0; p<ic->nb_programs; p++) {
1611
            AVProgram *program = ic->programs[p];
1612
            if(program->id != programid)
1613
                continue;
1614
            for(q=0; q<program->nb_stream_indexes; q++) {
1615
                int sidx = program->stream_index[q];
1616
                int ris = file_table[z].ist_index + sidx;
1617
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1618
                    return ris;
1619
            }
1620
        }
1621
    }
1622

    
1623
    return -1;
1624
}
1625

    
1626
/*
1627
 * The following code is the main loop of the file converter
1628
 */
1629
static int av_encode(AVFormatContext **output_files,
1630
                     int nb_output_files,
1631
                     AVFormatContext **input_files,
1632
                     int nb_input_files,
1633
                     AVStreamMap *stream_maps, int nb_stream_maps)
1634
{
1635
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1636
    AVFormatContext *is, *os;
1637
    AVCodecContext *codec, *icodec;
1638
    AVOutputStream *ost, **ost_table = NULL;
1639
    AVInputStream *ist, **ist_table = NULL;
1640
    AVInputFile *file_table;
1641
    char error[1024];
1642
    int key;
1643
    int want_sdp = 1;
1644
    uint8_t no_packet[MAX_FILES]={0};
1645
    int no_packet_count=0;
1646

    
1647
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1648
    if (!file_table)
1649
        goto fail;
1650

    
1651
    /* input stream init */
1652
    j = 0;
1653
    for(i=0;i<nb_input_files;i++) {
1654
        is = input_files[i];
1655
        file_table[i].ist_index = j;
1656
        file_table[i].nb_streams = is->nb_streams;
1657
        j += is->nb_streams;
1658
    }
1659
    nb_istreams = j;
1660

    
1661
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1662
    if (!ist_table)
1663
        goto fail;
1664

    
1665
    for(i=0;i<nb_istreams;i++) {
1666
        ist = av_mallocz(sizeof(AVInputStream));
1667
        if (!ist)
1668
            goto fail;
1669
        ist_table[i] = ist;
1670
    }
1671
    j = 0;
1672
    for(i=0;i<nb_input_files;i++) {
1673
        is = input_files[i];
1674
        for(k=0;k<is->nb_streams;k++) {
1675
            ist = ist_table[j++];
1676
            ist->st = is->streams[k];
1677
            ist->file_index = i;
1678
            ist->index = k;
1679
            ist->discard = 1; /* the stream is discarded by default
1680
                                 (changed later) */
1681

    
1682
            if (rate_emu) {
1683
                ist->start = av_gettime();
1684
            }
1685
        }
1686
    }
1687

    
1688
    /* output stream init */
1689
    nb_ostreams = 0;
1690
    for(i=0;i<nb_output_files;i++) {
1691
        os = output_files[i];
1692
        if (!os->nb_streams) {
1693
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1694
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1695
            av_exit(1);
1696
        }
1697
        nb_ostreams += os->nb_streams;
1698
    }
1699
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1700
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1701
        av_exit(1);
1702
    }
1703

    
1704
    /* Sanity check the mapping args -- do the input files & streams exist? */
1705
    for(i=0;i<nb_stream_maps;i++) {
1706
        int fi = stream_maps[i].file_index;
1707
        int si = stream_maps[i].stream_index;
1708

    
1709
        if (fi < 0 || fi > nb_input_files - 1 ||
1710
            si < 0 || si > file_table[fi].nb_streams - 1) {
1711
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1712
            av_exit(1);
1713
        }
1714
        fi = stream_maps[i].sync_file_index;
1715
        si = stream_maps[i].sync_stream_index;
1716
        if (fi < 0 || fi > nb_input_files - 1 ||
1717
            si < 0 || si > file_table[fi].nb_streams - 1) {
1718
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1719
            av_exit(1);
1720
        }
1721
    }
1722

    
1723
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1724
    if (!ost_table)
1725
        goto fail;
1726
    for(i=0;i<nb_ostreams;i++) {
1727
        ost = av_mallocz(sizeof(AVOutputStream));
1728
        if (!ost)
1729
            goto fail;
1730
        ost_table[i] = ost;
1731
    }
1732

    
1733
    n = 0;
1734
    for(k=0;k<nb_output_files;k++) {
1735
        os = output_files[k];
1736
        for(i=0;i<os->nb_streams;i++,n++) {
1737
            int found;
1738
            ost = ost_table[n];
1739
            ost->file_index = k;
1740
            ost->index = i;
1741
            ost->st = os->streams[i];
1742
            if (nb_stream_maps > 0) {
1743
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1744
                    stream_maps[n].stream_index;
1745

    
1746
                /* Sanity check that the stream types match */
1747
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1748
                    int i= ost->file_index;
1749
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1750
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1751
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1752
                        ost->file_index, ost->index);
1753
                    av_exit(1);
1754
                }
1755

    
1756
            } else {
1757
                if(opt_programid) {
1758
                    found = 0;
1759
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1760
                    if(j != -1) {
1761
                        ost->source_index = j;
1762
                        found = 1;
1763
                    }
1764
                } else {
1765
                    /* get corresponding input stream index : we select the first one with the right type */
1766
                    found = 0;
1767
                    for(j=0;j<nb_istreams;j++) {
1768
                        ist = ist_table[j];
1769
                        if (ist->discard &&
1770
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1771
                            ost->source_index = j;
1772
                            found = 1;
1773
                            break;
1774
                        }
1775
                    }
1776
                }
1777

    
1778
                if (!found) {
1779
                    if(! opt_programid) {
1780
                        /* try again and reuse existing stream */
1781
                        for(j=0;j<nb_istreams;j++) {
1782
                            ist = ist_table[j];
1783
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1784
                                ost->source_index = j;
1785
                                found = 1;
1786
                            }
1787
                        }
1788
                    }
1789
                    if (!found) {
1790
                        int i= ost->file_index;
1791
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1792
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1793
                                ost->file_index, ost->index);
1794
                        av_exit(1);
1795
                    }
1796
                }
1797
            }
1798
            ist = ist_table[ost->source_index];
1799
            ist->discard = 0;
1800
            ost->sync_ist = (nb_stream_maps > 0) ?
1801
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1802
                         stream_maps[n].sync_stream_index] : ist;
1803
        }
1804
    }
1805

    
1806
    /* for each output stream, we compute the right encoding parameters */
1807
    for(i=0;i<nb_ostreams;i++) {
1808
        AVMetadataTag *lang;
1809
        ost = ost_table[i];
1810
        os = output_files[ost->file_index];
1811
        ist = ist_table[ost->source_index];
1812

    
1813
        codec = ost->st->codec;
1814
        icodec = ist->st->codec;
1815

    
1816
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1817
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1818
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1819

    
1820
        ost->st->disposition = ist->st->disposition;
1821
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1822
        codec->chroma_sample_location = icodec->chroma_sample_location;
1823

    
1824
        if (ost->st->stream_copy) {
1825
            /* if stream_copy is selected, no need to decode or encode */
1826
            codec->codec_id = icodec->codec_id;
1827
            codec->codec_type = icodec->codec_type;
1828

    
1829
            if(!codec->codec_tag){
1830
                if(   !os->oformat->codec_tag
1831
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1832
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1833
                    codec->codec_tag = icodec->codec_tag;
1834
            }
1835

    
1836
            codec->bit_rate = icodec->bit_rate;
1837
            codec->extradata= icodec->extradata;
1838
            codec->extradata_size= icodec->extradata_size;
1839
            if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
1840
                codec->time_base = icodec->time_base;
1841
                codec->time_base.num *= icodec->ticks_per_frame;
1842
            }else
1843
                codec->time_base = ist->st->time_base;
1844
            switch(codec->codec_type) {
1845
            case CODEC_TYPE_AUDIO:
1846
                if(audio_volume != 256) {
1847
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1848
                    av_exit(1);
1849
                }
1850
                codec->channel_layout = icodec->channel_layout;
1851
                codec->sample_rate = icodec->sample_rate;
1852
                codec->channels = icodec->channels;
1853
                codec->frame_size = icodec->frame_size;
1854
                codec->block_align= icodec->block_align;
1855
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1856
                    codec->block_align= 0;
1857
                if(codec->codec_id == CODEC_ID_AC3)
1858
                    codec->block_align= 0;
1859
                break;
1860
            case CODEC_TYPE_VIDEO:
1861
                codec->pix_fmt = icodec->pix_fmt;
1862
                codec->width = icodec->width;
1863
                codec->height = icodec->height;
1864
                codec->has_b_frames = icodec->has_b_frames;
1865
                break;
1866
            case CODEC_TYPE_SUBTITLE:
1867
                codec->width = icodec->width;
1868
                codec->height = icodec->height;
1869
                break;
1870
            default:
1871
                abort();
1872
            }
1873
        } else {
1874
            switch(codec->codec_type) {
1875
            case CODEC_TYPE_AUDIO:
1876
                ost->fifo= av_fifo_alloc(1024);
1877
                if(!ost->fifo)
1878
                    goto fail;
1879
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1880
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1881
                icodec->request_channels = codec->channels;
1882
                ist->decoding_needed = 1;
1883
                ost->encoding_needed = 1;
1884
                break;
1885
            case CODEC_TYPE_VIDEO:
1886
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1887
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1888
                    av_exit(1);
1889
                }
1890
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1891
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1892
                ost->video_resample = ((codec->width != icodec->width -
1893
                                (frame_leftBand + frame_rightBand) +
1894
                                (frame_padleft + frame_padright)) ||
1895
                        (codec->height != icodec->height -
1896
                                (frame_topBand  + frame_bottomBand) +
1897
                                (frame_padtop + frame_padbottom)) ||
1898
                        (codec->pix_fmt != icodec->pix_fmt));
1899
                if (ost->video_crop) {
1900
                    ost->topBand    = ost->original_topBand    = frame_topBand;
1901
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1902
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
1903
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
1904
                }
1905
                if (ost->video_pad) {
1906
                    ost->padtop = frame_padtop;
1907
                    ost->padleft = frame_padleft;
1908
                    ost->padbottom = frame_padbottom;
1909
                    ost->padright = frame_padright;
1910
                    if (!ost->video_resample) {
1911
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1912
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1913
                                         codec->width, codec->height))
1914
                            goto fail;
1915
                    }
1916
                }
1917
                if (ost->video_resample) {
1918
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1919
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1920
                                         codec->width, codec->height)) {
1921
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1922
                        av_exit(1);
1923
                    }
1924
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1925
                    ost->img_resample_ctx = sws_getContext(
1926
                            icodec->width - (frame_leftBand + frame_rightBand),
1927
                            icodec->height - (frame_topBand + frame_bottomBand),
1928
                            icodec->pix_fmt,
1929
                            codec->width - (frame_padleft + frame_padright),
1930
                            codec->height - (frame_padtop + frame_padbottom),
1931
                            codec->pix_fmt,
1932
                            sws_flags, NULL, NULL, NULL);
1933
                    if (ost->img_resample_ctx == NULL) {
1934
                        fprintf(stderr, "Cannot get resampling context\n");
1935
                        av_exit(1);
1936
                    }
1937

    
1938
                    ost->original_height = icodec->height;
1939
                    ost->original_width  = icodec->width;
1940

    
1941
                    ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
1942
                    ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
1943
                    ost->resample_pix_fmt= icodec->pix_fmt;
1944
                    codec->bits_per_raw_sample= 0;
1945
                }
1946
                ost->encoding_needed = 1;
1947
                ist->decoding_needed = 1;
1948
                break;
1949
            case CODEC_TYPE_SUBTITLE:
1950
                ost->encoding_needed = 1;
1951
                ist->decoding_needed = 1;
1952
                break;
1953
            default:
1954
                abort();
1955
                break;
1956
            }
1957
            /* two pass mode */
1958
            if (ost->encoding_needed &&
1959
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1960
                char logfilename[1024];
1961
                FILE *f;
1962
                int size;
1963
                char *logbuffer;
1964

    
1965
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1966
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1967
                         i);
1968
                if (codec->flags & CODEC_FLAG_PASS1) {
1969
                    f = fopen(logfilename, "w");
1970
                    if (!f) {
1971
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1972
                        av_exit(1);
1973
                    }
1974
                    ost->logfile = f;
1975
                } else {
1976
                    /* read the log file */
1977
                    f = fopen(logfilename, "r");
1978
                    if (!f) {
1979
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1980
                        av_exit(1);
1981
                    }
1982
                    fseek(f, 0, SEEK_END);
1983
                    size = ftell(f);
1984
                    fseek(f, 0, SEEK_SET);
1985
                    logbuffer = av_malloc(size + 1);
1986
                    if (!logbuffer) {
1987
                        fprintf(stderr, "Could not allocate log buffer\n");
1988
                        av_exit(1);
1989
                    }
1990
                    size = fread(logbuffer, 1, size, f);
1991
                    fclose(f);
1992
                    logbuffer[size] = '\0';
1993
                    codec->stats_in = logbuffer;
1994
                }
1995
            }
1996
        }
1997
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1998
            int size= codec->width * codec->height;
1999
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2000
        }
2001
    }
2002

    
2003
    if (!bit_buffer)
2004
        bit_buffer = av_malloc(bit_buffer_size);
2005
    if (!bit_buffer) {
2006
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2007
                bit_buffer_size);
2008
        ret = AVERROR(ENOMEM);
2009
        goto fail;
2010
    }
2011

    
2012
    /* open each encoder */
2013
    for(i=0;i<nb_ostreams;i++) {
2014
        ost = ost_table[i];
2015
        if (ost->encoding_needed) {
2016
            AVCodec *codec = output_codecs[i];
2017
            if (!codec)
2018
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2019
            if (!codec) {
2020
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2021
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2022
                ret = AVERROR(EINVAL);
2023
                goto dump_format;
2024
            }
2025
            if (avcodec_open(ost->st->codec, codec) < 0) {
2026
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2027
                        ost->file_index, ost->index);
2028
                ret = AVERROR(EINVAL);
2029
                goto dump_format;
2030
            }
2031
            extra_size += ost->st->codec->extradata_size;
2032
        }
2033
    }
2034

    
2035
    /* open each decoder */
2036
    for(i=0;i<nb_istreams;i++) {
2037
        ist = ist_table[i];
2038
        if (ist->decoding_needed) {
2039
            AVCodec *codec = input_codecs[i];
2040
            if (!codec)
2041
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2042
            if (!codec) {
2043
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2044
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2045
                ret = AVERROR(EINVAL);
2046
                goto dump_format;
2047
            }
2048
            if (avcodec_open(ist->st->codec, codec) < 0) {
2049
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2050
                        ist->file_index, ist->index);
2051
                ret = AVERROR(EINVAL);
2052
                goto dump_format;
2053
            }
2054
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2055
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2056
        }
2057
    }
2058

    
2059
    /* init pts */
2060
    for(i=0;i<nb_istreams;i++) {
2061
        ist = ist_table[i];
2062
        ist->pts = 0;
2063
        ist->next_pts = AV_NOPTS_VALUE;
2064
        ist->is_start = 1;
2065
    }
2066

    
2067
    /* set meta data information from input file if required */
2068
    for (i=0;i<nb_meta_data_maps;i++) {
2069
        AVFormatContext *out_file;
2070
        AVFormatContext *in_file;
2071
        AVMetadataTag *mtag;
2072

    
2073
        int out_file_index = meta_data_maps[i].out_file;
2074
        int in_file_index = meta_data_maps[i].in_file;
2075
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2076
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2077
                     out_file_index, out_file_index, in_file_index);
2078
            ret = AVERROR(EINVAL);
2079
            goto dump_format;
2080
        }
2081
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2082
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2083
                     in_file_index, out_file_index, in_file_index);
2084
            ret = AVERROR(EINVAL);
2085
            goto dump_format;
2086
        }
2087

    
2088
        out_file = output_files[out_file_index];
2089
        in_file = input_files[in_file_index];
2090

    
2091

    
2092
        mtag=NULL;
2093
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2094
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2095
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2096
                                    in_file->iformat->metadata_conv);
2097
    }
2098

    
2099
    /* open files and write file headers */
2100
    for(i=0;i<nb_output_files;i++) {
2101
        os = output_files[i];
2102
        if (av_write_header(os) < 0) {
2103
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2104
            ret = AVERROR(EINVAL);
2105
            goto dump_format;
2106
        }
2107
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2108
            want_sdp = 0;
2109
        }
2110
    }
2111

    
2112
 dump_format:
2113
    /* dump the file output parameters - cannot be done before in case
2114
       of stream copy */
2115
    for(i=0;i<nb_output_files;i++) {
2116
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2117
    }
2118

    
2119
    /* dump the stream mapping */
2120
    if (verbose >= 0) {
2121
        fprintf(stderr, "Stream mapping:\n");
2122
        for(i=0;i<nb_ostreams;i++) {
2123
            ost = ost_table[i];
2124
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2125
                    ist_table[ost->source_index]->file_index,
2126
                    ist_table[ost->source_index]->index,
2127
                    ost->file_index,
2128
                    ost->index);
2129
            if (ost->sync_ist != ist_table[ost->source_index])
2130
                fprintf(stderr, " [sync #%d.%d]",
2131
                        ost->sync_ist->file_index,
2132
                        ost->sync_ist->index);
2133
            fprintf(stderr, "\n");
2134
        }
2135
    }
2136

    
2137
    if (ret) {
2138
        fprintf(stderr, "%s\n", error);
2139
        goto fail;
2140
    }
2141

    
2142
    if (want_sdp) {
2143
        print_sdp(output_files, nb_output_files);
2144
    }
2145

    
2146
    if (!using_stdin && verbose >= 0) {
2147
        fprintf(stderr, "Press [q] to stop encoding\n");
2148
        url_set_interrupt_cb(decode_interrupt_cb);
2149
    }
2150
    term_init();
2151

    
2152
    timer_start = av_gettime();
2153

    
2154
    for(; received_sigterm == 0;) {
2155
        int file_index, ist_index;
2156
        AVPacket pkt;
2157
        double ipts_min;
2158
        double opts_min;
2159

    
2160
    redo:
2161
        ipts_min= 1e100;
2162
        opts_min= 1e100;
2163
        /* if 'q' pressed, exits */
2164
        if (!using_stdin) {
2165
            if (q_pressed)
2166
                break;
2167
            /* read_key() returns 0 on EOF */
2168
            key = read_key();
2169
            if (key == 'q')
2170
                break;
2171
        }
2172

    
2173
        /* select the stream that we must read now by looking at the
2174
           smallest output pts */
2175
        file_index = -1;
2176
        for(i=0;i<nb_ostreams;i++) {
2177
            double ipts, opts;
2178
            ost = ost_table[i];
2179
            os = output_files[ost->file_index];
2180
            ist = ist_table[ost->source_index];
2181
            if(no_packet[ist->file_index])
2182
                continue;
2183
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2184
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2185
            else
2186
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2187
            ipts = (double)ist->pts;
2188
            if (!file_table[ist->file_index].eof_reached){
2189
                if(ipts < ipts_min) {
2190
                    ipts_min = ipts;
2191
                    if(input_sync ) file_index = ist->file_index;
2192
                }
2193
                if(opts < opts_min) {
2194
                    opts_min = opts;
2195
                    if(!input_sync) file_index = ist->file_index;
2196
                }
2197
            }
2198
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2199
                file_index= -1;
2200
                break;
2201
            }
2202
        }
2203
        /* if none, if is finished */
2204
        if (file_index < 0) {
2205
            if(no_packet_count){
2206
                no_packet_count=0;
2207
                memset(no_packet, 0, sizeof(no_packet));
2208
                usleep(10000);
2209
                continue;
2210
            }
2211
            break;
2212
        }
2213

    
2214
        /* finish if recording time exhausted */
2215
        if (opts_min >= (recording_time / 1000000.0))
2216
            break;
2217

    
2218
        /* finish if limit size exhausted */
2219
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2220
            break;
2221

    
2222
        /* read a frame from it and output it in the fifo */
2223
        is = input_files[file_index];
2224
        ret= av_read_frame(is, &pkt);
2225
        if(ret == AVERROR(EAGAIN)){
2226
            no_packet[file_index]=1;
2227
            no_packet_count++;
2228
            continue;
2229
        }
2230
        if (ret < 0) {
2231
            file_table[file_index].eof_reached = 1;
2232
            if (opt_shortest)
2233
                break;
2234
            else
2235
                continue;
2236
        }
2237

    
2238
        no_packet_count=0;
2239
        memset(no_packet, 0, sizeof(no_packet));
2240

    
2241
        if (do_pkt_dump) {
2242
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2243
        }
2244
        /* the following test is needed in case new streams appear
2245
           dynamically in stream : we ignore them */
2246
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2247
            goto discard_packet;
2248
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2249
        ist = ist_table[ist_index];
2250
        if (ist->discard)
2251
            goto discard_packet;
2252

    
2253
        if (pkt.dts != AV_NOPTS_VALUE)
2254
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2255
        if (pkt.pts != AV_NOPTS_VALUE)
2256
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2257

    
2258
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2259
            if(pkt.pts != AV_NOPTS_VALUE)
2260
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2261
            if(pkt.dts != AV_NOPTS_VALUE)
2262
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2263
        }
2264

    
2265
//        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);
2266
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2267
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2268
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2269
            int64_t delta= pkt_dts - ist->next_pts;
2270
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2271
                input_files_ts_offset[ist->file_index]-= delta;
2272
                if (verbose > 2)
2273
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2274
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2275
                if(pkt.pts != AV_NOPTS_VALUE)
2276
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2277
            }
2278
        }
2279

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

    
2283
            if (verbose >= 0)
2284
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2285
                        ist->file_index, ist->index);
2286
            if (exit_on_error)
2287
                av_exit(1);
2288
            av_free_packet(&pkt);
2289
            goto redo;
2290
        }
2291

    
2292
    discard_packet:
2293
        av_free_packet(&pkt);
2294

    
2295
        /* dump report by using the output first video and audio streams */
2296
        print_report(output_files, ost_table, nb_ostreams, 0);
2297
    }
2298

    
2299
    /* at the end of stream, we must flush the decoder buffers */
2300
    for(i=0;i<nb_istreams;i++) {
2301
        ist = ist_table[i];
2302
        if (ist->decoding_needed) {
2303
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2304
        }
2305
    }
2306

    
2307
    term_exit();
2308

    
2309
    /* write the trailer if needed and close file */
2310
    for(i=0;i<nb_output_files;i++) {
2311
        os = output_files[i];
2312
        av_write_trailer(os);
2313
    }
2314

    
2315
    /* dump report by using the first video and audio streams */
2316
    print_report(output_files, ost_table, nb_ostreams, 1);
2317

    
2318
    /* close each encoder */
2319
    for(i=0;i<nb_ostreams;i++) {
2320
        ost = ost_table[i];
2321
        if (ost->encoding_needed) {
2322
            av_freep(&ost->st->codec->stats_in);
2323
            avcodec_close(ost->st->codec);
2324
        }
2325
    }
2326

    
2327
    /* close each decoder */
2328
    for(i=0;i<nb_istreams;i++) {
2329
        ist = ist_table[i];
2330
        if (ist->decoding_needed) {
2331
            avcodec_close(ist->st->codec);
2332
        }
2333
    }
2334

    
2335
    /* finished ! */
2336
    ret = 0;
2337

    
2338
 fail:
2339
    av_freep(&bit_buffer);
2340
    av_free(file_table);
2341

    
2342
    if (ist_table) {
2343
        for(i=0;i<nb_istreams;i++) {
2344
            ist = ist_table[i];
2345
            av_free(ist);
2346
        }
2347
        av_free(ist_table);
2348
    }
2349
    if (ost_table) {
2350
        for(i=0;i<nb_ostreams;i++) {
2351
            ost = ost_table[i];
2352
            if (ost) {
2353
                if (ost->logfile) {
2354
                    fclose(ost->logfile);
2355
                    ost->logfile = NULL;
2356
                }
2357
                av_fifo_free(ost->fifo); /* works even if fifo is not
2358
                                             initialized but set to zero */
2359
                av_free(ost->pict_tmp.data[0]);
2360
                if (ost->video_resample)
2361
                    sws_freeContext(ost->img_resample_ctx);
2362
                if (ost->resample)
2363
                    audio_resample_close(ost->resample);
2364
                if (ost->reformat_ctx)
2365
                    av_audio_convert_free(ost->reformat_ctx);
2366
                av_free(ost);
2367
            }
2368
        }
2369
        av_free(ost_table);
2370
    }
2371
    return ret;
2372
}
2373

    
2374
#if 0
2375
int file_read(const char *filename)
2376
{
2377
    URLContext *h;
2378
    unsigned char buffer[1024];
2379
    int len, i;
2380

2381
    if (url_open(&h, filename, O_RDONLY) < 0) {
2382
        printf("could not open '%s'\n", filename);
2383
        return -1;
2384
    }
2385
    for(;;) {
2386
        len = url_read(h, buffer, sizeof(buffer));
2387
        if (len <= 0)
2388
            break;
2389
        for(i=0;i<len;i++) putchar(buffer[i]);
2390
    }
2391
    url_close(h);
2392
    return 0;
2393
}
2394
#endif
2395

    
2396
static void opt_format(const char *arg)
2397
{
2398
    /* compatibility stuff for pgmyuv */
2399
    if (!strcmp(arg, "pgmyuv")) {
2400
        pgmyuv_compatibility_hack=1;
2401
//        opt_image_format(arg);
2402
        arg = "image2";
2403
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2404
    }
2405

    
2406
    file_iformat = av_find_input_format(arg);
2407
    file_oformat = guess_format(arg, NULL, NULL);
2408
    if (!file_iformat && !file_oformat) {
2409
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2410
        av_exit(1);
2411
    }
2412
}
2413

    
2414
static void opt_video_rc_override_string(const char *arg)
2415
{
2416
    video_rc_override_string = arg;
2417
}
2418

    
2419
static int opt_me_threshold(const char *opt, const char *arg)
2420
{
2421
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2422
    return 0;
2423
}
2424

    
2425
static int opt_verbose(const char *opt, const char *arg)
2426
{
2427
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2428
    return 0;
2429
}
2430

    
2431
static int opt_frame_rate(const char *opt, const char *arg)
2432
{
2433
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2434
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2435
        av_exit(1);
2436
    }
2437
    return 0;
2438
}
2439

    
2440
static int opt_bitrate(const char *opt, const char *arg)
2441
{
2442
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2443

    
2444
    opt_default(opt, arg);
2445

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

    
2449
    return 0;
2450
}
2451

    
2452
static void opt_frame_crop_top(const char *arg)
2453
{
2454
    frame_topBand = atoi(arg);
2455
    if (frame_topBand < 0) {
2456
        fprintf(stderr, "Incorrect top crop size\n");
2457
        av_exit(1);
2458
    }
2459
    if ((frame_topBand) >= frame_height){
2460
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2461
        av_exit(1);
2462
    }
2463
    frame_height -= frame_topBand;
2464
}
2465

    
2466
static void opt_frame_crop_bottom(const char *arg)
2467
{
2468
    frame_bottomBand = atoi(arg);
2469
    if (frame_bottomBand < 0) {
2470
        fprintf(stderr, "Incorrect bottom crop size\n");
2471
        av_exit(1);
2472
    }
2473
    if ((frame_bottomBand) >= frame_height){
2474
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2475
        av_exit(1);
2476
    }
2477
    frame_height -= frame_bottomBand;
2478
}
2479

    
2480
static void opt_frame_crop_left(const char *arg)
2481
{
2482
    frame_leftBand = atoi(arg);
2483
    if (frame_leftBand < 0) {
2484
        fprintf(stderr, "Incorrect left crop size\n");
2485
        av_exit(1);
2486
    }
2487
    if ((frame_leftBand) >= frame_width){
2488
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2489
        av_exit(1);
2490
    }
2491
    frame_width -= frame_leftBand;
2492
}
2493

    
2494
static void opt_frame_crop_right(const char *arg)
2495
{
2496
    frame_rightBand = atoi(arg);
2497
    if (frame_rightBand < 0) {
2498
        fprintf(stderr, "Incorrect right crop size\n");
2499
        av_exit(1);
2500
    }
2501
    if ((frame_rightBand) >= frame_width){
2502
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2503
        av_exit(1);
2504
    }
2505
    frame_width -= frame_rightBand;
2506
}
2507

    
2508
static void opt_frame_size(const char *arg)
2509
{
2510
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2511
        fprintf(stderr, "Incorrect frame size\n");
2512
        av_exit(1);
2513
    }
2514
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2515
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2516
        av_exit(1);
2517
    }
2518
}
2519

    
2520
static void opt_pad_color(const char *arg) {
2521
    /* Input is expected to be six hex digits similar to
2522
       how colors are expressed in html tags (but without the #) */
2523
    int rgb = strtol(arg, NULL, 16);
2524
    int r,g,b;
2525

    
2526
    r = (rgb >> 16);
2527
    g = ((rgb >> 8) & 255);
2528
    b = (rgb & 255);
2529

    
2530
    padcolor[0] = RGB_TO_Y(r,g,b);
2531
    padcolor[1] = RGB_TO_U(r,g,b,0);
2532
    padcolor[2] = RGB_TO_V(r,g,b,0);
2533
}
2534

    
2535
static void opt_frame_pad_top(const char *arg)
2536
{
2537
    frame_padtop = atoi(arg);
2538
    if (frame_padtop < 0) {
2539
        fprintf(stderr, "Incorrect top pad size\n");
2540
        av_exit(1);
2541
    }
2542
}
2543

    
2544
static void opt_frame_pad_bottom(const char *arg)
2545
{
2546
    frame_padbottom = atoi(arg);
2547
    if (frame_padbottom < 0) {
2548
        fprintf(stderr, "Incorrect bottom pad size\n");
2549
        av_exit(1);
2550
    }
2551
}
2552

    
2553

    
2554
static void opt_frame_pad_left(const char *arg)
2555
{
2556
    frame_padleft = atoi(arg);
2557
    if (frame_padleft < 0) {
2558
        fprintf(stderr, "Incorrect left pad size\n");
2559
        av_exit(1);
2560
    }
2561
}
2562

    
2563

    
2564
static void opt_frame_pad_right(const char *arg)
2565
{
2566
    frame_padright = atoi(arg);
2567
    if (frame_padright < 0) {
2568
        fprintf(stderr, "Incorrect right pad size\n");
2569
        av_exit(1);
2570
    }
2571
}
2572

    
2573
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2574
{
2575
    int i;
2576
    char fmt_str[128];
2577
    for (i=-1; i < nb_fmts; i++) {
2578
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2579
        fprintf(stdout, "%s\n", fmt_str);
2580
    }
2581
}
2582

    
2583
static void opt_frame_pix_fmt(const char *arg)
2584
{
2585
    if (strcmp(arg, "list")) {
2586
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2587
        if (frame_pix_fmt == PIX_FMT_NONE) {
2588
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2589
            av_exit(1);
2590
        }
2591
    } else {
2592
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2593
        av_exit(0);
2594
    }
2595
}
2596

    
2597
static void opt_frame_aspect_ratio(const char *arg)
2598
{
2599
    int x = 0, y = 0;
2600
    double ar = 0;
2601
    const char *p;
2602
    char *end;
2603

    
2604
    p = strchr(arg, ':');
2605
    if (p) {
2606
        x = strtol(arg, &end, 10);
2607
        if (end == p)
2608
            y = strtol(end+1, &end, 10);
2609
        if (x > 0 && y > 0)
2610
            ar = (double)x / (double)y;
2611
    } else
2612
        ar = strtod(arg, NULL);
2613

    
2614
    if (!ar) {
2615
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2616
        av_exit(1);
2617
    }
2618
    frame_aspect_ratio = ar;
2619
}
2620

    
2621
static int opt_metadata(const char *opt, const char *arg)
2622
{
2623
    char *mid= strchr(arg, '=');
2624

    
2625
    if(!mid){
2626
        fprintf(stderr, "Missing =\n");
2627
        av_exit(1);
2628
    }
2629
    *mid++= 0;
2630

    
2631
    metadata_count++;
2632
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2633
    metadata[metadata_count-1].key  = av_strdup(arg);
2634
    metadata[metadata_count-1].value= av_strdup(mid);
2635

    
2636
    return 0;
2637
}
2638

    
2639
static void opt_qscale(const char *arg)
2640
{
2641
    video_qscale = atof(arg);
2642
    if (video_qscale <= 0 ||
2643
        video_qscale > 255) {
2644
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2645
        av_exit(1);
2646
    }
2647
}
2648

    
2649
static void opt_top_field_first(const char *arg)
2650
{
2651
    top_field_first= atoi(arg);
2652
}
2653

    
2654
static int opt_thread_count(const char *opt, const char *arg)
2655
{
2656
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2657
#if !HAVE_THREADS
2658
    if (verbose >= 0)
2659
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2660
#endif
2661
    return 0;
2662
}
2663

    
2664
static void opt_audio_sample_fmt(const char *arg)
2665
{
2666
    if (strcmp(arg, "list"))
2667
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2668
    else {
2669
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2670
        av_exit(0);
2671
    }
2672
}
2673

    
2674
static int opt_audio_rate(const char *opt, const char *arg)
2675
{
2676
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2677
    return 0;
2678
}
2679

    
2680
static int opt_audio_channels(const char *opt, const char *arg)
2681
{
2682
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2683
    return 0;
2684
}
2685

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

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

    
2696
static void opt_codec(int *pstream_copy, char **pcodec_name,
2697
                      int codec_type, const char *arg)
2698
{
2699
    av_freep(pcodec_name);
2700
    if (!strcmp(arg, "copy")) {
2701
        *pstream_copy = 1;
2702
    } else {
2703
        *pcodec_name = av_strdup(arg);
2704
    }
2705
}
2706

    
2707
static void opt_audio_codec(const char *arg)
2708
{
2709
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2710
}
2711

    
2712
static void opt_audio_tag(const char *arg)
2713
{
2714
    char *tail;
2715
    audio_codec_tag= strtol(arg, &tail, 0);
2716

    
2717
    if(!tail || *tail)
2718
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2719
}
2720

    
2721
static void opt_video_tag(const char *arg)
2722
{
2723
    char *tail;
2724
    video_codec_tag= strtol(arg, &tail, 0);
2725

    
2726
    if(!tail || *tail)
2727
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2728
}
2729

    
2730
static void opt_video_codec(const char *arg)
2731
{
2732
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2733
}
2734

    
2735
static void opt_subtitle_codec(const char *arg)
2736
{
2737
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2738
}
2739

    
2740
static void opt_subtitle_tag(const char *arg)
2741
{
2742
    char *tail;
2743
    subtitle_codec_tag= strtol(arg, &tail, 0);
2744

    
2745
    if(!tail || *tail)
2746
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2747
}
2748

    
2749
static void opt_map(const char *arg)
2750
{
2751
    AVStreamMap *m;
2752
    char *p;
2753

    
2754
    m = &stream_maps[nb_stream_maps++];
2755

    
2756
    m->file_index = strtol(arg, &p, 0);
2757
    if (*p)
2758
        p++;
2759

    
2760
    m->stream_index = strtol(p, &p, 0);
2761
    if (*p) {
2762
        p++;
2763
        m->sync_file_index = strtol(p, &p, 0);
2764
        if (*p)
2765
            p++;
2766
        m->sync_stream_index = strtol(p, &p, 0);
2767
    } else {
2768
        m->sync_file_index = m->file_index;
2769
        m->sync_stream_index = m->stream_index;
2770
    }
2771
}
2772

    
2773
static void opt_map_meta_data(const char *arg)
2774
{
2775
    AVMetaDataMap *m;
2776
    char *p;
2777

    
2778
    m = &meta_data_maps[nb_meta_data_maps++];
2779

    
2780
    m->out_file = strtol(arg, &p, 0);
2781
    if (*p)
2782
        p++;
2783

    
2784
    m->in_file = strtol(p, &p, 0);
2785
}
2786

    
2787
static void opt_input_ts_scale(const char *arg)
2788
{
2789
    unsigned int stream;
2790
    double scale;
2791
    char *p;
2792

    
2793
    stream = strtol(arg, &p, 0);
2794
    if (*p)
2795
        p++;
2796
    scale= strtod(p, &p);
2797

    
2798
    if(stream >= MAX_STREAMS)
2799
        av_exit(1);
2800

    
2801
    input_files_ts_scale[nb_input_files][stream]= scale;
2802
}
2803

    
2804
static int opt_recording_time(const char *opt, const char *arg)
2805
{
2806
    recording_time = parse_time_or_die(opt, arg, 1);
2807
    return 0;
2808
}
2809

    
2810
static int opt_start_time(const char *opt, const char *arg)
2811
{
2812
    start_time = parse_time_or_die(opt, arg, 1);
2813
    return 0;
2814
}
2815

    
2816
static int opt_rec_timestamp(const char *opt, const char *arg)
2817
{
2818
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2819
    return 0;
2820
}
2821

    
2822
static int opt_input_ts_offset(const char *opt, const char *arg)
2823
{
2824
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2825
    return 0;
2826
}
2827

    
2828
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2829
{
2830
    const char *codec_string = encoder ? "encoder" : "decoder";
2831
    AVCodec *codec;
2832

    
2833
    if(!name)
2834
        return CODEC_ID_NONE;
2835
    codec = encoder ?
2836
        avcodec_find_encoder_by_name(name) :
2837
        avcodec_find_decoder_by_name(name);
2838
    if(!codec) {
2839
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2840
        av_exit(1);
2841
    }
2842
    if(codec->type != type) {
2843
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2844
        av_exit(1);
2845
    }
2846
    return codec->id;
2847
}
2848

    
2849
static void opt_input_file(const char *filename)
2850
{
2851
    AVFormatContext *ic;
2852
    AVFormatParameters params, *ap = &params;
2853
    int err, i, ret, rfps, rfps_base;
2854
    int64_t timestamp;
2855

    
2856
    if (!strcmp(filename, "-"))
2857
        filename = "pipe:";
2858

    
2859
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2860
                    !strcmp(filename, "/dev/stdin");
2861

    
2862
    /* get default parameters from command line */
2863
    ic = avformat_alloc_context();
2864

    
2865
    memset(ap, 0, sizeof(*ap));
2866
    ap->prealloced_context = 1;
2867
    ap->sample_rate = audio_sample_rate;
2868
    ap->channels = audio_channels;
2869
    ap->time_base.den = frame_rate.num;
2870
    ap->time_base.num = frame_rate.den;
2871
    ap->width = frame_width + frame_padleft + frame_padright;
2872
    ap->height = frame_height + frame_padtop + frame_padbottom;
2873
    ap->pix_fmt = frame_pix_fmt;
2874
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2875
    ap->channel = video_channel;
2876
    ap->standard = video_standard;
2877
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2878
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2879
    if(pgmyuv_compatibility_hack)
2880
        ap->video_codec_id= CODEC_ID_PGMYUV;
2881

    
2882
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2883

    
2884
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2885
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2886
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2887
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2888

    
2889
    /* open the input file with generic libav function */
2890
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2891
    if (err < 0) {
2892
        print_error(filename, err);
2893
        av_exit(1);
2894
    }
2895
    if(opt_programid) {
2896
        int i;
2897
        for(i=0; i<ic->nb_programs; i++)
2898
            if(ic->programs[i]->id != opt_programid)
2899
                ic->programs[i]->discard = AVDISCARD_ALL;
2900
    }
2901

    
2902
    ic->loop_input = loop_input;
2903

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

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

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

    
2928
    /* update the current parameters so that they match the one of the input stream */
2929
    for(i=0;i<ic->nb_streams;i++) {
2930
        AVCodecContext *enc = ic->streams[i]->codec;
2931
        if(thread_count>1)
2932
            avcodec_thread_init(enc, thread_count);
2933
        enc->thread_count= thread_count;
2934
        switch(enc->codec_type) {
2935
        case CODEC_TYPE_AUDIO:
2936
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2937
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2938
            channel_layout = enc->channel_layout;
2939
            audio_channels = enc->channels;
2940
            audio_sample_rate = enc->sample_rate;
2941
            audio_sample_fmt = enc->sample_fmt;
2942
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2943
            if(audio_disable)
2944
                ic->streams[i]->discard= AVDISCARD_ALL;
2945
            break;
2946
        case CODEC_TYPE_VIDEO:
2947
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2948
            frame_height = enc->height;
2949
            frame_width = enc->width;
2950
            if(ic->streams[i]->sample_aspect_ratio.num)
2951
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2952
            else
2953
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2954
            frame_aspect_ratio *= (float) enc->width / enc->height;
2955
            frame_pix_fmt = enc->pix_fmt;
2956
            rfps      = ic->streams[i]->r_frame_rate.num;
2957
            rfps_base = ic->streams[i]->r_frame_rate.den;
2958
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2959
            if(me_threshold)
2960
                enc->debug |= FF_DEBUG_MV;
2961

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

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

    
2968
                    (float)rfps / rfps_base, rfps, rfps_base);
2969
            }
2970
            /* update the current frame rate to match the stream frame rate */
2971
            frame_rate.num = rfps;
2972
            frame_rate.den = rfps_base;
2973

    
2974
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2975
            if(video_disable)
2976
                ic->streams[i]->discard= AVDISCARD_ALL;
2977
            else if(video_discard)
2978
                ic->streams[i]->discard= video_discard;
2979
            break;
2980
        case CODEC_TYPE_DATA:
2981
            break;
2982
        case CODEC_TYPE_SUBTITLE:
2983
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2984
            if(subtitle_disable)
2985
                ic->streams[i]->discard = AVDISCARD_ALL;
2986
            break;
2987
        case CODEC_TYPE_ATTACHMENT:
2988
        case CODEC_TYPE_UNKNOWN:
2989
            nb_icodecs++;
2990
            break;
2991
        default:
2992
            abort();
2993
        }
2994
    }
2995

    
2996
    input_files[nb_input_files] = ic;
2997
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2998
    /* dump the file content */
2999
    if (verbose >= 0)
3000
        dump_format(ic, nb_input_files, filename, 0);
3001

    
3002
    nb_input_files++;
3003
    file_iformat = NULL;
3004
    file_oformat = NULL;
3005

    
3006
    video_channel = 0;
3007

    
3008
    av_freep(&video_codec_name);
3009
    av_freep(&audio_codec_name);
3010
    av_freep(&subtitle_codec_name);
3011
}
3012

    
3013
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3014
                                         int *has_subtitle_ptr)
3015
{
3016
    int has_video, has_audio, has_subtitle, i, j;
3017
    AVFormatContext *ic;
3018

    
3019
    has_video = 0;
3020
    has_audio = 0;
3021
    has_subtitle = 0;
3022
    for(j=0;j<nb_input_files;j++) {
3023
        ic = input_files[j];
3024
        for(i=0;i<ic->nb_streams;i++) {
3025
            AVCodecContext *enc = ic->streams[i]->codec;
3026
            switch(enc->codec_type) {
3027
            case CODEC_TYPE_AUDIO:
3028
                has_audio = 1;
3029
                break;
3030
            case CODEC_TYPE_VIDEO:
3031
                has_video = 1;
3032
                break;
3033
            case CODEC_TYPE_SUBTITLE:
3034
                has_subtitle = 1;
3035
                break;
3036
            case CODEC_TYPE_DATA:
3037
            case CODEC_TYPE_ATTACHMENT:
3038
            case CODEC_TYPE_UNKNOWN:
3039
                break;
3040
            default:
3041
                abort();
3042
            }
3043
        }
3044
    }
3045
    *has_video_ptr = has_video;
3046
    *has_audio_ptr = has_audio;
3047
    *has_subtitle_ptr = has_subtitle;
3048
}
3049

    
3050
static void new_video_stream(AVFormatContext *oc)
3051
{
3052
    AVStream *st;
3053
    AVCodecContext *video_enc;
3054
    int codec_id;
3055

    
3056
    st = av_new_stream(oc, oc->nb_streams);
3057
    if (!st) {
3058
        fprintf(stderr, "Could not alloc stream\n");
3059
        av_exit(1);
3060
    }
3061
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3062
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3063
    video_bitstream_filters= NULL;
3064

    
3065
    if(thread_count>1)
3066
        avcodec_thread_init(st->codec, thread_count);
3067

    
3068
    video_enc = st->codec;
3069

    
3070
    if(video_codec_tag)
3071
        video_enc->codec_tag= video_codec_tag;
3072

    
3073
    if(   (video_global_header&1)
3074
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3075
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3076
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3077
    }
3078
    if(video_global_header&2){
3079
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3080
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3081
    }
3082

    
3083
    if (video_stream_copy) {
3084
        st->stream_copy = 1;
3085
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3086
        video_enc->sample_aspect_ratio =
3087
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3088
    } else {
3089
        const char *p;
3090
        int i;
3091
        AVCodec *codec;
3092
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3093

    
3094
        if (video_codec_name) {
3095
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3096
            codec = avcodec_find_encoder_by_name(video_codec_name);
3097
            output_codecs[nb_ocodecs] = codec;
3098
        } else {
3099
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3100
            codec = avcodec_find_encoder(codec_id);
3101
        }
3102

    
3103
        video_enc->codec_id = codec_id;
3104

    
3105
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3106

    
3107
        if (codec && codec->supported_framerates && !force_fps)
3108
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3109
        video_enc->time_base.den = fps.num;
3110
        video_enc->time_base.num = fps.den;
3111

    
3112
        video_enc->width = frame_width + frame_padright + frame_padleft;
3113
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3114
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3115
        video_enc->pix_fmt = frame_pix_fmt;
3116
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3117

    
3118
        if(codec && codec->pix_fmts){
3119
            const enum PixelFormat *p= codec->pix_fmts;
3120
            for(; *p!=-1; p++){
3121
                if(*p == video_enc->pix_fmt)
3122
                    break;
3123
            }
3124
            if(*p == -1)
3125
                video_enc->pix_fmt = codec->pix_fmts[0];
3126
        }
3127

    
3128
        if (intra_only)
3129
            video_enc->gop_size = 0;
3130
        if (video_qscale || same_quality) {
3131
            video_enc->flags |= CODEC_FLAG_QSCALE;
3132
            video_enc->global_quality=
3133
                st->quality = FF_QP2LAMBDA * video_qscale;
3134
        }
3135

    
3136
        if(intra_matrix)
3137
            video_enc->intra_matrix = intra_matrix;
3138
        if(inter_matrix)
3139
            video_enc->inter_matrix = inter_matrix;
3140

    
3141
        video_enc->thread_count = thread_count;
3142
        p= video_rc_override_string;
3143
        for(i=0; p; i++){
3144
            int start, end, q;
3145
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3146
            if(e!=3){
3147
                fprintf(stderr, "error parsing rc_override\n");
3148
                av_exit(1);
3149
            }
3150
            video_enc->rc_override=
3151
                av_realloc(video_enc->rc_override,
3152
                           sizeof(RcOverride)*(i+1));
3153
            video_enc->rc_override[i].start_frame= start;
3154
            video_enc->rc_override[i].end_frame  = end;
3155
            if(q>0){
3156
                video_enc->rc_override[i].qscale= q;
3157
                video_enc->rc_override[i].quality_factor= 1.0;
3158
            }
3159
            else{
3160
                video_enc->rc_override[i].qscale= 0;
3161
                video_enc->rc_override[i].quality_factor= -q/100.0;
3162
            }
3163
            p= strchr(p, '/');
3164
            if(p) p++;
3165
        }
3166
        video_enc->rc_override_count=i;
3167
        if (!video_enc->rc_initial_buffer_occupancy)
3168
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3169
        video_enc->me_threshold= me_threshold;
3170
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3171

    
3172
        if (do_psnr)
3173
            video_enc->flags|= CODEC_FLAG_PSNR;
3174

    
3175
        /* two pass mode */
3176
        if (do_pass) {
3177
            if (do_pass == 1) {
3178
                video_enc->flags |= CODEC_FLAG_PASS1;
3179
            } else {
3180
                video_enc->flags |= CODEC_FLAG_PASS2;
3181
            }
3182
        }
3183
    }
3184
    nb_ocodecs++;
3185

    
3186
    /* reset some key parameters */
3187
    video_disable = 0;
3188
    av_freep(&video_codec_name);
3189
    video_stream_copy = 0;
3190
}
3191

    
3192
static void new_audio_stream(AVFormatContext *oc)
3193
{
3194
    AVStream *st;
3195
    AVCodecContext *audio_enc;
3196
    int codec_id;
3197

    
3198
    st = av_new_stream(oc, oc->nb_streams);
3199
    if (!st) {
3200
        fprintf(stderr, "Could not alloc stream\n");
3201
        av_exit(1);
3202
    }
3203
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3204

    
3205
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3206
    audio_bitstream_filters= NULL;
3207

    
3208
    if(thread_count>1)
3209
        avcodec_thread_init(st->codec, thread_count);
3210

    
3211
    audio_enc = st->codec;
3212
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3213

    
3214
    if(audio_codec_tag)
3215
        audio_enc->codec_tag= audio_codec_tag;
3216

    
3217
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3218
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3219
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3220
    }
3221
    if (audio_stream_copy) {
3222
        st->stream_copy = 1;
3223
        audio_enc->channels = audio_channels;
3224
    } else {
3225
        AVCodec *codec;
3226

    
3227
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3228

    
3229
        if (audio_codec_name) {
3230
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3231
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3232
            output_codecs[nb_ocodecs] = codec;
3233
        } else {
3234
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3235
            codec = avcodec_find_encoder(codec_id);
3236
        }
3237
        audio_enc->codec_id = codec_id;
3238

    
3239
        if (audio_qscale > QSCALE_NONE) {
3240
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3241
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3242
        }
3243
        audio_enc->thread_count = thread_count;
3244
        audio_enc->channels = audio_channels;
3245
        audio_enc->sample_fmt = audio_sample_fmt;
3246
        audio_enc->channel_layout = channel_layout;
3247
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3248
            audio_enc->channel_layout = 0;
3249

    
3250
        if(codec && codec->sample_fmts){
3251
            const enum SampleFormat *p= codec->sample_fmts;
3252
            for(; *p!=-1; p++){
3253
                if(*p == audio_enc->sample_fmt)
3254
                    break;
3255
            }
3256
            if(*p == -1)
3257
                audio_enc->sample_fmt = codec->sample_fmts[0];
3258
        }
3259
    }
3260
    nb_ocodecs++;
3261
    audio_enc->sample_rate = audio_sample_rate;
3262
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3263
    if (audio_language) {
3264
        av_metadata_set(&st->metadata, "language", audio_language);
3265
        av_free(audio_language);
3266
        audio_language = NULL;
3267
    }
3268

    
3269
    /* reset some key parameters */
3270
    audio_disable = 0;
3271
    av_freep(&audio_codec_name);
3272
    audio_stream_copy = 0;
3273
}
3274

    
3275
static void new_subtitle_stream(AVFormatContext *oc)
3276
{
3277
    AVStream *st;
3278
    AVCodecContext *subtitle_enc;
3279

    
3280
    st = av_new_stream(oc, oc->nb_streams);
3281
    if (!st) {
3282
        fprintf(stderr, "Could not alloc stream\n");
3283
        av_exit(1);
3284
    }
3285
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3286

    
3287
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3288
    subtitle_bitstream_filters= NULL;
3289

    
3290
    subtitle_enc = st->codec;
3291
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3292

    
3293
    if(subtitle_codec_tag)
3294
        subtitle_enc->codec_tag= subtitle_codec_tag;
3295

    
3296
    if (subtitle_stream_copy) {
3297
        st->stream_copy = 1;
3298
    } else {
3299
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3300
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3301
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3302
    }
3303
    nb_ocodecs++;
3304

    
3305
    if (subtitle_language) {
3306
        av_metadata_set(&st->metadata, "language", subtitle_language);
3307
        av_free(subtitle_language);
3308
        subtitle_language = NULL;
3309
    }
3310

    
3311
    subtitle_disable = 0;
3312
    av_freep(&subtitle_codec_name);
3313
    subtitle_stream_copy = 0;
3314
}
3315

    
3316
static void opt_new_audio_stream(void)
3317
{
3318
    AVFormatContext *oc;
3319
    if (nb_output_files <= 0) {
3320
        fprintf(stderr, "At least one output file must be specified\n");
3321
        av_exit(1);
3322
    }
3323
    oc = output_files[nb_output_files - 1];
3324
    new_audio_stream(oc);
3325
}
3326

    
3327
static void opt_new_video_stream(void)
3328
{
3329
    AVFormatContext *oc;
3330
    if (nb_output_files <= 0) {
3331
        fprintf(stderr, "At least one output file must be specified\n");
3332
        av_exit(1);
3333
    }
3334
    oc = output_files[nb_output_files - 1];
3335
    new_video_stream(oc);
3336
}
3337

    
3338
static void opt_new_subtitle_stream(void)
3339
{
3340
    AVFormatContext *oc;
3341
    if (nb_output_files <= 0) {
3342
        fprintf(stderr, "At least one output file must be specified\n");
3343
        av_exit(1);
3344
    }
3345
    oc = output_files[nb_output_files - 1];
3346
    new_subtitle_stream(oc);
3347
}
3348

    
3349
static void opt_output_file(const char *filename)
3350
{
3351
    AVFormatContext *oc;
3352
    int use_video, use_audio, use_subtitle;
3353
    int input_has_video, input_has_audio, input_has_subtitle;
3354
    AVFormatParameters params, *ap = &params;
3355

    
3356
    if (!strcmp(filename, "-"))
3357
        filename = "pipe:";
3358

    
3359
    oc = avformat_alloc_context();
3360

    
3361
    if (!file_oformat) {
3362
        file_oformat = guess_format(NULL, filename, NULL);
3363
        if (!file_oformat) {
3364
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3365
                    filename);
3366
            av_exit(1);
3367
        }
3368
    }
3369

    
3370
    oc->oformat = file_oformat;
3371
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3372

    
3373
    if (!strcmp(file_oformat->name, "ffm") &&
3374
        av_strstart(filename, "http:", NULL)) {
3375
        /* special case for files sent to ffserver: we get the stream
3376
           parameters from ffserver */
3377
        int err = read_ffserver_streams(oc, filename);
3378
        if (err < 0) {
3379
            print_error(filename, err);
3380
            av_exit(1);
3381
        }
3382
    } else {
3383
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3384
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3385
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3386

    
3387
        /* disable if no corresponding type found and at least one
3388
           input file */
3389
        if (nb_input_files > 0) {
3390
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3391
                                         &input_has_subtitle);
3392
            if (!input_has_video)
3393
                use_video = 0;
3394
            if (!input_has_audio)
3395
                use_audio = 0;
3396
            if (!input_has_subtitle)
3397
                use_subtitle = 0;
3398
        }
3399

    
3400
        /* manual disable */
3401
        if (audio_disable) {
3402
            use_audio = 0;
3403
        }
3404
        if (video_disable) {
3405
            use_video = 0;
3406
        }
3407
        if (subtitle_disable) {
3408
            use_subtitle = 0;
3409
        }
3410

    
3411
        if (use_video) {
3412
            new_video_stream(oc);
3413
        }
3414

    
3415
        if (use_audio) {
3416
            new_audio_stream(oc);
3417
        }
3418

    
3419
        if (use_subtitle) {
3420
            new_subtitle_stream(oc);
3421
        }
3422

    
3423
        oc->timestamp = rec_timestamp;
3424

    
3425
        for(; metadata_count>0; metadata_count--){
3426
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3427
                                           metadata[metadata_count-1].value);
3428
        }
3429
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3430
    }
3431

    
3432
    output_files[nb_output_files++] = oc;
3433

    
3434
    /* check filename in case of an image number is expected */
3435
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3436
        if (!av_filename_number_test(oc->filename)) {
3437
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3438
            av_exit(1);
3439
        }
3440
    }
3441

    
3442
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3443
        /* test if it already exists to avoid loosing precious files */
3444
        if (!file_overwrite &&
3445
            (strchr(filename, ':') == NULL ||
3446
             filename[1] == ':' ||
3447
             av_strstart(filename, "file:", NULL))) {
3448
            if (url_exist(filename)) {
3449
                if (!using_stdin) {
3450
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3451
                    fflush(stderr);
3452
                    if (!read_yesno()) {
3453
                        fprintf(stderr, "Not overwriting - exiting\n");
3454
                        av_exit(1);
3455
                    }
3456
                }
3457
                else {
3458
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3459
                    av_exit(1);
3460
                }
3461
            }
3462
        }
3463

    
3464
        /* open the file */
3465
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3466
            fprintf(stderr, "Could not open '%s'\n", filename);
3467
            av_exit(1);
3468
        }
3469
    }
3470

    
3471
    memset(ap, 0, sizeof(*ap));
3472
    if (av_set_parameters(oc, ap) < 0) {
3473
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3474
                oc->filename);
3475
        av_exit(1);
3476
    }
3477

    
3478
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3479
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3480
    oc->loop_output = loop_output;
3481
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3482

    
3483
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3484

    
3485
    /* reset some options */
3486
    file_oformat = NULL;
3487
    file_iformat = NULL;
3488
}
3489

    
3490
/* same option as mencoder */
3491
static void opt_pass(const char *pass_str)
3492
{
3493
    int pass;
3494
    pass = atoi(pass_str);
3495
    if (pass != 1 && pass != 2) {
3496
        fprintf(stderr, "pass number can be only 1 or 2\n");
3497
        av_exit(1);
3498
    }
3499
    do_pass = pass;
3500
}
3501

    
3502
static int64_t getutime(void)
3503
{
3504
#if HAVE_GETRUSAGE
3505
    struct rusage rusage;
3506

    
3507
    getrusage(RUSAGE_SELF, &rusage);
3508
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3509
#elif HAVE_GETPROCESSTIMES
3510
    HANDLE proc;
3511
    FILETIME c, e, k, u;
3512
    proc = GetCurrentProcess();
3513
    GetProcessTimes(proc, &c, &e, &k, &u);
3514
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3515
#else
3516
    return av_gettime();
3517
#endif
3518
}
3519

    
3520
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3521
{
3522
    int i;
3523
    const char *p = str;
3524
    for(i = 0;; i++) {
3525
        dest[i] = atoi(p);
3526
        if(i == 63)
3527
            break;
3528
        p = strchr(p, ',');
3529
        if(!p) {
3530
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3531
            av_exit(1);
3532
        }
3533
        p++;
3534
    }
3535
}
3536

    
3537
static void opt_inter_matrix(const char *arg)
3538
{
3539
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3540
    parse_matrix_coeffs(inter_matrix, arg);
3541
}
3542

    
3543
static void opt_intra_matrix(const char *arg)
3544
{
3545
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3546
    parse_matrix_coeffs(intra_matrix, arg);
3547
}
3548

    
3549
/**
3550
 * Trivial log callback.
3551
 * Only suitable for show_help and similar since it lacks prefix handling.
3552
 */
3553
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3554
{
3555
    vfprintf(stdout, fmt, vl);
3556
}
3557

    
3558
static void show_help(void)
3559
{
3560
    av_log_set_callback(log_callback_help);
3561
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3562
           "Hyper fast Audio and Video encoder\n");
3563
    printf("\n");
3564
    show_help_options(options, "Main options:\n",
3565
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3566
    show_help_options(options, "\nAdvanced options:\n",
3567
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3568
                      OPT_EXPERT);
3569
    show_help_options(options, "\nVideo options:\n",
3570
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3571
                      OPT_VIDEO);
3572
    show_help_options(options, "\nAdvanced Video options:\n",
3573
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3574
                      OPT_VIDEO | OPT_EXPERT);
3575
    show_help_options(options, "\nAudio options:\n",
3576
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3577
                      OPT_AUDIO);
3578
    show_help_options(options, "\nAdvanced Audio options:\n",
3579
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3580
                      OPT_AUDIO | OPT_EXPERT);
3581
    show_help_options(options, "\nSubtitle options:\n",
3582
                      OPT_SUBTITLE | OPT_GRAB,
3583
                      OPT_SUBTITLE);
3584
    show_help_options(options, "\nAudio/Video grab options:\n",
3585
                      OPT_GRAB,
3586
                      OPT_GRAB);
3587
    printf("\n");
3588
    av_opt_show(avcodec_opts[0], NULL);
3589
    printf("\n");
3590
    av_opt_show(avformat_opts, NULL);
3591
    printf("\n");
3592
    av_opt_show(sws_opts, NULL);
3593
}
3594

    
3595
static void opt_target(const char *arg)
3596
{
3597
    int norm = -1;
3598
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3599

    
3600
    if(!strncmp(arg, "pal-", 4)) {
3601
        norm = 0;
3602
        arg += 4;
3603
    } else if(!strncmp(arg, "ntsc-", 5)) {
3604
        norm = 1;
3605
        arg += 5;
3606
    } else if(!strncmp(arg, "film-", 5)) {
3607
        norm = 2;
3608
        arg += 5;
3609
    } else {
3610
        int fr;
3611
        /* Calculate FR via float to avoid int overflow */
3612
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3613
        if(fr == 25000) {
3614
            norm = 0;
3615
        } else if((fr == 29970) || (fr == 23976)) {
3616
            norm = 1;
3617
        } else {
3618
            /* Try to determine PAL/NTSC by peeking in the input files */
3619
            if(nb_input_files) {
3620
                int i, j;
3621
                for(j = 0; j < nb_input_files; j++) {
3622
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3623
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3624
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3625
                            continue;
3626
                        fr = c->time_base.den * 1000 / c->time_base.num;
3627
                        if(fr == 25000) {
3628
                            norm = 0;
3629
                            break;
3630
                        } else if((fr == 29970) || (fr == 23976)) {
3631
                            norm = 1;
3632
                            break;
3633
                        }
3634
                    }
3635
                    if(norm >= 0)
3636
                        break;
3637
                }
3638
            }
3639
        }
3640
        if(verbose && norm >= 0)
3641
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3642
    }
3643

    
3644
    if(norm < 0) {
3645
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3646
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3647
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3648
        av_exit(1);
3649
    }
3650

    
3651
    if(!strcmp(arg, "vcd")) {
3652

    
3653
        opt_video_codec("mpeg1video");
3654
        opt_audio_codec("mp2");
3655
        opt_format("vcd");
3656

    
3657
        opt_frame_size(norm ? "352x240" : "352x288");
3658
        opt_frame_rate(NULL, frame_rates[norm]);
3659
        opt_default("gop", norm ? "18" : "15");
3660

    
3661
        opt_default("b", "1150000");
3662
        opt_default("maxrate", "1150000");
3663
        opt_default("minrate", "1150000");
3664
        opt_default("bufsize", "327680"); // 40*1024*8;
3665

    
3666
        opt_default("ab", "224000");
3667
        audio_sample_rate = 44100;
3668
        audio_channels = 2;
3669

    
3670
        opt_default("packetsize", "2324");
3671
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3672

    
3673
        /* We have to offset the PTS, so that it is consistent with the SCR.
3674
           SCR starts at 36000, but the first two packs contain only padding
3675
           and the first pack from the other stream, respectively, may also have
3676
           been written before.
3677
           So the real data starts at SCR 36000+3*1200. */
3678
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3679
    } else if(!strcmp(arg, "svcd")) {
3680

    
3681
        opt_video_codec("mpeg2video");
3682
        opt_audio_codec("mp2");
3683
        opt_format("svcd");
3684

    
3685
        opt_frame_size(norm ? "480x480" : "480x576");
3686
        opt_frame_rate(NULL, frame_rates[norm]);
3687
        opt_default("gop", norm ? "18" : "15");
3688

    
3689
        opt_default("b", "2040000");
3690
        opt_default("maxrate", "2516000");
3691
        opt_default("minrate", "0"); //1145000;
3692
        opt_default("bufsize", "1835008"); //224*1024*8;
3693
        opt_default("flags", "+scan_offset");
3694

    
3695

    
3696
        opt_default("ab", "224000");
3697
        audio_sample_rate = 44100;
3698

    
3699
        opt_default("packetsize", "2324");
3700

    
3701
    } else if(!strcmp(arg, "dvd")) {
3702

    
3703
        opt_video_codec("mpeg2video");
3704
        opt_audio_codec("ac3");
3705
        opt_format("dvd");
3706

    
3707
        opt_frame_size(norm ? "720x480" : "720x576");
3708
        opt_frame_rate(NULL, frame_rates[norm]);
3709
        opt_default("gop", norm ? "18" : "15");
3710

    
3711
        opt_default("b", "6000000");
3712
        opt_default("maxrate", "9000000");
3713
        opt_default("minrate", "0"); //1500000;
3714
        opt_default("bufsize", "1835008"); //224*1024*8;
3715

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

    
3719
        opt_default("ab", "448000");
3720
        audio_sample_rate = 48000;
3721

    
3722
    } else if(!strncmp(arg, "dv", 2)) {
3723

    
3724
        opt_format("dv");
3725

    
3726
        opt_frame_size(norm ? "720x480" : "720x576");
3727
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3728
                                             (norm ? "yuv411p" : "yuv420p"));
3729
        opt_frame_rate(NULL, frame_rates[norm]);
3730

    
3731
        audio_sample_rate = 48000;
3732
        audio_channels = 2;
3733

    
3734
    } else {
3735
        fprintf(stderr, "Unknown target: %s\n", arg);
3736
        av_exit(1);
3737
    }
3738
}
3739

    
3740
static void opt_vstats_file (const char *arg)
3741
{
3742
    av_free (vstats_filename);
3743
    vstats_filename=av_strdup (arg);
3744
}
3745

    
3746
static void opt_vstats (void)
3747
{
3748
    char filename[40];
3749
    time_t today2 = time(NULL);
3750
    struct tm *today = localtime(&today2);
3751

    
3752
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3753
             today->tm_sec);
3754
    opt_vstats_file(filename);
3755
}
3756

    
3757
static int opt_bsf(const char *opt, const char *arg)
3758
{
3759
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3760
    AVBitStreamFilterContext **bsfp;
3761

    
3762
    if(!bsfc){
3763
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3764
        av_exit(1);
3765
    }
3766

    
3767
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3768
          *opt == 'a' ? &audio_bitstream_filters :
3769
                        &subtitle_bitstream_filters;
3770
    while(*bsfp)
3771
        bsfp= &(*bsfp)->next;
3772

    
3773
    *bsfp= bsfc;
3774

    
3775
    return 0;
3776
}
3777

    
3778
static int opt_preset(const char *opt, const char *arg)
3779
{
3780
    FILE *f=NULL;
3781
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3782
    int i;
3783
    const char *base[2]= { getenv("HOME"),
3784
                           FFMPEG_DATADIR,
3785
                         };
3786

    
3787
    for(i=!base[0]; i<2 && !f; i++){
3788
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3789
        f= fopen(filename, "r");
3790
        if(!f){
3791
            char *codec_name= *opt == 'v' ? video_codec_name :
3792
                              *opt == 'a' ? audio_codec_name :
3793
                                            subtitle_codec_name;
3794
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3795
            f= fopen(filename, "r");
3796
        }
3797
    }
3798
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3799
              is_dos_path(arg))){
3800
        av_strlcpy(filename, arg, sizeof(filename));
3801
        f= fopen(filename, "r");
3802
    }
3803

    
3804
    if(!f){
3805
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3806
        av_exit(1);
3807
    }
3808

    
3809
    while(!feof(f)){
3810
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3811
        if(line[0] == '#' && !e)
3812
            continue;
3813
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3814
        if(e){
3815
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3816
            av_exit(1);
3817
        }
3818
        if(!strcmp(tmp, "acodec")){
3819
            opt_audio_codec(tmp2);
3820
        }else if(!strcmp(tmp, "vcodec")){
3821
            opt_video_codec(tmp2);
3822
        }else if(!strcmp(tmp, "scodec")){
3823
            opt_subtitle_codec(tmp2);
3824
        }else if(opt_default(tmp, tmp2) < 0){
3825
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3826
            av_exit(1);
3827
        }
3828
    }
3829

    
3830
    fclose(f);
3831

    
3832
    return 0;
3833
}
3834

    
3835
static const OptionDef options[] = {
3836
    /* main options */
3837
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3838
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3839
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3840
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3841
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3842
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3843
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3844
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3845
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3846
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3847
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3848
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3849
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3850
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3851
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3852
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3853
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3854
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3855
      "add timings for benchmarking" },
3856
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3857
      "dump each input packet" },
3858
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3859
      "when dumping packets, also dump the payload" },
3860
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3861
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3862
    { "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)", "" },
3863
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3864
    { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "logging level number or string" },
3865
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3866
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3867
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3868
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3869
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3870
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3871
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3872
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3873
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3874
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3875
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3876
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3877

    
3878
    /* video options */
3879
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3880
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3881
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3882
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3883
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3884
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3885
    { "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" },
3886
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3887
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3888
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3889
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3890
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3891
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3892
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3893
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3894
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3895
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3896
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3897
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3898
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3899
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3900
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3901
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3902
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3903
      "use same video quality as source (implies VBR)" },
3904
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3905
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3906
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3907
      "deinterlace pictures" },
3908
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3909
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3910
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3911
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3912
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3913
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3914
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3915
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3916
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3917
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3918
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3919

    
3920
    /* audio options */
3921
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3922
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3923
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3924
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3925
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3926
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3927
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3928
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3929
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3930
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3931
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3932
    { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3933

    
3934
    /* subtitle options */
3935
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3936
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3937
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3938
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3939
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3940

    
3941
    /* grab options */
3942
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3943
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3944
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3945

    
3946
    /* muxer options */
3947
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3948
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3949

    
3950
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3951
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3952
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3953

    
3954
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3955
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3956
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3957

    
3958
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3959
    { NULL, },
3960
};
3961

    
3962
int main(int argc, char **argv)
3963
{
3964
    int i;
3965
    int64_t ti;
3966

    
3967
    avcodec_register_all();
3968
    avdevice_register_all();
3969
    av_register_all();
3970

    
3971
    if(isatty(STDIN_FILENO))
3972
        url_set_interrupt_cb(decode_interrupt_cb);
3973

    
3974
    for(i=0; i<CODEC_TYPE_NB; i++){
3975
        avcodec_opts[i]= avcodec_alloc_context2(i);
3976
    }
3977
    avformat_opts = avformat_alloc_context();
3978
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3979

    
3980
    show_banner();
3981

    
3982
    /* parse options */
3983
    parse_options(argc, argv, options, opt_output_file);
3984

    
3985
    /* file converter / grab */
3986
    if (nb_output_files <= 0) {
3987
        fprintf(stderr, "At least one output file must be specified\n");
3988
        av_exit(1);
3989
    }
3990

    
3991
    if (nb_input_files == 0) {
3992
        fprintf(stderr, "At least one input file must be specified\n");
3993
        av_exit(1);
3994
    }
3995

    
3996
    ti = getutime();
3997
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3998
                  stream_maps, nb_stream_maps) < 0)
3999
        av_exit(1);
4000
    ti = getutime() - ti;
4001
    if (do_benchmark) {
4002
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4003
    }
4004

    
4005
    return av_exit(0);
4006
}