Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ a75e1034

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 char *last_asked_format = NULL;
95
static AVFormatContext *input_files[MAX_FILES];
96
static int64_t input_files_ts_offset[MAX_FILES];
97
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
98
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
99
static int nb_input_files = 0;
100
static int nb_icodecs;
101

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

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

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

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

    
146
static int intra_only = 0;
147
static int audio_sample_rate = 44100;
148
static int64_t channel_layout = 0;
149
#define QSCALE_NONE -99999
150
static float audio_qscale = QSCALE_NONE;
151
static int audio_disable = 0;
152
static int audio_channels = 1;
153
static char  *audio_codec_name = NULL;
154
static int audio_codec_tag = 0;
155
static char *audio_language = NULL;
156

    
157
static int subtitle_disable = 0;
158
static char *subtitle_codec_name = NULL;
159
static char *subtitle_language = NULL;
160
static int subtitle_codec_tag = 0;
161

    
162
static float mux_preload= 0.5;
163
static float mux_max_delay= 0.7;
164

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

    
192
static int rate_emu = 0;
193

    
194
static int  video_channel = 0;
195
static char *video_standard;
196

    
197
static int audio_volume = 256;
198

    
199
static int exit_on_error = 0;
200
static int using_stdin = 0;
201
static int verbose = 1;
202
static int thread_count= 1;
203
static int q_pressed = 0;
204
static int64_t video_size = 0;
205
static int64_t audio_size = 0;
206
static int64_t extra_size = 0;
207
static int nb_frames_dup = 0;
208
static int nb_frames_drop = 0;
209
static int input_sync;
210
static uint64_t limit_filesize = 0;
211
static int force_fps = 0;
212

    
213
static int pgmyuv_compatibility_hack=0;
214
static float dts_delta_threshold = 10;
215

    
216
static unsigned int sws_flags = SWS_BICUBIC;
217

    
218
static int64_t timer_start;
219

    
220
static uint8_t *audio_buf;
221
static uint8_t *audio_out;
222
static uint8_t *audio_out2;
223

    
224
static short *samples;
225

    
226
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
227
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
228
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
229
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
230

    
231
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
232

    
233
struct AVInputStream;
234

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

    
255
    /* full frame size of first frame */
256
    int original_height;
257
    int original_width;
258

    
259
    /* cropping area sizes */
260
    int video_crop;
261
    int topBand;
262
    int bottomBand;
263
    int leftBand;
264
    int rightBand;
265

    
266
    /* cropping area of first frame */
267
    int original_topBand;
268
    int original_bottomBand;
269
    int original_leftBand;
270
    int original_rightBand;
271

    
272
    /* padding area sizes */
273
    int video_pad;
274
    int padtop;
275
    int padbottom;
276
    int padleft;
277
    int padright;
278

    
279
    /* audio only */
280
    int audio_resample;
281
    ReSampleContext *resample; /* for audio resampling */
282
    int reformat_pair;
283
    AVAudioConvert *reformat_ctx;
284
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
285
    FILE *logfile;
286
} AVOutputStream;
287

    
288
typedef struct AVInputStream {
289
    int file_index;
290
    int index;
291
    AVStream *st;
292
    int discard;             /* true if stream data should be discarded */
293
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
294
    int64_t sample_index;      /* current sample */
295

    
296
    int64_t       start;     /* time when read started */
297
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
298
                                is not defined */
299
    int64_t       pts;       /* current pts */
300
    int is_start;            /* is 1 at the start and after a discontinuity */
301
} AVInputStream;
302

    
303
typedef struct AVInputFile {
304
    int eof_reached;      /* true if eof reached */
305
    int ist_index;        /* index of first stream in ist_table */
306
    int buffer_size;      /* current total buffer size */
307
    int nb_streams;       /* nb streams we are aware of */
308
} AVInputFile;
309

    
310
#if HAVE_TERMIOS_H
311

    
312
/* init terminal so that we can grab keys */
313
static struct termios oldtty;
314
#endif
315

    
316
static void term_exit(void)
317
{
318
#if HAVE_TERMIOS_H
319
    tcsetattr (0, TCSANOW, &oldtty);
320
#endif
321
}
322

    
323
static volatile int received_sigterm = 0;
324

    
325
static void
326
sigterm_handler(int sig)
327
{
328
    received_sigterm = sig;
329
    term_exit();
330
}
331

    
332
static void term_init(void)
333
{
334
#if HAVE_TERMIOS_H
335
    struct termios tty;
336

    
337
    tcgetattr (0, &tty);
338
    oldtty = tty;
339

    
340
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
341
                          |INLCR|IGNCR|ICRNL|IXON);
342
    tty.c_oflag |= OPOST;
343
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
344
    tty.c_cflag &= ~(CSIZE|PARENB);
345
    tty.c_cflag |= CS8;
346
    tty.c_cc[VMIN] = 1;
347
    tty.c_cc[VTIME] = 0;
348

    
349
    tcsetattr (0, TCSANOW, &tty);
350
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
351
#endif
352

    
353
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
354
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
355
    /*
356
    register a function to be called at normal program termination
357
    */
358
    atexit(term_exit);
359
#if CONFIG_BEOS_NETSERVER
360
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
361
#endif
362
}
363

    
364
/* read a key without blocking */
365
static int read_key(void)
366
{
367
#if HAVE_TERMIOS_H
368
    int n = 1;
369
    unsigned char ch;
370
#if !CONFIG_BEOS_NETSERVER
371
    struct timeval tv;
372
    fd_set rfds;
373

    
374
    FD_ZERO(&rfds);
375
    FD_SET(0, &rfds);
376
    tv.tv_sec = 0;
377
    tv.tv_usec = 0;
378
    n = select(1, &rfds, NULL, NULL, &tv);
379
#endif
380
    if (n > 0) {
381
        n = read(0, &ch, 1);
382
        if (n == 1)
383
            return ch;
384

    
385
        return n;
386
    }
387
#elif HAVE_CONIO_H
388
    if(kbhit())
389
        return(getch());
390
#endif
391
    return -1;
392
}
393

    
394
static int decode_interrupt_cb(void)
395
{
396
    return q_pressed || (q_pressed = read_key() == 'q');
397
}
398

    
399
static int av_exit(int ret)
400
{
401
    int i;
402

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

    
427
    av_free(intra_matrix);
428
    av_free(inter_matrix);
429

    
430
    if (vstats_file)
431
        fclose(vstats_file);
432
    av_free(vstats_filename);
433

    
434
    av_free(opt_names);
435

    
436
    av_free(video_codec_name);
437
    av_free(audio_codec_name);
438
    av_free(subtitle_codec_name);
439

    
440
    av_free(video_standard);
441

    
442
#if CONFIG_POWERPC_PERF
443
    void powerpc_display_perf_report(void);
444
    powerpc_display_perf_report();
445
#endif /* CONFIG_POWERPC_PERF */
446

    
447
    for (i=0;i<CODEC_TYPE_NB;i++)
448
        av_free(avcodec_opts[i]);
449
    av_free(avformat_opts);
450
    av_free(sws_opts);
451
    av_free(audio_buf);
452
    av_free(audio_out);
453
    av_free(audio_out2);
454
    av_free(samples);
455

    
456
    if (received_sigterm) {
457
        fprintf(stderr,
458
            "Received signal %d: terminating.\n",
459
            (int) received_sigterm);
460
        exit (255);
461
    }
462

    
463
    exit(ret); /* not all OS-es handle main() return value */
464
    return ret;
465
}
466

    
467
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
468
{
469
    int i, err;
470
    AVFormatContext *ic;
471
    int nopts = 0;
472

    
473
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
474
    if (err < 0)
475
        return err;
476
    /* copy stream format */
477
    s->nb_streams = ic->nb_streams;
478
    for(i=0;i<ic->nb_streams;i++) {
479
        AVStream *st;
480

    
481
        // FIXME: a more elegant solution is needed
482
        st = av_mallocz(sizeof(AVStream));
483
        memcpy(st, ic->streams[i], sizeof(AVStream));
484
        st->codec = avcodec_alloc_context();
485
        if (!st->codec) {
486
            print_error(filename, AVERROR(ENOMEM));
487
            av_exit(1);
488
        }
489
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
490
        s->streams[i] = st;
491

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

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

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

    
506
    if (!nopts)
507
        s->timestamp = av_gettime();
508

    
509
    av_close_input_file(ic);
510
    return 0;
511
}
512

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

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

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

    
542
        bsfc= bsfc->next;
543
    }
544

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

    
552
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
553

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

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

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

    
576
    if (enc->channels != dec->channels)
577
        ost->audio_resample = 1;
578

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

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

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

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

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

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

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

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

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

    
697
        frame_bytes = enc->frame_size * osize * enc->channels;
698

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

    
703
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
704

    
705
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
706

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

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

    
729
        ost->sync_opts += size_out / (osize * enc->channels);
730

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

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

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

    
762
    dec = ist->st->codec;
763

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

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

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

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

    
789
    if (picture != picture2)
790
        *picture = *picture2;
791
    *bufp = buf;
792
}
793

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

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

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

    
816
    enc = ost->st->codec;
817

    
818
    if (!subtitle_out) {
819
        subtitle_out = av_malloc(subtitle_out_max_size);
820
    }
821

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

    
830
    for(i = 0; i < nb; i++) {
831
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
832
        // start_display_time is required to be 0
833
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
834
        sub->end_display_time -= sub->start_display_time;
835
        sub->start_display_time = 0;
836
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
837
                                                    subtitle_out_max_size, sub);
838
        if (subtitle_out_size < 0) {
839
            fprintf(stderr, "Subtitle encoding failed\n");
840
            av_exit(1);
841
        }
842

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

    
860
static int bit_buffer_size= 1024*256;
861
static uint8_t *bit_buffer= NULL;
862

    
863
static void do_video_out(AVFormatContext *s,
864
                         AVOutputStream *ost,
865
                         AVInputStream *ist,
866
                         AVFrame *in_picture,
867
                         int *frame_size)
868
{
869
    int nb_frames, i, ret;
870
    int64_t topBand, bottomBand, leftBand, rightBand;
871
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
872
    AVFrame picture_crop_temp, picture_pad_temp;
873
    AVCodecContext *enc, *dec;
874

    
875
    avcodec_get_frame_defaults(&picture_crop_temp);
876
    avcodec_get_frame_defaults(&picture_pad_temp);
877

    
878
    enc = ost->st->codec;
879
    dec = ist->st->codec;
880

    
881
    /* by default, we output a single frame */
882
    nb_frames = 1;
883

    
884
    *frame_size = 0;
885

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

    
912
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
913
    if (nb_frames <= 0)
914
        return;
915

    
916
    if (ost->video_crop) {
917
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
918
            fprintf(stderr, "error cropping picture\n");
919
            if (exit_on_error)
920
                av_exit(1);
921
            return;
922
        }
923
        formatted_picture = &picture_crop_temp;
924
    } else {
925
        formatted_picture = in_picture;
926
    }
927

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

    
944
    if (ost->video_resample) {
945
        padding_src = NULL;
946
        final_picture = &ost->pict_tmp;
947
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
948
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
949
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
950

    
951
            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));
952
            /* keep bands proportional to the frame size */
953
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
954
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
955
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
956
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
957

    
958
            /* sanity check to ensure no bad band sizes sneak in */
959
            assert(topBand    <= INT_MAX && topBand    >= 0);
960
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
961
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
962
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
963

    
964
            ost->topBand    = topBand;
965
            ost->bottomBand = bottomBand;
966
            ost->leftBand   = leftBand;
967
            ost->rightBand  = rightBand;
968

    
969
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
970
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
971
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
972

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

    
993
    if (ost->video_pad) {
994
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
995
                enc->height, enc->width, enc->pix_fmt,
996
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
997
    }
998

    
999
    /* duplicates frame if needed */
1000
    for(i=0;i<nb_frames;i++) {
1001
        AVPacket pkt;
1002
        av_init_packet(&pkt);
1003
        pkt.stream_index= ost->index;
1004

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

    
1016
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1017
            enc->coded_frame = old_frame;
1018
        } else {
1019
            AVFrame big_picture;
1020

    
1021
            big_picture= *final_picture;
1022
            /* better than nothing: use input picture interlaced
1023
               settings */
1024
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1025
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1026
                if(top_field_first == -1)
1027
                    big_picture.top_field_first = in_picture->top_field_first;
1028
                else
1029
                    big_picture.top_field_first = top_field_first;
1030
            }
1031

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

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

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

    
1079
static double psnr(double d){
1080
    return -10.0*log(d)/log(10.0);
1081
}
1082

    
1083
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1084
                           int frame_size)
1085
{
1086
    AVCodecContext *enc;
1087
    int frame_number;
1088
    double ti1, bitrate, avg_bitrate;
1089

    
1090
    /* this is executed just the first time do_video_stats is called */
1091
    if (!vstats_file) {
1092
        vstats_file = fopen(vstats_filename, "w");
1093
        if (!vstats_file) {
1094
            perror("fopen");
1095
            av_exit(1);
1096
        }
1097
    }
1098

    
1099
    enc = ost->st->codec;
1100
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1101
        frame_number = ost->frame_number;
1102
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1103
        if (enc->flags&CODEC_FLAG_PSNR)
1104
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1105

    
1106
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1107
        /* compute pts value */
1108
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1109
        if (ti1 < 0.01)
1110
            ti1 = 0.01;
1111

    
1112
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1113
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1114
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1115
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1116
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1117
    }
1118
}
1119

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

    
1134
    if (!is_last_report) {
1135
        int64_t cur_time;
1136
        /* display the report every 0.5 seconds */
1137
        cur_time = av_gettime();
1138
        if (last_time == -1) {
1139
            last_time = cur_time;
1140
            return;
1141
        }
1142
        if ((cur_time - last_time) < 500000)
1143
            return;
1144
        last_time = cur_time;
1145
    }
1146

    
1147

    
1148
    oc = output_files[0];
1149

    
1150
    total_size = url_fsize(oc->pb);
1151
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1152
        total_size= url_ftell(oc->pb);
1153

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

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

    
1214
    if (verbose || is_last_report) {
1215
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1216

    
1217
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1218
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1219
            (double)total_size / 1024, ti1, bitrate);
1220

    
1221
        if (verbose > 1)
1222
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1223
                  nb_frames_dup, nb_frames_drop);
1224

    
1225
        if (verbose >= 0)
1226
            fprintf(stderr, "%s    \r", buf);
1227

    
1228
        fflush(stderr);
1229
    }
1230

    
1231
    if (is_last_report && verbose >= 0){
1232
        int64_t raw= audio_size + video_size + extra_size;
1233
        fprintf(stderr, "\n");
1234
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1235
                video_size/1024.0,
1236
                audio_size/1024.0,
1237
                extra_size/1024.0,
1238
                100.0*(total_size - raw)/raw
1239
        );
1240
    }
1241
}
1242

    
1243
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1244
static int output_packet(AVInputStream *ist, int ist_index,
1245
                         AVOutputStream **ost_table, int nb_ostreams,
1246
                         const AVPacket *pkt)
1247
{
1248
    AVFormatContext *os;
1249
    AVOutputStream *ost;
1250
    int ret, i;
1251
    uint8_t *data_buf;
1252
    int data_size, got_picture;
1253
    AVFrame picture;
1254
    void *buffer_to_free;
1255
    static unsigned int samples_size= 0;
1256
    AVSubtitle subtitle, *subtitle_to_free;
1257
    int got_subtitle;
1258
    AVPacket avpkt;
1259
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1260

    
1261
    if(ist->next_pts == AV_NOPTS_VALUE)
1262
        ist->next_pts= ist->pts;
1263

    
1264
    if (pkt == NULL) {
1265
        /* EOF handling */
1266
        av_init_packet(&avpkt);
1267
        avpkt.data = NULL;
1268
        avpkt.size = 0;
1269
        goto handle_eof;
1270
    } else {
1271
        avpkt = *pkt;
1272
    }
1273

    
1274
    if(pkt->dts != AV_NOPTS_VALUE)
1275
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1276

    
1277
    //while we have more to decode or while the decoder did output something on EOF
1278
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1279
    handle_eof:
1280
        ist->pts= ist->next_pts;
1281

    
1282
        if(avpkt.size && avpkt.size != pkt->size &&
1283
           !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0)
1284
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1285

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

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

    
1374
        buffer_to_free = NULL;
1375
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1376
            pre_process_video_frame(ist, (AVPicture *)&picture,
1377
                                    &buffer_to_free);
1378
        }
1379

    
1380
        // preprocess audio (volume)
1381
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1382
            if (audio_volume != 256) {
1383
                short *volp;
1384
                volp = samples;
1385
                for(i=0;i<(data_size / sizeof(short));i++) {
1386
                    int v = ((*volp) * audio_volume + 128) >> 8;
1387
                    if (v < -32768) v = -32768;
1388
                    if (v >  32767) v = 32767;
1389
                    *volp++ = v;
1390
                }
1391
            }
1392
        }
1393

    
1394
        /* frame rate emulation */
1395
        if (rate_emu) {
1396
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1397
            int64_t now = av_gettime() - ist->start;
1398
            if (pts > now)
1399
                usleep(pts - now);
1400
        }
1401

    
1402
        /* if output time reached then transcode raw format,
1403
           encode packets and output them */
1404
        if (start_time == 0 || ist->pts >= start_time)
1405
            for(i=0;i<nb_ostreams;i++) {
1406
                int frame_size;
1407

    
1408
                ost = ost_table[i];
1409
                if (ost->source_index == ist_index) {
1410
                    os = output_files[ost->file_index];
1411

    
1412
                    /* set the input output pts pairs */
1413
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1414

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

    
1437
                        av_init_packet(&opkt);
1438

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

    
1442
                        /* no reencoding needed : output the packet directly */
1443
                        /* force the input stream PTS */
1444

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1588
    return 0;
1589
 fail_decode:
1590
    return -1;
1591
}
1592

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

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

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

    
1625
    return -1;
1626
}
1627

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1815
        codec = ost->st->codec;
1816
        icodec = ist->st->codec;
1817

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

    
1822
        ost->st->disposition = ist->st->disposition;
1823
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1824
        codec->chroma_sample_location = icodec->chroma_sample_location;
1825

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

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

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

    
1940
                    ost->original_height = icodec->height;
1941
                    ost->original_width  = icodec->width;
1942

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

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

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

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

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

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

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

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

    
2090
        out_file = output_files[out_file_index];
2091
        in_file = input_files[in_file_index];
2092

    
2093

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

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

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

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

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

    
2144
    if (want_sdp) {
2145
        print_sdp(output_files, nb_output_files);
2146
    }
2147

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

    
2154
    timer_start = av_gettime();
2155

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

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

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

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

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

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

    
2240
        no_packet_count=0;
2241
        memset(no_packet, 0, sizeof(no_packet));
2242

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

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

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

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

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

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

    
2294
    discard_packet:
2295
        av_free_packet(&pkt);
2296

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

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

    
2309
    term_exit();
2310

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

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

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

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

    
2337
    /* finished ! */
2338
    ret = 0;
2339

    
2340
 fail:
2341
    av_freep(&bit_buffer);
2342
    av_free(file_table);
2343

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

    
2376
static void opt_format(const char *arg)
2377
{
2378
    /* compatibility stuff for pgmyuv */
2379
    if (!strcmp(arg, "pgmyuv")) {
2380
        pgmyuv_compatibility_hack=1;
2381
//        opt_image_format(arg);
2382
        arg = "image2";
2383
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2384
    }
2385

    
2386
    last_asked_format = arg;
2387
}
2388

    
2389
static void opt_video_rc_override_string(const char *arg)
2390
{
2391
    video_rc_override_string = arg;
2392
}
2393

    
2394
static int opt_me_threshold(const char *opt, const char *arg)
2395
{
2396
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2397
    return 0;
2398
}
2399

    
2400
static int opt_verbose(const char *opt, const char *arg)
2401
{
2402
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2403
    return 0;
2404
}
2405

    
2406
static int opt_frame_rate(const char *opt, const char *arg)
2407
{
2408
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2409
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2410
        av_exit(1);
2411
    }
2412
    return 0;
2413
}
2414

    
2415
static int opt_bitrate(const char *opt, const char *arg)
2416
{
2417
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2418

    
2419
    opt_default(opt, arg);
2420

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

    
2424
    return 0;
2425
}
2426

    
2427
static void opt_frame_crop_top(const char *arg)
2428
{
2429
    frame_topBand = atoi(arg);
2430
    if (frame_topBand < 0) {
2431
        fprintf(stderr, "Incorrect top crop size\n");
2432
        av_exit(1);
2433
    }
2434
    if ((frame_topBand) >= frame_height){
2435
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2436
        av_exit(1);
2437
    }
2438
    frame_height -= frame_topBand;
2439
}
2440

    
2441
static void opt_frame_crop_bottom(const char *arg)
2442
{
2443
    frame_bottomBand = atoi(arg);
2444
    if (frame_bottomBand < 0) {
2445
        fprintf(stderr, "Incorrect bottom crop size\n");
2446
        av_exit(1);
2447
    }
2448
    if ((frame_bottomBand) >= frame_height){
2449
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2450
        av_exit(1);
2451
    }
2452
    frame_height -= frame_bottomBand;
2453
}
2454

    
2455
static void opt_frame_crop_left(const char *arg)
2456
{
2457
    frame_leftBand = atoi(arg);
2458
    if (frame_leftBand < 0) {
2459
        fprintf(stderr, "Incorrect left crop size\n");
2460
        av_exit(1);
2461
    }
2462
    if ((frame_leftBand) >= frame_width){
2463
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2464
        av_exit(1);
2465
    }
2466
    frame_width -= frame_leftBand;
2467
}
2468

    
2469
static void opt_frame_crop_right(const char *arg)
2470
{
2471
    frame_rightBand = atoi(arg);
2472
    if (frame_rightBand < 0) {
2473
        fprintf(stderr, "Incorrect right crop size\n");
2474
        av_exit(1);
2475
    }
2476
    if ((frame_rightBand) >= frame_width){
2477
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2478
        av_exit(1);
2479
    }
2480
    frame_width -= frame_rightBand;
2481
}
2482

    
2483
static void opt_frame_size(const char *arg)
2484
{
2485
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2486
        fprintf(stderr, "Incorrect frame size\n");
2487
        av_exit(1);
2488
    }
2489
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2490
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2491
        av_exit(1);
2492
    }
2493
}
2494

    
2495
static void opt_pad_color(const char *arg) {
2496
    /* Input is expected to be six hex digits similar to
2497
       how colors are expressed in html tags (but without the #) */
2498
    int rgb = strtol(arg, NULL, 16);
2499
    int r,g,b;
2500

    
2501
    r = (rgb >> 16);
2502
    g = ((rgb >> 8) & 255);
2503
    b = (rgb & 255);
2504

    
2505
    padcolor[0] = RGB_TO_Y(r,g,b);
2506
    padcolor[1] = RGB_TO_U(r,g,b,0);
2507
    padcolor[2] = RGB_TO_V(r,g,b,0);
2508
}
2509

    
2510
static void opt_frame_pad_top(const char *arg)
2511
{
2512
    frame_padtop = atoi(arg);
2513
    if (frame_padtop < 0) {
2514
        fprintf(stderr, "Incorrect top pad size\n");
2515
        av_exit(1);
2516
    }
2517
}
2518

    
2519
static void opt_frame_pad_bottom(const char *arg)
2520
{
2521
    frame_padbottom = atoi(arg);
2522
    if (frame_padbottom < 0) {
2523
        fprintf(stderr, "Incorrect bottom pad size\n");
2524
        av_exit(1);
2525
    }
2526
}
2527

    
2528

    
2529
static void opt_frame_pad_left(const char *arg)
2530
{
2531
    frame_padleft = atoi(arg);
2532
    if (frame_padleft < 0) {
2533
        fprintf(stderr, "Incorrect left pad size\n");
2534
        av_exit(1);
2535
    }
2536
}
2537

    
2538

    
2539
static void opt_frame_pad_right(const char *arg)
2540
{
2541
    frame_padright = atoi(arg);
2542
    if (frame_padright < 0) {
2543
        fprintf(stderr, "Incorrect right pad size\n");
2544
        av_exit(1);
2545
    }
2546
}
2547

    
2548
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2549
{
2550
    int i;
2551
    char fmt_str[128];
2552
    for (i=-1; i < nb_fmts; i++) {
2553
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2554
        fprintf(stdout, "%s\n", fmt_str);
2555
    }
2556
}
2557

    
2558
static void opt_frame_pix_fmt(const char *arg)
2559
{
2560
    if (strcmp(arg, "list")) {
2561
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2562
        if (frame_pix_fmt == PIX_FMT_NONE) {
2563
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2564
            av_exit(1);
2565
        }
2566
    } else {
2567
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2568
        av_exit(0);
2569
    }
2570
}
2571

    
2572
static void opt_frame_aspect_ratio(const char *arg)
2573
{
2574
    int x = 0, y = 0;
2575
    double ar = 0;
2576
    const char *p;
2577
    char *end;
2578

    
2579
    p = strchr(arg, ':');
2580
    if (p) {
2581
        x = strtol(arg, &end, 10);
2582
        if (end == p)
2583
            y = strtol(end+1, &end, 10);
2584
        if (x > 0 && y > 0)
2585
            ar = (double)x / (double)y;
2586
    } else
2587
        ar = strtod(arg, NULL);
2588

    
2589
    if (!ar) {
2590
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2591
        av_exit(1);
2592
    }
2593
    frame_aspect_ratio = ar;
2594
}
2595

    
2596
static int opt_metadata(const char *opt, const char *arg)
2597
{
2598
    char *mid= strchr(arg, '=');
2599

    
2600
    if(!mid){
2601
        fprintf(stderr, "Missing =\n");
2602
        av_exit(1);
2603
    }
2604
    *mid++= 0;
2605

    
2606
    metadata_count++;
2607
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2608
    metadata[metadata_count-1].key  = av_strdup(arg);
2609
    metadata[metadata_count-1].value= av_strdup(mid);
2610

    
2611
    return 0;
2612
}
2613

    
2614
static void opt_qscale(const char *arg)
2615
{
2616
    video_qscale = atof(arg);
2617
    if (video_qscale <= 0 ||
2618
        video_qscale > 255) {
2619
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2620
        av_exit(1);
2621
    }
2622
}
2623

    
2624
static void opt_top_field_first(const char *arg)
2625
{
2626
    top_field_first= atoi(arg);
2627
}
2628

    
2629
static int opt_thread_count(const char *opt, const char *arg)
2630
{
2631
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2632
#if !HAVE_THREADS
2633
    if (verbose >= 0)
2634
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2635
#endif
2636
    return 0;
2637
}
2638

    
2639
static void opt_audio_sample_fmt(const char *arg)
2640
{
2641
    if (strcmp(arg, "list"))
2642
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2643
    else {
2644
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2645
        av_exit(0);
2646
    }
2647
}
2648

    
2649
static int opt_audio_rate(const char *opt, const char *arg)
2650
{
2651
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2652
    return 0;
2653
}
2654

    
2655
static int opt_audio_channels(const char *opt, const char *arg)
2656
{
2657
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2658
    return 0;
2659
}
2660

    
2661
static void opt_video_channel(const char *arg)
2662
{
2663
    video_channel = strtol(arg, NULL, 0);
2664
}
2665

    
2666
static void opt_video_standard(const char *arg)
2667
{
2668
    video_standard = av_strdup(arg);
2669
}
2670

    
2671
static void opt_codec(int *pstream_copy, char **pcodec_name,
2672
                      int codec_type, const char *arg)
2673
{
2674
    av_freep(pcodec_name);
2675
    if (!strcmp(arg, "copy")) {
2676
        *pstream_copy = 1;
2677
    } else {
2678
        *pcodec_name = av_strdup(arg);
2679
    }
2680
}
2681

    
2682
static void opt_audio_codec(const char *arg)
2683
{
2684
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2685
}
2686

    
2687
static void opt_audio_tag(const char *arg)
2688
{
2689
    char *tail;
2690
    audio_codec_tag= strtol(arg, &tail, 0);
2691

    
2692
    if(!tail || *tail)
2693
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2694
}
2695

    
2696
static void opt_video_tag(const char *arg)
2697
{
2698
    char *tail;
2699
    video_codec_tag= strtol(arg, &tail, 0);
2700

    
2701
    if(!tail || *tail)
2702
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2703
}
2704

    
2705
static void opt_video_codec(const char *arg)
2706
{
2707
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2708
}
2709

    
2710
static void opt_subtitle_codec(const char *arg)
2711
{
2712
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2713
}
2714

    
2715
static void opt_subtitle_tag(const char *arg)
2716
{
2717
    char *tail;
2718
    subtitle_codec_tag= strtol(arg, &tail, 0);
2719

    
2720
    if(!tail || *tail)
2721
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2722
}
2723

    
2724
static void opt_map(const char *arg)
2725
{
2726
    AVStreamMap *m;
2727
    char *p;
2728

    
2729
    m = &stream_maps[nb_stream_maps++];
2730

    
2731
    m->file_index = strtol(arg, &p, 0);
2732
    if (*p)
2733
        p++;
2734

    
2735
    m->stream_index = strtol(p, &p, 0);
2736
    if (*p) {
2737
        p++;
2738
        m->sync_file_index = strtol(p, &p, 0);
2739
        if (*p)
2740
            p++;
2741
        m->sync_stream_index = strtol(p, &p, 0);
2742
    } else {
2743
        m->sync_file_index = m->file_index;
2744
        m->sync_stream_index = m->stream_index;
2745
    }
2746
}
2747

    
2748
static void opt_map_meta_data(const char *arg)
2749
{
2750
    AVMetaDataMap *m;
2751
    char *p;
2752

    
2753
    m = &meta_data_maps[nb_meta_data_maps++];
2754

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

    
2759
    m->in_file = strtol(p, &p, 0);
2760
}
2761

    
2762
static void opt_input_ts_scale(const char *arg)
2763
{
2764
    unsigned int stream;
2765
    double scale;
2766
    char *p;
2767

    
2768
    stream = strtol(arg, &p, 0);
2769
    if (*p)
2770
        p++;
2771
    scale= strtod(p, &p);
2772

    
2773
    if(stream >= MAX_STREAMS)
2774
        av_exit(1);
2775

    
2776
    input_files_ts_scale[nb_input_files][stream]= scale;
2777
}
2778

    
2779
static int opt_recording_time(const char *opt, const char *arg)
2780
{
2781
    recording_time = parse_time_or_die(opt, arg, 1);
2782
    return 0;
2783
}
2784

    
2785
static int opt_start_time(const char *opt, const char *arg)
2786
{
2787
    start_time = parse_time_or_die(opt, arg, 1);
2788
    return 0;
2789
}
2790

    
2791
static int opt_rec_timestamp(const char *opt, const char *arg)
2792
{
2793
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2794
    return 0;
2795
}
2796

    
2797
static int opt_input_ts_offset(const char *opt, const char *arg)
2798
{
2799
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2800
    return 0;
2801
}
2802

    
2803
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2804
{
2805
    const char *codec_string = encoder ? "encoder" : "decoder";
2806
    AVCodec *codec;
2807

    
2808
    if(!name)
2809
        return CODEC_ID_NONE;
2810
    codec = encoder ?
2811
        avcodec_find_encoder_by_name(name) :
2812
        avcodec_find_decoder_by_name(name);
2813
    if(!codec) {
2814
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2815
        av_exit(1);
2816
    }
2817
    if(codec->type != type) {
2818
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2819
        av_exit(1);
2820
    }
2821
    return codec->id;
2822
}
2823

    
2824
static void opt_input_file(const char *filename)
2825
{
2826
    AVFormatContext *ic;
2827
    AVFormatParameters params, *ap = &params;
2828
    AVInputFormat *file_iformat = NULL;
2829
    int err, i, ret, rfps, rfps_base;
2830
    int64_t timestamp;
2831

    
2832
    if (last_asked_format) {
2833
        file_iformat = av_find_input_format(last_asked_format);
2834
        last_asked_format = NULL;
2835
    }
2836

    
2837
    if (!strcmp(filename, "-"))
2838
        filename = "pipe:";
2839

    
2840
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2841
                    !strcmp(filename, "/dev/stdin");
2842

    
2843
    /* get default parameters from command line */
2844
    ic = avformat_alloc_context();
2845
    if (!ic) {
2846
        print_error(filename, AVERROR(ENOMEM));
2847
        av_exit(1);
2848
    }
2849

    
2850
    memset(ap, 0, sizeof(*ap));
2851
    ap->prealloced_context = 1;
2852
    ap->sample_rate = audio_sample_rate;
2853
    ap->channels = audio_channels;
2854
    ap->time_base.den = frame_rate.num;
2855
    ap->time_base.num = frame_rate.den;
2856
    ap->width = frame_width + frame_padleft + frame_padright;
2857
    ap->height = frame_height + frame_padtop + frame_padbottom;
2858
    ap->pix_fmt = frame_pix_fmt;
2859
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2860
    ap->channel = video_channel;
2861
    ap->standard = video_standard;
2862
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2863
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2864
    if(pgmyuv_compatibility_hack)
2865
        ap->video_codec_id= CODEC_ID_PGMYUV;
2866

    
2867
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2868

    
2869
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2870
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2871
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2872
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2873

    
2874
    /* open the input file with generic libav function */
2875
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2876
    if (err < 0) {
2877
        print_error(filename, err);
2878
        av_exit(1);
2879
    }
2880
    if(opt_programid) {
2881
        int i;
2882
        for(i=0; i<ic->nb_programs; i++)
2883
            if(ic->programs[i]->id != opt_programid)
2884
                ic->programs[i]->discard = AVDISCARD_ALL;
2885
    }
2886

    
2887
    ic->loop_input = loop_input;
2888

    
2889
    /* If not enough info to get the stream parameters, we decode the
2890
       first frames to get it. (used in mpeg case for example) */
2891
    ret = av_find_stream_info(ic);
2892
    if (ret < 0 && verbose >= 0) {
2893
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2894
        av_exit(1);
2895
    }
2896

    
2897
    timestamp = start_time;
2898
    /* add the stream start time */
2899
    if (ic->start_time != AV_NOPTS_VALUE)
2900
        timestamp += ic->start_time;
2901

    
2902
    /* if seeking requested, we execute it */
2903
    if (start_time != 0) {
2904
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2905
        if (ret < 0) {
2906
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2907
                    filename, (double)timestamp / AV_TIME_BASE);
2908
        }
2909
        /* reset seek info */
2910
        start_time = 0;
2911
    }
2912

    
2913
    /* update the current parameters so that they match the one of the input stream */
2914
    for(i=0;i<ic->nb_streams;i++) {
2915
        AVCodecContext *enc = ic->streams[i]->codec;
2916
        if(thread_count>1)
2917
            avcodec_thread_init(enc, thread_count);
2918
        enc->thread_count= thread_count;
2919
        switch(enc->codec_type) {
2920
        case CODEC_TYPE_AUDIO:
2921
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2922
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2923
            channel_layout = enc->channel_layout;
2924
            audio_channels = enc->channels;
2925
            audio_sample_rate = enc->sample_rate;
2926
            audio_sample_fmt = enc->sample_fmt;
2927
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2928
            if(audio_disable)
2929
                ic->streams[i]->discard= AVDISCARD_ALL;
2930
            break;
2931
        case CODEC_TYPE_VIDEO:
2932
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2933
            frame_height = enc->height;
2934
            frame_width = enc->width;
2935
            if(ic->streams[i]->sample_aspect_ratio.num)
2936
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2937
            else
2938
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2939
            frame_aspect_ratio *= (float) enc->width / enc->height;
2940
            frame_pix_fmt = enc->pix_fmt;
2941
            rfps      = ic->streams[i]->r_frame_rate.num;
2942
            rfps_base = ic->streams[i]->r_frame_rate.den;
2943
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2944
            if(me_threshold)
2945
                enc->debug |= FF_DEBUG_MV;
2946

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

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

    
2953
                    (float)rfps / rfps_base, rfps, rfps_base);
2954
            }
2955
            /* update the current frame rate to match the stream frame rate */
2956
            frame_rate.num = rfps;
2957
            frame_rate.den = rfps_base;
2958

    
2959
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2960
            if(video_disable)
2961
                ic->streams[i]->discard= AVDISCARD_ALL;
2962
            else if(video_discard)
2963
                ic->streams[i]->discard= video_discard;
2964
            break;
2965
        case CODEC_TYPE_DATA:
2966
            break;
2967
        case CODEC_TYPE_SUBTITLE:
2968
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2969
            if(subtitle_disable)
2970
                ic->streams[i]->discard = AVDISCARD_ALL;
2971
            break;
2972
        case CODEC_TYPE_ATTACHMENT:
2973
        case CODEC_TYPE_UNKNOWN:
2974
            nb_icodecs++;
2975
            break;
2976
        default:
2977
            abort();
2978
        }
2979
    }
2980

    
2981
    input_files[nb_input_files] = ic;
2982
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2983
    /* dump the file content */
2984
    if (verbose >= 0)
2985
        dump_format(ic, nb_input_files, filename, 0);
2986

    
2987
    nb_input_files++;
2988

    
2989
    video_channel = 0;
2990

    
2991
    av_freep(&video_codec_name);
2992
    av_freep(&audio_codec_name);
2993
    av_freep(&subtitle_codec_name);
2994
}
2995

    
2996
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2997
                                         int *has_subtitle_ptr)
2998
{
2999
    int has_video, has_audio, has_subtitle, i, j;
3000
    AVFormatContext *ic;
3001

    
3002
    has_video = 0;
3003
    has_audio = 0;
3004
    has_subtitle = 0;
3005
    for(j=0;j<nb_input_files;j++) {
3006
        ic = input_files[j];
3007
        for(i=0;i<ic->nb_streams;i++) {
3008
            AVCodecContext *enc = ic->streams[i]->codec;
3009
            switch(enc->codec_type) {
3010
            case CODEC_TYPE_AUDIO:
3011
                has_audio = 1;
3012
                break;
3013
            case CODEC_TYPE_VIDEO:
3014
                has_video = 1;
3015
                break;
3016
            case CODEC_TYPE_SUBTITLE:
3017
                has_subtitle = 1;
3018
                break;
3019
            case CODEC_TYPE_DATA:
3020
            case CODEC_TYPE_ATTACHMENT:
3021
            case CODEC_TYPE_UNKNOWN:
3022
                break;
3023
            default:
3024
                abort();
3025
            }
3026
        }
3027
    }
3028
    *has_video_ptr = has_video;
3029
    *has_audio_ptr = has_audio;
3030
    *has_subtitle_ptr = has_subtitle;
3031
}
3032

    
3033
static void new_video_stream(AVFormatContext *oc)
3034
{
3035
    AVStream *st;
3036
    AVCodecContext *video_enc;
3037
    enum CodecID codec_id;
3038

    
3039
    st = av_new_stream(oc, oc->nb_streams);
3040
    if (!st) {
3041
        fprintf(stderr, "Could not alloc stream\n");
3042
        av_exit(1);
3043
    }
3044
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3045
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3046
    video_bitstream_filters= NULL;
3047

    
3048
    if(thread_count>1)
3049
        avcodec_thread_init(st->codec, thread_count);
3050

    
3051
    video_enc = st->codec;
3052

    
3053
    if(video_codec_tag)
3054
        video_enc->codec_tag= video_codec_tag;
3055

    
3056
    if(   (video_global_header&1)
3057
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3058
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3059
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3060
    }
3061
    if(video_global_header&2){
3062
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3063
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3064
    }
3065

    
3066
    if (video_stream_copy) {
3067
        st->stream_copy = 1;
3068
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3069
        video_enc->sample_aspect_ratio =
3070
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3071
    } else {
3072
        const char *p;
3073
        int i;
3074
        AVCodec *codec;
3075
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3076

    
3077
        if (video_codec_name) {
3078
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3079
            codec = avcodec_find_encoder_by_name(video_codec_name);
3080
            output_codecs[nb_ocodecs] = codec;
3081
        } else {
3082
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3083
            codec = avcodec_find_encoder(codec_id);
3084
        }
3085

    
3086
        video_enc->codec_id = codec_id;
3087

    
3088
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3089

    
3090
        if (codec && codec->supported_framerates && !force_fps)
3091
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3092
        video_enc->time_base.den = fps.num;
3093
        video_enc->time_base.num = fps.den;
3094

    
3095
        video_enc->width = frame_width + frame_padright + frame_padleft;
3096
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3097
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3098
        video_enc->pix_fmt = frame_pix_fmt;
3099
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3100

    
3101
        if(codec && codec->pix_fmts){
3102
            const enum PixelFormat *p= codec->pix_fmts;
3103
            for(; *p!=-1; p++){
3104
                if(*p == video_enc->pix_fmt)
3105
                    break;
3106
            }
3107
            if(*p == -1)
3108
                video_enc->pix_fmt = codec->pix_fmts[0];
3109
        }
3110

    
3111
        if (intra_only)
3112
            video_enc->gop_size = 0;
3113
        if (video_qscale || same_quality) {
3114
            video_enc->flags |= CODEC_FLAG_QSCALE;
3115
            video_enc->global_quality=
3116
                st->quality = FF_QP2LAMBDA * video_qscale;
3117
        }
3118

    
3119
        if(intra_matrix)
3120
            video_enc->intra_matrix = intra_matrix;
3121
        if(inter_matrix)
3122
            video_enc->inter_matrix = inter_matrix;
3123

    
3124
        video_enc->thread_count = thread_count;
3125
        p= video_rc_override_string;
3126
        for(i=0; p; i++){
3127
            int start, end, q;
3128
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3129
            if(e!=3){
3130
                fprintf(stderr, "error parsing rc_override\n");
3131
                av_exit(1);
3132
            }
3133
            video_enc->rc_override=
3134
                av_realloc(video_enc->rc_override,
3135
                           sizeof(RcOverride)*(i+1));
3136
            video_enc->rc_override[i].start_frame= start;
3137
            video_enc->rc_override[i].end_frame  = end;
3138
            if(q>0){
3139
                video_enc->rc_override[i].qscale= q;
3140
                video_enc->rc_override[i].quality_factor= 1.0;
3141
            }
3142
            else{
3143
                video_enc->rc_override[i].qscale= 0;
3144
                video_enc->rc_override[i].quality_factor= -q/100.0;
3145
            }
3146
            p= strchr(p, '/');
3147
            if(p) p++;
3148
        }
3149
        video_enc->rc_override_count=i;
3150
        if (!video_enc->rc_initial_buffer_occupancy)
3151
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3152
        video_enc->me_threshold= me_threshold;
3153
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3154

    
3155
        if (do_psnr)
3156
            video_enc->flags|= CODEC_FLAG_PSNR;
3157

    
3158
        /* two pass mode */
3159
        if (do_pass) {
3160
            if (do_pass == 1) {
3161
                video_enc->flags |= CODEC_FLAG_PASS1;
3162
            } else {
3163
                video_enc->flags |= CODEC_FLAG_PASS2;
3164
            }
3165
        }
3166
    }
3167
    nb_ocodecs++;
3168

    
3169
    /* reset some key parameters */
3170
    video_disable = 0;
3171
    av_freep(&video_codec_name);
3172
    video_stream_copy = 0;
3173
}
3174

    
3175
static void new_audio_stream(AVFormatContext *oc)
3176
{
3177
    AVStream *st;
3178
    AVCodecContext *audio_enc;
3179
    enum CodecID codec_id;
3180

    
3181
    st = av_new_stream(oc, oc->nb_streams);
3182
    if (!st) {
3183
        fprintf(stderr, "Could not alloc stream\n");
3184
        av_exit(1);
3185
    }
3186
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3187

    
3188
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3189
    audio_bitstream_filters= NULL;
3190

    
3191
    if(thread_count>1)
3192
        avcodec_thread_init(st->codec, thread_count);
3193

    
3194
    audio_enc = st->codec;
3195
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3196

    
3197
    if(audio_codec_tag)
3198
        audio_enc->codec_tag= audio_codec_tag;
3199

    
3200
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3201
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3202
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3203
    }
3204
    if (audio_stream_copy) {
3205
        st->stream_copy = 1;
3206
        audio_enc->channels = audio_channels;
3207
    } else {
3208
        AVCodec *codec;
3209

    
3210
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3211

    
3212
        if (audio_codec_name) {
3213
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3214
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3215
            output_codecs[nb_ocodecs] = codec;
3216
        } else {
3217
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3218
            codec = avcodec_find_encoder(codec_id);
3219
        }
3220
        audio_enc->codec_id = codec_id;
3221

    
3222
        if (audio_qscale > QSCALE_NONE) {
3223
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3224
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3225
        }
3226
        audio_enc->thread_count = thread_count;
3227
        audio_enc->channels = audio_channels;
3228
        audio_enc->sample_fmt = audio_sample_fmt;
3229
        audio_enc->channel_layout = channel_layout;
3230
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3231
            audio_enc->channel_layout = 0;
3232

    
3233
        if(codec && codec->sample_fmts){
3234
            const enum SampleFormat *p= codec->sample_fmts;
3235
            for(; *p!=-1; p++){
3236
                if(*p == audio_enc->sample_fmt)
3237
                    break;
3238
            }
3239
            if(*p == -1)
3240
                audio_enc->sample_fmt = codec->sample_fmts[0];
3241
        }
3242
    }
3243
    nb_ocodecs++;
3244
    audio_enc->sample_rate = audio_sample_rate;
3245
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3246
    if (audio_language) {
3247
        av_metadata_set(&st->metadata, "language", audio_language);
3248
        av_free(audio_language);
3249
        audio_language = NULL;
3250
    }
3251

    
3252
    /* reset some key parameters */
3253
    audio_disable = 0;
3254
    av_freep(&audio_codec_name);
3255
    audio_stream_copy = 0;
3256
}
3257

    
3258
static void new_subtitle_stream(AVFormatContext *oc)
3259
{
3260
    AVStream *st;
3261
    AVCodecContext *subtitle_enc;
3262

    
3263
    st = av_new_stream(oc, oc->nb_streams);
3264
    if (!st) {
3265
        fprintf(stderr, "Could not alloc stream\n");
3266
        av_exit(1);
3267
    }
3268
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3269

    
3270
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3271
    subtitle_bitstream_filters= NULL;
3272

    
3273
    subtitle_enc = st->codec;
3274
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3275

    
3276
    if(subtitle_codec_tag)
3277
        subtitle_enc->codec_tag= subtitle_codec_tag;
3278

    
3279
    if (subtitle_stream_copy) {
3280
        st->stream_copy = 1;
3281
    } else {
3282
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3283
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3284
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3285
    }
3286
    nb_ocodecs++;
3287

    
3288
    if (subtitle_language) {
3289
        av_metadata_set(&st->metadata, "language", subtitle_language);
3290
        av_free(subtitle_language);
3291
        subtitle_language = NULL;
3292
    }
3293

    
3294
    subtitle_disable = 0;
3295
    av_freep(&subtitle_codec_name);
3296
    subtitle_stream_copy = 0;
3297
}
3298

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

    
3310
static void opt_new_video_stream(void)
3311
{
3312
    AVFormatContext *oc;
3313
    if (nb_output_files <= 0) {
3314
        fprintf(stderr, "At least one output file must be specified\n");
3315
        av_exit(1);
3316
    }
3317
    oc = output_files[nb_output_files - 1];
3318
    new_video_stream(oc);
3319
}
3320

    
3321
static void opt_new_subtitle_stream(void)
3322
{
3323
    AVFormatContext *oc;
3324
    if (nb_output_files <= 0) {
3325
        fprintf(stderr, "At least one output file must be specified\n");
3326
        av_exit(1);
3327
    }
3328
    oc = output_files[nb_output_files - 1];
3329
    new_subtitle_stream(oc);
3330
}
3331

    
3332
static void opt_output_file(const char *filename)
3333
{
3334
    AVFormatContext *oc;
3335
    int use_video, use_audio, use_subtitle;
3336
    int input_has_video, input_has_audio, input_has_subtitle;
3337
    AVFormatParameters params, *ap = &params;
3338
    AVOutputFormat *file_oformat;
3339

    
3340
    if (!strcmp(filename, "-"))
3341
        filename = "pipe:";
3342

    
3343
    oc = avformat_alloc_context();
3344
    if (!oc) {
3345
        print_error(filename, AVERROR(ENOMEM));
3346
        av_exit(1);
3347
    }
3348

    
3349
    if (last_asked_format) {
3350
        file_oformat = guess_format(last_asked_format, NULL, NULL);
3351
        if (!file_oformat) {
3352
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3353
            av_exit(1);
3354
        }
3355
        last_asked_format = NULL;
3356
    } else {
3357
        file_oformat = guess_format(NULL, filename, NULL);
3358
        if (!file_oformat) {
3359
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3360
                    filename);
3361
            av_exit(1);
3362
        }
3363
    }
3364

    
3365
    oc->oformat = file_oformat;
3366
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3367

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

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

    
3395
        /* manual disable */
3396
        if (audio_disable) {
3397
            use_audio = 0;
3398
        }
3399
        if (video_disable) {
3400
            use_video = 0;
3401
        }
3402
        if (subtitle_disable) {
3403
            use_subtitle = 0;
3404
        }
3405

    
3406
        if (use_video) {
3407
            new_video_stream(oc);
3408
        }
3409

    
3410
        if (use_audio) {
3411
            new_audio_stream(oc);
3412
        }
3413

    
3414
        if (use_subtitle) {
3415
            new_subtitle_stream(oc);
3416
        }
3417

    
3418
        oc->timestamp = rec_timestamp;
3419

    
3420
        for(; metadata_count>0; metadata_count--){
3421
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3422
                                           metadata[metadata_count-1].value);
3423
        }
3424
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3425
    }
3426

    
3427
    output_files[nb_output_files++] = oc;
3428

    
3429
    /* check filename in case of an image number is expected */
3430
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3431
        if (!av_filename_number_test(oc->filename)) {
3432
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3433
            av_exit(1);
3434
        }
3435
    }
3436

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

    
3459
        /* open the file */
3460
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3461
            fprintf(stderr, "Could not open '%s'\n", filename);
3462
            av_exit(1);
3463
        }
3464
    }
3465

    
3466
    memset(ap, 0, sizeof(*ap));
3467
    if (av_set_parameters(oc, ap) < 0) {
3468
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3469
                oc->filename);
3470
        av_exit(1);
3471
    }
3472

    
3473
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3474
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3475
    oc->loop_output = loop_output;
3476
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3477

    
3478
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3479
}
3480

    
3481
/* same option as mencoder */
3482
static void opt_pass(const char *pass_str)
3483
{
3484
    int pass;
3485
    pass = atoi(pass_str);
3486
    if (pass != 1 && pass != 2) {
3487
        fprintf(stderr, "pass number can be only 1 or 2\n");
3488
        av_exit(1);
3489
    }
3490
    do_pass = pass;
3491
}
3492

    
3493
static int64_t getutime(void)
3494
{
3495
#if HAVE_GETRUSAGE
3496
    struct rusage rusage;
3497

    
3498
    getrusage(RUSAGE_SELF, &rusage);
3499
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3500
#elif HAVE_GETPROCESSTIMES
3501
    HANDLE proc;
3502
    FILETIME c, e, k, u;
3503
    proc = GetCurrentProcess();
3504
    GetProcessTimes(proc, &c, &e, &k, &u);
3505
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3506
#else
3507
    return av_gettime();
3508
#endif
3509
}
3510

    
3511
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3512
{
3513
    int i;
3514
    const char *p = str;
3515
    for(i = 0;; i++) {
3516
        dest[i] = atoi(p);
3517
        if(i == 63)
3518
            break;
3519
        p = strchr(p, ',');
3520
        if(!p) {
3521
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3522
            av_exit(1);
3523
        }
3524
        p++;
3525
    }
3526
}
3527

    
3528
static void opt_inter_matrix(const char *arg)
3529
{
3530
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3531
    parse_matrix_coeffs(inter_matrix, arg);
3532
}
3533

    
3534
static void opt_intra_matrix(const char *arg)
3535
{
3536
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3537
    parse_matrix_coeffs(intra_matrix, arg);
3538
}
3539

    
3540
/**
3541
 * Trivial log callback.
3542
 * Only suitable for show_help and similar since it lacks prefix handling.
3543
 */
3544
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3545
{
3546
    vfprintf(stdout, fmt, vl);
3547
}
3548

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

    
3586
static void opt_target(const char *arg)
3587
{
3588
    int norm = -1;
3589
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3590

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

    
3635
    if(norm < 0) {
3636
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3637
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3638
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3639
        av_exit(1);
3640
    }
3641

    
3642
    if(!strcmp(arg, "vcd")) {
3643

    
3644
        opt_video_codec("mpeg1video");
3645
        opt_audio_codec("mp2");
3646
        opt_format("vcd");
3647

    
3648
        opt_frame_size(norm ? "352x240" : "352x288");
3649
        opt_frame_rate(NULL, frame_rates[norm]);
3650
        opt_default("g", norm ? "18" : "15");
3651

    
3652
        opt_default("b", "1150000");
3653
        opt_default("maxrate", "1150000");
3654
        opt_default("minrate", "1150000");
3655
        opt_default("bufsize", "327680"); // 40*1024*8;
3656

    
3657
        opt_default("ab", "224000");
3658
        audio_sample_rate = 44100;
3659
        audio_channels = 2;
3660

    
3661
        opt_default("packetsize", "2324");
3662
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3663

    
3664
        /* We have to offset the PTS, so that it is consistent with the SCR.
3665
           SCR starts at 36000, but the first two packs contain only padding
3666
           and the first pack from the other stream, respectively, may also have
3667
           been written before.
3668
           So the real data starts at SCR 36000+3*1200. */
3669
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3670
    } else if(!strcmp(arg, "svcd")) {
3671

    
3672
        opt_video_codec("mpeg2video");
3673
        opt_audio_codec("mp2");
3674
        opt_format("svcd");
3675

    
3676
        opt_frame_size(norm ? "480x480" : "480x576");
3677
        opt_frame_rate(NULL, frame_rates[norm]);
3678
        opt_default("g", norm ? "18" : "15");
3679

    
3680
        opt_default("b", "2040000");
3681
        opt_default("maxrate", "2516000");
3682
        opt_default("minrate", "0"); //1145000;
3683
        opt_default("bufsize", "1835008"); //224*1024*8;
3684
        opt_default("flags", "+scan_offset");
3685

    
3686

    
3687
        opt_default("ab", "224000");
3688
        audio_sample_rate = 44100;
3689

    
3690
        opt_default("packetsize", "2324");
3691

    
3692
    } else if(!strcmp(arg, "dvd")) {
3693

    
3694
        opt_video_codec("mpeg2video");
3695
        opt_audio_codec("ac3");
3696
        opt_format("dvd");
3697

    
3698
        opt_frame_size(norm ? "720x480" : "720x576");
3699
        opt_frame_rate(NULL, frame_rates[norm]);
3700
        opt_default("g", norm ? "18" : "15");
3701

    
3702
        opt_default("b", "6000000");
3703
        opt_default("maxrate", "9000000");
3704
        opt_default("minrate", "0"); //1500000;
3705
        opt_default("bufsize", "1835008"); //224*1024*8;
3706

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

    
3710
        opt_default("ab", "448000");
3711
        audio_sample_rate = 48000;
3712

    
3713
    } else if(!strncmp(arg, "dv", 2)) {
3714

    
3715
        opt_format("dv");
3716

    
3717
        opt_frame_size(norm ? "720x480" : "720x576");
3718
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3719
                                             (norm ? "yuv411p" : "yuv420p"));
3720
        opt_frame_rate(NULL, frame_rates[norm]);
3721

    
3722
        audio_sample_rate = 48000;
3723
        audio_channels = 2;
3724

    
3725
    } else {
3726
        fprintf(stderr, "Unknown target: %s\n", arg);
3727
        av_exit(1);
3728
    }
3729
}
3730

    
3731
static void opt_vstats_file (const char *arg)
3732
{
3733
    av_free (vstats_filename);
3734
    vstats_filename=av_strdup (arg);
3735
}
3736

    
3737
static void opt_vstats (void)
3738
{
3739
    char filename[40];
3740
    time_t today2 = time(NULL);
3741
    struct tm *today = localtime(&today2);
3742

    
3743
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3744
             today->tm_sec);
3745
    opt_vstats_file(filename);
3746
}
3747

    
3748
static int opt_bsf(const char *opt, const char *arg)
3749
{
3750
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3751
    AVBitStreamFilterContext **bsfp;
3752

    
3753
    if(!bsfc){
3754
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3755
        av_exit(1);
3756
    }
3757

    
3758
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3759
          *opt == 'a' ? &audio_bitstream_filters :
3760
                        &subtitle_bitstream_filters;
3761
    while(*bsfp)
3762
        bsfp= &(*bsfp)->next;
3763

    
3764
    *bsfp= bsfc;
3765

    
3766
    return 0;
3767
}
3768

    
3769
static int opt_preset(const char *opt, const char *arg)
3770
{
3771
    FILE *f=NULL;
3772
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3773
    int i;
3774
    const char *base[2]= { getenv("HOME"),
3775
                           FFMPEG_DATADIR,
3776
                         };
3777

    
3778
    if (*opt != 'f') {
3779
    for(i=!base[0]; i<2 && !f; i++){
3780
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3781
        f= fopen(filename, "r");
3782
        if(!f){
3783
            char *codec_name= *opt == 'v' ? video_codec_name :
3784
                              *opt == 'a' ? audio_codec_name :
3785
                                            subtitle_codec_name;
3786
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3787
            f= fopen(filename, "r");
3788
        }
3789
    }
3790
    } else {
3791
        av_strlcpy(filename, arg, sizeof(filename));
3792
        f= fopen(filename, "r");
3793
    }
3794

    
3795
    if(!f){
3796
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3797
        av_exit(1);
3798
    }
3799

    
3800
    while(!feof(f)){
3801
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3802
        if(line[0] == '#' && !e)
3803
            continue;
3804
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3805
        if(e){
3806
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3807
            av_exit(1);
3808
        }
3809
        if(!strcmp(tmp, "acodec")){
3810
            opt_audio_codec(tmp2);
3811
        }else if(!strcmp(tmp, "vcodec")){
3812
            opt_video_codec(tmp2);
3813
        }else if(!strcmp(tmp, "scodec")){
3814
            opt_subtitle_codec(tmp2);
3815
        }else if(opt_default(tmp, tmp2) < 0){
3816
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3817
            av_exit(1);
3818
        }
3819
    }
3820

    
3821
    fclose(f);
3822

    
3823
    return 0;
3824
}
3825

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

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

    
3911
    /* audio options */
3912
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3913
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3914
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3915
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3916
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3917
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3918
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3919
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3920
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3921
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3922
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3923
    { "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" },
3924

    
3925
    /* subtitle options */
3926
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3927
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3928
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3929
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3930
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3931

    
3932
    /* grab options */
3933
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3934
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3935
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3936

    
3937
    /* muxer options */
3938
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3939
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3940

    
3941
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3942
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3943
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3944

    
3945
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3946
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3947
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3948
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options to the indicated preset file", "filename" },
3949

    
3950
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3951
    { NULL, },
3952
};
3953

    
3954
int main(int argc, char **argv)
3955
{
3956
    int i;
3957
    int64_t ti;
3958

    
3959
    avcodec_register_all();
3960
    avdevice_register_all();
3961
    av_register_all();
3962

    
3963
#if HAVE_ISATTY
3964
    if(isatty(STDIN_FILENO))
3965
        url_set_interrupt_cb(decode_interrupt_cb);
3966
#endif
3967

    
3968
    for(i=0; i<CODEC_TYPE_NB; i++){
3969
        avcodec_opts[i]= avcodec_alloc_context2(i);
3970
    }
3971
    avformat_opts = avformat_alloc_context();
3972
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3973

    
3974
    show_banner();
3975

    
3976
    /* parse options */
3977
    parse_options(argc, argv, options, opt_output_file);
3978

    
3979
    /* file converter / grab */
3980
    if (nb_output_files <= 0) {
3981
        fprintf(stderr, "At least one output file must be specified\n");
3982
        av_exit(1);
3983
    }
3984

    
3985
    if (nb_input_files == 0) {
3986
        fprintf(stderr, "At least one input file must be specified\n");
3987
        av_exit(1);
3988
    }
3989

    
3990
    ti = getutime();
3991
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3992
                  stream_maps, nb_stream_maps) < 0)
3993
        av_exit(1);
3994
    ti = getutime() - ti;
3995
    if (do_benchmark) {
3996
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3997
    }
3998

    
3999
    return av_exit(0);
4000
}