Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 7a086a85

History | View | Annotate | Download (145 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 const 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 char *video_language = NULL;
138
static int same_quality = 0;
139
static int do_deinterlace = 0;
140
static int top_field_first = -1;
141
static int me_threshold = 0;
142
static int intra_dc_precision = 8;
143
static int loop_input = 0;
144
static int loop_output = AVFMT_NOOUTPUTLOOP;
145
static int qp_hist = 0;
146

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

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

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

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

    
193
static int rate_emu = 0;
194

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

    
198
static int audio_volume = 256;
199

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

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

    
217
static unsigned int sws_flags = SWS_BICUBIC;
218

    
219
static int64_t timer_start;
220

    
221
static uint8_t *audio_buf;
222
static uint8_t *audio_out;
223
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
224

    
225
static short *samples;
226

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

    
232
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
233

    
234
struct AVInputStream;
235

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

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

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

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

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

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

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

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

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

    
311
#if HAVE_TERMIOS_H
312

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

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

    
324
static volatile int received_sigterm = 0;
325

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

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

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

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

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

    
354
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
355
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
356
#ifdef SIGXCPU
357
    signal(SIGXCPU, sigterm_handler);
358
#endif
359

    
360
    /*
361
    register a function to be called at normal program termination
362
    */
363
    atexit(term_exit);
364
#if CONFIG_BEOS_NETSERVER
365
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
366
#endif
367
}
368

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

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

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

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

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

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

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

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

    
439
    av_free(opt_names);
440

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

    
445
    av_free(video_standard);
446

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

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

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

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

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

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

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

    
497
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
498
            st->stream_copy = 1;
499
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
500
            st->stream_copy = 1;
501

    
502
        if(!st->codec->thread_count)
503
            st->codec->thread_count = 1;
504
        if(st->codec->thread_count>1)
505
            avcodec_thread_init(st->codec, st->codec->thread_count);
506

    
507
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
508
            nopts = 1;
509
    }
510

    
511
    if (!nopts)
512
        s->timestamp = av_gettime();
513

    
514
    av_close_input_file(ic);
515
    return 0;
516
}
517

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

    
525
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
526
    int ret;
527

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

    
547
        bsfc= bsfc->next;
548
    }
549

    
550
    ret= av_interleaved_write_frame(s, pkt);
551
    if(ret < 0){
552
        print_error("av_interleaved_write_frame()", ret);
553
        av_exit(1);
554
    }
555
}
556

    
557
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
558

    
559
static void do_audio_out(AVFormatContext *s,
560
                         AVOutputStream *ost,
561
                         AVInputStream *ist,
562
                         unsigned char *buf, int size)
563
{
564
    uint8_t *buftmp;
565
    int64_t audio_out_size, audio_buf_size;
566
    int64_t allocated_for_size= size;
567

    
568
    int size_out, frame_bytes, ret;
569
    AVCodecContext *enc= ost->st->codec;
570
    AVCodecContext *dec= ist->st->codec;
571
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
572
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
573
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
574

    
575
need_realloc:
576
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
577
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
578
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
579
    audio_buf_size*= osize*enc->channels;
580

    
581
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
582
    if(coded_bps > 8*osize)
583
        audio_out_size= audio_out_size * coded_bps / (8*osize);
584
    audio_out_size += FF_MIN_BUFFER_SIZE;
585

    
586
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
587
        fprintf(stderr, "Buffer sizes too large\n");
588
        av_exit(1);
589
    }
590

    
591
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
592
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
593
    if (!audio_buf || !audio_out){
594
        fprintf(stderr, "Out of memory in do_audio_out\n");
595
        av_exit(1);
596
    }
597

    
598
    if (enc->channels != dec->channels)
599
        ost->audio_resample = 1;
600

    
601
    if (ost->audio_resample && !ost->resample) {
602
        if (dec->sample_fmt != SAMPLE_FMT_S16)
603
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
604
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
605
                                               enc->sample_rate, dec->sample_rate,
606
                                               enc->sample_fmt,  dec->sample_fmt,
607
                                               16, 10, 0, 0.8);
608
        if (!ost->resample) {
609
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
610
                    dec->channels, dec->sample_rate,
611
                    enc->channels, enc->sample_rate);
612
            av_exit(1);
613
        }
614
    }
615

    
616
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
617
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
618
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
619
        if (ost->reformat_ctx)
620
            av_audio_convert_free(ost->reformat_ctx);
621
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
622
                                                   dec->sample_fmt, 1, NULL, 0);
623
        if (!ost->reformat_ctx) {
624
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
625
                avcodec_get_sample_fmt_name(dec->sample_fmt),
626
                avcodec_get_sample_fmt_name(enc->sample_fmt));
627
            av_exit(1);
628
        }
629
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
630
    }
631

    
632
    if(audio_sync_method){
633
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
634
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
635
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
636
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
637

    
638
        //FIXME resample delay
639
        if(fabs(delta) > 50){
640
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
641
                if(byte_delta < 0){
642
                    byte_delta= FFMAX(byte_delta, -size);
643
                    size += byte_delta;
644
                    buf  -= byte_delta;
645
                    if(verbose > 2)
646
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
647
                    if(!size)
648
                        return;
649
                    ist->is_start=0;
650
                }else{
651
                    static uint8_t *input_tmp= NULL;
652
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
653

    
654
                    if(byte_delta > allocated_for_size - size){
655
                        allocated_for_size= byte_delta + (int64_t)size;
656
                        goto need_realloc;
657
                    }
658
                    ist->is_start=0;
659

    
660
                    memset(input_tmp, 0, byte_delta);
661
                    memcpy(input_tmp + byte_delta, buf, size);
662
                    buf= input_tmp;
663
                    size += byte_delta;
664
                    if(verbose > 2)
665
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
666
                }
667
            }else if(audio_sync_method>1){
668
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
669
                assert(ost->audio_resample);
670
                if(verbose > 2)
671
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
672
//                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));
673
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
674
            }
675
        }
676
    }else
677
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
678
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
679

    
680
    if (ost->audio_resample) {
681
        buftmp = audio_buf;
682
        size_out = audio_resample(ost->resample,
683
                                  (short *)buftmp, (short *)buf,
684
                                  size / (ist->st->codec->channels * isize));
685
        size_out = size_out * enc->channels * osize;
686
    } else {
687
        buftmp = buf;
688
        size_out = size;
689
    }
690

    
691
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
692
        const void *ibuf[6]= {buftmp};
693
        void *obuf[6]= {audio_buf};
694
        int istride[6]= {isize};
695
        int ostride[6]= {osize};
696
        int len= size_out/istride[0];
697
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
698
            printf("av_audio_convert() failed\n");
699
            if (exit_on_error)
700
                av_exit(1);
701
            return;
702
        }
703
        buftmp = audio_buf;
704
        size_out = len*osize;
705
    }
706

    
707
    /* now encode as many frames as possible */
708
    if (enc->frame_size > 1) {
709
        /* output resampled raw samples */
710
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
711
            fprintf(stderr, "av_fifo_realloc2() failed\n");
712
            av_exit(1);
713
        }
714
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
715

    
716
        frame_bytes = enc->frame_size * osize * enc->channels;
717

    
718
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
719
            AVPacket pkt;
720
            av_init_packet(&pkt);
721

    
722
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
723

    
724
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
725

    
726
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
727
                                       (short *)audio_buf);
728
            if (ret < 0) {
729
                fprintf(stderr, "Audio encoding failed\n");
730
                av_exit(1);
731
            }
732
            audio_size += ret;
733
            pkt.stream_index= ost->index;
734
            pkt.data= audio_out;
735
            pkt.size= ret;
736
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
737
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
738
            pkt.flags |= PKT_FLAG_KEY;
739
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
740

    
741
            ost->sync_opts += enc->frame_size;
742
        }
743
    } else {
744
        AVPacket pkt;
745
        av_init_packet(&pkt);
746

    
747
        ost->sync_opts += size_out / (osize * enc->channels);
748

    
749
        /* output a pcm frame */
750
        /* determine the size of the coded buffer */
751
        size_out /= osize;
752
        if (coded_bps)
753
            size_out = size_out*coded_bps/8;
754

    
755
        if(size_out > audio_out_size){
756
            fprintf(stderr, "Internal error, buffer size too small\n");
757
            av_exit(1);
758
        }
759

    
760
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
761
        ret = avcodec_encode_audio(enc, audio_out, size_out,
762
                                   (short *)buftmp);
763
        if (ret < 0) {
764
            fprintf(stderr, "Audio encoding failed\n");
765
            av_exit(1);
766
        }
767
        audio_size += ret;
768
        pkt.stream_index= ost->index;
769
        pkt.data= audio_out;
770
        pkt.size= ret;
771
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
772
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
773
        pkt.flags |= PKT_FLAG_KEY;
774
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
775
    }
776
}
777

    
778
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
779
{
780
    AVCodecContext *dec;
781
    AVPicture *picture2;
782
    AVPicture picture_tmp;
783
    uint8_t *buf = 0;
784

    
785
    dec = ist->st->codec;
786

    
787
    /* deinterlace : must be done before any resize */
788
    if (do_deinterlace) {
789
        int size;
790

    
791
        /* create temporary picture */
792
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
793
        buf = av_malloc(size);
794
        if (!buf)
795
            return;
796

    
797
        picture2 = &picture_tmp;
798
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
799

    
800
        if(avpicture_deinterlace(picture2, picture,
801
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
802
            /* if error, do not deinterlace */
803
            fprintf(stderr, "Deinterlacing failed\n");
804
            av_free(buf);
805
            buf = NULL;
806
            picture2 = picture;
807
        }
808
    } else {
809
        picture2 = picture;
810
    }
811

    
812
    if (picture != picture2)
813
        *picture = *picture2;
814
    *bufp = buf;
815
}
816

    
817
/* we begin to correct av delay at this threshold */
818
#define AV_DELAY_MAX 0.100
819

    
820
static void do_subtitle_out(AVFormatContext *s,
821
                            AVOutputStream *ost,
822
                            AVInputStream *ist,
823
                            AVSubtitle *sub,
824
                            int64_t pts)
825
{
826
    static uint8_t *subtitle_out = NULL;
827
    int subtitle_out_max_size = 1024 * 1024;
828
    int subtitle_out_size, nb, i;
829
    AVCodecContext *enc;
830
    AVPacket pkt;
831

    
832
    if (pts == AV_NOPTS_VALUE) {
833
        fprintf(stderr, "Subtitle packets must have a pts\n");
834
        if (exit_on_error)
835
            av_exit(1);
836
        return;
837
    }
838

    
839
    enc = ost->st->codec;
840

    
841
    if (!subtitle_out) {
842
        subtitle_out = av_malloc(subtitle_out_max_size);
843
    }
844

    
845
    /* Note: DVB subtitle need one packet to draw them and one other
846
       packet to clear them */
847
    /* XXX: signal it in the codec context ? */
848
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
849
        nb = 2;
850
    else
851
        nb = 1;
852

    
853
    for(i = 0; i < nb; i++) {
854
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
855
        // start_display_time is required to be 0
856
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
857
        sub->end_display_time -= sub->start_display_time;
858
        sub->start_display_time = 0;
859
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
860
                                                    subtitle_out_max_size, sub);
861
        if (subtitle_out_size < 0) {
862
            fprintf(stderr, "Subtitle encoding failed\n");
863
            av_exit(1);
864
        }
865

    
866
        av_init_packet(&pkt);
867
        pkt.stream_index = ost->index;
868
        pkt.data = subtitle_out;
869
        pkt.size = subtitle_out_size;
870
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
871
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
872
            /* XXX: the pts correction is handled here. Maybe handling
873
               it in the codec would be better */
874
            if (i == 0)
875
                pkt.pts += 90 * sub->start_display_time;
876
            else
877
                pkt.pts += 90 * sub->end_display_time;
878
        }
879
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
880
    }
881
}
882

    
883
static int bit_buffer_size= 1024*256;
884
static uint8_t *bit_buffer= NULL;
885

    
886
static void do_video_out(AVFormatContext *s,
887
                         AVOutputStream *ost,
888
                         AVInputStream *ist,
889
                         AVFrame *in_picture,
890
                         int *frame_size)
891
{
892
    int nb_frames, i, ret;
893
    int64_t topBand, bottomBand, leftBand, rightBand;
894
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
895
    AVFrame picture_crop_temp, picture_pad_temp;
896
    AVCodecContext *enc, *dec;
897

    
898
    avcodec_get_frame_defaults(&picture_crop_temp);
899
    avcodec_get_frame_defaults(&picture_pad_temp);
900

    
901
    enc = ost->st->codec;
902
    dec = ist->st->codec;
903

    
904
    /* by default, we output a single frame */
905
    nb_frames = 1;
906

    
907
    *frame_size = 0;
908

    
909
    if(video_sync_method){
910
        double vdelta;
911
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
912
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
913
        if (vdelta < -1.1)
914
            nb_frames = 0;
915
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
916
            if(vdelta<=-0.6){
917
                nb_frames=0;
918
            }else if(vdelta>0.6)
919
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
920
        }else if (vdelta > 1.1)
921
            nb_frames = lrintf(vdelta);
922
//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);
923
        if (nb_frames == 0){
924
            ++nb_frames_drop;
925
            if (verbose>2)
926
                fprintf(stderr, "*** drop!\n");
927
        }else if (nb_frames > 1) {
928
            nb_frames_dup += nb_frames - 1;
929
            if (verbose>2)
930
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
931
        }
932
    }else
933
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
934

    
935
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
936
    if (nb_frames <= 0)
937
        return;
938

    
939
    if (ost->video_crop) {
940
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
941
            fprintf(stderr, "error cropping picture\n");
942
            if (exit_on_error)
943
                av_exit(1);
944
            return;
945
        }
946
        formatted_picture = &picture_crop_temp;
947
    } else {
948
        formatted_picture = in_picture;
949
    }
950

    
951
    final_picture = formatted_picture;
952
    padding_src = formatted_picture;
953
    resampling_dst = &ost->pict_tmp;
954
    if (ost->video_pad) {
955
        final_picture = &ost->pict_tmp;
956
        if (ost->video_resample) {
957
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
958
                fprintf(stderr, "error padding picture\n");
959
                if (exit_on_error)
960
                    av_exit(1);
961
                return;
962
            }
963
            resampling_dst = &picture_pad_temp;
964
        }
965
    }
966

    
967
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
968
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
969
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
970

    
971
        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));
972
        if(!ost->video_resample)
973
            av_exit(1);
974
    }
975

    
976
    if (ost->video_resample) {
977
        padding_src = NULL;
978
        final_picture = &ost->pict_tmp;
979
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
980
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
981
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
982

    
983
            /* keep bands proportional to the frame size */
984
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
985
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
986
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
987
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
988

    
989
            /* sanity check to ensure no bad band sizes sneak in */
990
            assert(topBand    <= INT_MAX && topBand    >= 0);
991
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
992
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
993
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
994

    
995
            ost->topBand    = topBand;
996
            ost->bottomBand = bottomBand;
997
            ost->leftBand   = leftBand;
998
            ost->rightBand  = rightBand;
999

    
1000
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1001
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1002
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1003

    
1004
            /* initialize a new scaler context */
1005
            sws_freeContext(ost->img_resample_ctx);
1006
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1007
            ost->img_resample_ctx = sws_getContext(
1008
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1009
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1010
                ist->st->codec->pix_fmt,
1011
                ost->st->codec->width  - (ost->padleft  + ost->padright),
1012
                ost->st->codec->height - (ost->padtop   + ost->padbottom),
1013
                ost->st->codec->pix_fmt,
1014
                sws_flags, NULL, NULL, NULL);
1015
            if (ost->img_resample_ctx == NULL) {
1016
                fprintf(stderr, "Cannot get resampling context\n");
1017
                av_exit(1);
1018
            }
1019
        }
1020
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1021
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1022
    }
1023

    
1024
    if (ost->video_pad) {
1025
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1026
                enc->height, enc->width, enc->pix_fmt,
1027
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1028
    }
1029

    
1030
    /* duplicates frame if needed */
1031
    for(i=0;i<nb_frames;i++) {
1032
        AVPacket pkt;
1033
        av_init_packet(&pkt);
1034
        pkt.stream_index= ost->index;
1035

    
1036
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1037
            /* raw pictures are written as AVPicture structure to
1038
               avoid any copies. We support temorarily the older
1039
               method. */
1040
            AVFrame* old_frame = enc->coded_frame;
1041
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1042
            pkt.data= (uint8_t *)final_picture;
1043
            pkt.size=  sizeof(AVPicture);
1044
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1045
            pkt.flags |= PKT_FLAG_KEY;
1046

    
1047
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1048
            enc->coded_frame = old_frame;
1049
        } else {
1050
            AVFrame big_picture;
1051

    
1052
            big_picture= *final_picture;
1053
            /* better than nothing: use input picture interlaced
1054
               settings */
1055
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1056
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1057
                if(top_field_first == -1)
1058
                    big_picture.top_field_first = in_picture->top_field_first;
1059
                else
1060
                    big_picture.top_field_first = top_field_first;
1061
            }
1062

    
1063
            /* handles sameq here. This is not correct because it may
1064
               not be a global option */
1065
            if (same_quality) {
1066
                big_picture.quality = ist->st->quality;
1067
            }else
1068
                big_picture.quality = ost->st->quality;
1069
            if(!me_threshold)
1070
                big_picture.pict_type = 0;
1071
//            big_picture.pts = AV_NOPTS_VALUE;
1072
            big_picture.pts= ost->sync_opts;
1073
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1074
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1075
            ret = avcodec_encode_video(enc,
1076
                                       bit_buffer, bit_buffer_size,
1077
                                       &big_picture);
1078
            if (ret < 0) {
1079
                fprintf(stderr, "Video encoding failed\n");
1080
                av_exit(1);
1081
            }
1082

    
1083
            if(ret>0){
1084
                pkt.data= bit_buffer;
1085
                pkt.size= ret;
1086
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1087
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1088
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1089
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1090
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1091

    
1092
                if(enc->coded_frame->key_frame)
1093
                    pkt.flags |= PKT_FLAG_KEY;
1094
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1095
                *frame_size = ret;
1096
                video_size += ret;
1097
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1098
                //        enc->frame_number-1, ret, enc->pict_type);
1099
                /* if two pass, output log */
1100
                if (ost->logfile && enc->stats_out) {
1101
                    fprintf(ost->logfile, "%s", enc->stats_out);
1102
                }
1103
            }
1104
        }
1105
        ost->sync_opts++;
1106
        ost->frame_number++;
1107
    }
1108
}
1109

    
1110
static double psnr(double d){
1111
    return -10.0*log(d)/log(10.0);
1112
}
1113

    
1114
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1115
                           int frame_size)
1116
{
1117
    AVCodecContext *enc;
1118
    int frame_number;
1119
    double ti1, bitrate, avg_bitrate;
1120

    
1121
    /* this is executed just the first time do_video_stats is called */
1122
    if (!vstats_file) {
1123
        vstats_file = fopen(vstats_filename, "w");
1124
        if (!vstats_file) {
1125
            perror("fopen");
1126
            av_exit(1);
1127
        }
1128
    }
1129

    
1130
    enc = ost->st->codec;
1131
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1132
        frame_number = ost->frame_number;
1133
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1134
        if (enc->flags&CODEC_FLAG_PSNR)
1135
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1136

    
1137
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1138
        /* compute pts value */
1139
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1140
        if (ti1 < 0.01)
1141
            ti1 = 0.01;
1142

    
1143
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1144
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1145
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1146
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1147
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1148
    }
1149
}
1150

    
1151
static void print_report(AVFormatContext **output_files,
1152
                         AVOutputStream **ost_table, int nb_ostreams,
1153
                         int is_last_report)
1154
{
1155
    char buf[1024];
1156
    AVOutputStream *ost;
1157
    AVFormatContext *oc;
1158
    int64_t total_size;
1159
    AVCodecContext *enc;
1160
    int frame_number, vid, i;
1161
    double bitrate, ti1, pts;
1162
    static int64_t last_time = -1;
1163
    static int qp_histogram[52];
1164

    
1165
    if (!is_last_report) {
1166
        int64_t cur_time;
1167
        /* display the report every 0.5 seconds */
1168
        cur_time = av_gettime();
1169
        if (last_time == -1) {
1170
            last_time = cur_time;
1171
            return;
1172
        }
1173
        if ((cur_time - last_time) < 500000)
1174
            return;
1175
        last_time = cur_time;
1176
    }
1177

    
1178

    
1179
    oc = output_files[0];
1180

    
1181
    total_size = url_fsize(oc->pb);
1182
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1183
        total_size= url_ftell(oc->pb);
1184

    
1185
    buf[0] = '\0';
1186
    ti1 = 1e10;
1187
    vid = 0;
1188
    for(i=0;i<nb_ostreams;i++) {
1189
        ost = ost_table[i];
1190
        enc = ost->st->codec;
1191
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1192
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1193
                     !ost->st->stream_copy ?
1194
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1195
        }
1196
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1197
            float t = (av_gettime()-timer_start) / 1000000.0;
1198

    
1199
            frame_number = ost->frame_number;
1200
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1201
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1202
                     !ost->st->stream_copy ?
1203
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1204
            if(is_last_report)
1205
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1206
            if(qp_hist){
1207
                int j;
1208
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1209
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1210
                    qp_histogram[qp]++;
1211
                for(j=0; j<32; j++)
1212
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1213
            }
1214
            if (enc->flags&CODEC_FLAG_PSNR){
1215
                int j;
1216
                double error, error_sum=0;
1217
                double scale, scale_sum=0;
1218
                char type[3]= {'Y','U','V'};
1219
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1220
                for(j=0; j<3; j++){
1221
                    if(is_last_report){
1222
                        error= enc->error[j];
1223
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1224
                    }else{
1225
                        error= enc->coded_frame->error[j];
1226
                        scale= enc->width*enc->height*255.0*255.0;
1227
                    }
1228
                    if(j) scale/=4;
1229
                    error_sum += error;
1230
                    scale_sum += scale;
1231
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1232
                }
1233
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1234
            }
1235
            vid = 1;
1236
        }
1237
        /* compute min output value */
1238
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1239
        if ((pts < ti1) && (pts > 0))
1240
            ti1 = pts;
1241
    }
1242
    if (ti1 < 0.01)
1243
        ti1 = 0.01;
1244

    
1245
    if (verbose || is_last_report) {
1246
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1247

    
1248
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1249
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1250
            (double)total_size / 1024, ti1, bitrate);
1251

    
1252
        if (nb_frames_dup || nb_frames_drop)
1253
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1254
                  nb_frames_dup, nb_frames_drop);
1255

    
1256
        if (verbose >= 0)
1257
            fprintf(stderr, "%s    \r", buf);
1258

    
1259
        fflush(stderr);
1260
    }
1261

    
1262
    if (is_last_report && verbose >= 0){
1263
        int64_t raw= audio_size + video_size + extra_size;
1264
        fprintf(stderr, "\n");
1265
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1266
                video_size/1024.0,
1267
                audio_size/1024.0,
1268
                extra_size/1024.0,
1269
                100.0*(total_size - raw)/raw
1270
        );
1271
    }
1272
}
1273

    
1274
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1275
static int output_packet(AVInputStream *ist, int ist_index,
1276
                         AVOutputStream **ost_table, int nb_ostreams,
1277
                         const AVPacket *pkt)
1278
{
1279
    AVFormatContext *os;
1280
    AVOutputStream *ost;
1281
    int ret, i;
1282
    int got_picture;
1283
    AVFrame picture;
1284
    void *buffer_to_free;
1285
    static unsigned int samples_size= 0;
1286
    AVSubtitle subtitle, *subtitle_to_free;
1287
    int got_subtitle;
1288
    AVPacket avpkt;
1289
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1290

    
1291
    if(ist->next_pts == AV_NOPTS_VALUE)
1292
        ist->next_pts= ist->pts;
1293

    
1294
    if (pkt == NULL) {
1295
        /* EOF handling */
1296
        av_init_packet(&avpkt);
1297
        avpkt.data = NULL;
1298
        avpkt.size = 0;
1299
        goto handle_eof;
1300
    } else {
1301
        avpkt = *pkt;
1302
    }
1303

    
1304
    if(pkt->dts != AV_NOPTS_VALUE)
1305
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1306

    
1307
    //while we have more to decode or while the decoder did output something on EOF
1308
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1309
        uint8_t *data_buf, *decoded_data_buf;
1310
        int data_size, decoded_data_size;
1311
    handle_eof:
1312
        ist->pts= ist->next_pts;
1313

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

    
1318
        /* decode the packet if needed */
1319
        decoded_data_buf = NULL; /* fail safe */
1320
        decoded_data_size= 0;
1321
        data_buf  = avpkt.data;
1322
        data_size = avpkt.size;
1323
        subtitle_to_free = NULL;
1324
        if (ist->decoding_needed) {
1325
            switch(ist->st->codec->codec_type) {
1326
            case CODEC_TYPE_AUDIO:{
1327
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1328
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1329
                    av_free(samples);
1330
                    samples= av_malloc(samples_size);
1331
                }
1332
                decoded_data_size= samples_size;
1333
                    /* XXX: could avoid copy if PCM 16 bits with same
1334
                       endianness as CPU */
1335
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1336
                                            &avpkt);
1337
                if (ret < 0)
1338
                    goto fail_decode;
1339
                avpkt.data += ret;
1340
                avpkt.size -= ret;
1341
                data_size   = ret;
1342
                /* Some bug in mpeg audio decoder gives */
1343
                /* decoded_data_size < 0, it seems they are overflows */
1344
                if (decoded_data_size <= 0) {
1345
                    /* no audio frame */
1346
                    continue;
1347
                }
1348
                decoded_data_buf = (uint8_t *)samples;
1349
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1350
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1351
                break;}
1352
            case CODEC_TYPE_VIDEO:
1353
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1354
                    /* XXX: allocate picture correctly */
1355
                    avcodec_get_frame_defaults(&picture);
1356

    
1357
                    ret = avcodec_decode_video2(ist->st->codec,
1358
                                                &picture, &got_picture, &avpkt);
1359
                    ist->st->quality= picture.quality;
1360
                    if (ret < 0)
1361
                        goto fail_decode;
1362
                    if (!got_picture) {
1363
                        /* no picture yet */
1364
                        goto discard_packet;
1365
                    }
1366
                    if (ist->st->codec->time_base.num != 0) {
1367
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1368
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1369
                                          ist->st->codec->time_base.num * ticks) /
1370
                            ist->st->codec->time_base.den;
1371
                    }
1372
                    avpkt.size = 0;
1373
                    break;
1374
            case CODEC_TYPE_SUBTITLE:
1375
                ret = avcodec_decode_subtitle2(ist->st->codec,
1376
                                               &subtitle, &got_subtitle, &avpkt);
1377
                if (ret < 0)
1378
                    goto fail_decode;
1379
                if (!got_subtitle) {
1380
                    goto discard_packet;
1381
                }
1382
                subtitle_to_free = &subtitle;
1383
                avpkt.size = 0;
1384
                break;
1385
            default:
1386
                goto fail_decode;
1387
            }
1388
        } else {
1389
            switch(ist->st->codec->codec_type) {
1390
            case CODEC_TYPE_AUDIO:
1391
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1392
                    ist->st->codec->sample_rate;
1393
                break;
1394
            case CODEC_TYPE_VIDEO:
1395
                if (ist->st->codec->time_base.num != 0) {
1396
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1397
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1398
                                      ist->st->codec->time_base.num * ticks) /
1399
                        ist->st->codec->time_base.den;
1400
                }
1401
                break;
1402
            }
1403
            ret = avpkt.size;
1404
            avpkt.size = 0;
1405
        }
1406

    
1407
        buffer_to_free = NULL;
1408
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1409
            pre_process_video_frame(ist, (AVPicture *)&picture,
1410
                                    &buffer_to_free);
1411
        }
1412

    
1413
        // preprocess audio (volume)
1414
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1415
            if (audio_volume != 256) {
1416
                short *volp;
1417
                volp = samples;
1418
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1419
                    int v = ((*volp) * audio_volume + 128) >> 8;
1420
                    if (v < -32768) v = -32768;
1421
                    if (v >  32767) v = 32767;
1422
                    *volp++ = v;
1423
                }
1424
            }
1425
        }
1426

    
1427
        /* frame rate emulation */
1428
        if (rate_emu) {
1429
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1430
            int64_t now = av_gettime() - ist->start;
1431
            if (pts > now)
1432
                usleep(pts - now);
1433
        }
1434

    
1435
        /* if output time reached then transcode raw format,
1436
           encode packets and output them */
1437
        if (start_time == 0 || ist->pts >= start_time)
1438
            for(i=0;i<nb_ostreams;i++) {
1439
                int frame_size;
1440

    
1441
                ost = ost_table[i];
1442
                if (ost->source_index == ist_index) {
1443
                    os = output_files[ost->file_index];
1444

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

    
1448
                    if (ost->encoding_needed) {
1449
                        assert(ist->decoding_needed);
1450
                        switch(ost->st->codec->codec_type) {
1451
                        case CODEC_TYPE_AUDIO:
1452
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1453
                            break;
1454
                        case CODEC_TYPE_VIDEO:
1455
                            do_video_out(os, ost, ist, &picture, &frame_size);
1456
                            if (vstats_filename && frame_size)
1457
                                do_video_stats(os, ost, frame_size);
1458
                            break;
1459
                        case CODEC_TYPE_SUBTITLE:
1460
                            do_subtitle_out(os, ost, ist, &subtitle,
1461
                                            pkt->pts);
1462
                            break;
1463
                        default:
1464
                            abort();
1465
                        }
1466
                    } else {
1467
                        AVFrame avframe; //FIXME/XXX remove this
1468
                        AVPacket opkt;
1469
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1470

    
1471
                        av_init_packet(&opkt);
1472

    
1473
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1474
                            continue;
1475

    
1476
                        /* no reencoding needed : output the packet directly */
1477
                        /* force the input stream PTS */
1478

    
1479
                        avcodec_get_frame_defaults(&avframe);
1480
                        ost->st->codec->coded_frame= &avframe;
1481
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1482

    
1483
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1484
                            audio_size += data_size;
1485
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1486
                            video_size += data_size;
1487
                            ost->sync_opts++;
1488
                        }
1489

    
1490
                        opkt.stream_index= ost->index;
1491
                        if(pkt->pts != AV_NOPTS_VALUE)
1492
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1493
                        else
1494
                            opkt.pts= AV_NOPTS_VALUE;
1495

    
1496
                        if (pkt->dts == AV_NOPTS_VALUE)
1497
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1498
                        else
1499
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1500
                        opkt.dts -= ost_tb_start_time;
1501

    
1502
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1503
                        opkt.flags= pkt->flags;
1504

    
1505
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1506
                        if(ost->st->codec->codec_id != CODEC_ID_H264) {
1507
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1508
                                opkt.destruct= av_destruct_packet;
1509
                        } else {
1510
                            opkt.data = data_buf;
1511
                            opkt.size = data_size;
1512
                        }
1513

    
1514
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1515
                        ost->st->codec->frame_number++;
1516
                        ost->frame_number++;
1517
                        av_free_packet(&opkt);
1518
                    }
1519
                }
1520
            }
1521
        av_free(buffer_to_free);
1522
        /* XXX: allocate the subtitles in the codec ? */
1523
        if (subtitle_to_free) {
1524
            if (subtitle_to_free->rects != NULL) {
1525
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1526
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1527
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1528
                    av_freep(&subtitle_to_free->rects[i]);
1529
                }
1530
                av_freep(&subtitle_to_free->rects);
1531
            }
1532
            subtitle_to_free->num_rects = 0;
1533
            subtitle_to_free = NULL;
1534
        }
1535
    }
1536
 discard_packet:
1537
    if (pkt == NULL) {
1538
        /* EOF handling */
1539

    
1540
        for(i=0;i<nb_ostreams;i++) {
1541
            ost = ost_table[i];
1542
            if (ost->source_index == ist_index) {
1543
                AVCodecContext *enc= ost->st->codec;
1544
                os = output_files[ost->file_index];
1545

    
1546
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1547
                    continue;
1548
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1549
                    continue;
1550

    
1551
                if (ost->encoding_needed) {
1552
                    for(;;) {
1553
                        AVPacket pkt;
1554
                        int fifo_bytes;
1555
                        av_init_packet(&pkt);
1556
                        pkt.stream_index= ost->index;
1557

    
1558
                        switch(ost->st->codec->codec_type) {
1559
                        case CODEC_TYPE_AUDIO:
1560
                            fifo_bytes = av_fifo_size(ost->fifo);
1561
                            ret = 0;
1562
                            /* encode any samples remaining in fifo */
1563
                            if (fifo_bytes > 0) {
1564
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1565
                                int fs_tmp = enc->frame_size;
1566

    
1567
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1568
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1569
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1570
                                } else { /* pad */
1571
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1572
                                    if (samples_size < frame_bytes)
1573
                                        av_exit(1);
1574
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1575
                                }
1576

    
1577
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1578
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1579
                                                          ost->st->time_base.num, enc->sample_rate);
1580
                                enc->frame_size = fs_tmp;
1581
                            }
1582
                            if(ret <= 0) {
1583
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1584
                            }
1585
                            if (ret < 0) {
1586
                                fprintf(stderr, "Audio encoding failed\n");
1587
                                av_exit(1);
1588
                            }
1589
                            audio_size += ret;
1590
                            pkt.flags |= PKT_FLAG_KEY;
1591
                            break;
1592
                        case CODEC_TYPE_VIDEO:
1593
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1594
                            if (ret < 0) {
1595
                                fprintf(stderr, "Video encoding failed\n");
1596
                                av_exit(1);
1597
                            }
1598
                            video_size += ret;
1599
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1600
                                pkt.flags |= PKT_FLAG_KEY;
1601
                            if (ost->logfile && enc->stats_out) {
1602
                                fprintf(ost->logfile, "%s", enc->stats_out);
1603
                            }
1604
                            break;
1605
                        default:
1606
                            ret=-1;
1607
                        }
1608

    
1609
                        if(ret<=0)
1610
                            break;
1611
                        pkt.data= bit_buffer;
1612
                        pkt.size= ret;
1613
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1614
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1615
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1616
                    }
1617
                }
1618
            }
1619
        }
1620
    }
1621

    
1622
    return 0;
1623
 fail_decode:
1624
    return -1;
1625
}
1626

    
1627
static void print_sdp(AVFormatContext **avc, int n)
1628
{
1629
    char sdp[2048];
1630

    
1631
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1632
    printf("SDP:\n%s\n", sdp);
1633
    fflush(stdout);
1634
}
1635

    
1636
static int stream_index_from_inputs(AVFormatContext **input_files,
1637
                                    int nb_input_files,
1638
                                    AVInputFile *file_table,
1639
                                    AVInputStream **ist_table,
1640
                                    enum CodecType type,
1641
                                    int programid)
1642
{
1643
    int p, q, z;
1644
    for(z=0; z<nb_input_files; z++) {
1645
        AVFormatContext *ic = input_files[z];
1646
        for(p=0; p<ic->nb_programs; p++) {
1647
            AVProgram *program = ic->programs[p];
1648
            if(program->id != programid)
1649
                continue;
1650
            for(q=0; q<program->nb_stream_indexes; q++) {
1651
                int sidx = program->stream_index[q];
1652
                int ris = file_table[z].ist_index + sidx;
1653
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1654
                    return ris;
1655
            }
1656
        }
1657
    }
1658

    
1659
    return -1;
1660
}
1661

    
1662
/*
1663
 * The following code is the main loop of the file converter
1664
 */
1665
static int av_encode(AVFormatContext **output_files,
1666
                     int nb_output_files,
1667
                     AVFormatContext **input_files,
1668
                     int nb_input_files,
1669
                     AVStreamMap *stream_maps, int nb_stream_maps)
1670
{
1671
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1672
    AVFormatContext *is, *os;
1673
    AVCodecContext *codec, *icodec;
1674
    AVOutputStream *ost, **ost_table = NULL;
1675
    AVInputStream *ist, **ist_table = NULL;
1676
    AVInputFile *file_table;
1677
    char error[1024];
1678
    int key;
1679
    int want_sdp = 1;
1680
    uint8_t no_packet[MAX_FILES]={0};
1681
    int no_packet_count=0;
1682

    
1683
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1684
    if (!file_table)
1685
        goto fail;
1686

    
1687
    /* input stream init */
1688
    j = 0;
1689
    for(i=0;i<nb_input_files;i++) {
1690
        is = input_files[i];
1691
        file_table[i].ist_index = j;
1692
        file_table[i].nb_streams = is->nb_streams;
1693
        j += is->nb_streams;
1694
    }
1695
    nb_istreams = j;
1696

    
1697
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1698
    if (!ist_table)
1699
        goto fail;
1700

    
1701
    for(i=0;i<nb_istreams;i++) {
1702
        ist = av_mallocz(sizeof(AVInputStream));
1703
        if (!ist)
1704
            goto fail;
1705
        ist_table[i] = ist;
1706
    }
1707
    j = 0;
1708
    for(i=0;i<nb_input_files;i++) {
1709
        is = input_files[i];
1710
        for(k=0;k<is->nb_streams;k++) {
1711
            ist = ist_table[j++];
1712
            ist->st = is->streams[k];
1713
            ist->file_index = i;
1714
            ist->index = k;
1715
            ist->discard = 1; /* the stream is discarded by default
1716
                                 (changed later) */
1717

    
1718
            if (rate_emu) {
1719
                ist->start = av_gettime();
1720
            }
1721
        }
1722
    }
1723

    
1724
    /* output stream init */
1725
    nb_ostreams = 0;
1726
    for(i=0;i<nb_output_files;i++) {
1727
        os = output_files[i];
1728
        if (!os->nb_streams) {
1729
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1730
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1731
            av_exit(1);
1732
        }
1733
        nb_ostreams += os->nb_streams;
1734
    }
1735
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1736
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1737
        av_exit(1);
1738
    }
1739

    
1740
    /* Sanity check the mapping args -- do the input files & streams exist? */
1741
    for(i=0;i<nb_stream_maps;i++) {
1742
        int fi = stream_maps[i].file_index;
1743
        int si = stream_maps[i].stream_index;
1744

    
1745
        if (fi < 0 || fi > nb_input_files - 1 ||
1746
            si < 0 || si > file_table[fi].nb_streams - 1) {
1747
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1748
            av_exit(1);
1749
        }
1750
        fi = stream_maps[i].sync_file_index;
1751
        si = stream_maps[i].sync_stream_index;
1752
        if (fi < 0 || fi > nb_input_files - 1 ||
1753
            si < 0 || si > file_table[fi].nb_streams - 1) {
1754
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1755
            av_exit(1);
1756
        }
1757
    }
1758

    
1759
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1760
    if (!ost_table)
1761
        goto fail;
1762
    for(i=0;i<nb_ostreams;i++) {
1763
        ost = av_mallocz(sizeof(AVOutputStream));
1764
        if (!ost)
1765
            goto fail;
1766
        ost_table[i] = ost;
1767
    }
1768

    
1769
    n = 0;
1770
    for(k=0;k<nb_output_files;k++) {
1771
        os = output_files[k];
1772
        for(i=0;i<os->nb_streams;i++,n++) {
1773
            int found;
1774
            ost = ost_table[n];
1775
            ost->file_index = k;
1776
            ost->index = i;
1777
            ost->st = os->streams[i];
1778
            if (nb_stream_maps > 0) {
1779
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1780
                    stream_maps[n].stream_index;
1781

    
1782
                /* Sanity check that the stream types match */
1783
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1784
                    int i= ost->file_index;
1785
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1786
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1787
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1788
                        ost->file_index, ost->index);
1789
                    av_exit(1);
1790
                }
1791

    
1792
            } else {
1793
                if(opt_programid) {
1794
                    found = 0;
1795
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1796
                    if(j != -1) {
1797
                        ost->source_index = j;
1798
                        found = 1;
1799
                    }
1800
                } else {
1801
                    /* get corresponding input stream index : we select the first one with the right type */
1802
                    found = 0;
1803
                    for(j=0;j<nb_istreams;j++) {
1804
                        ist = ist_table[j];
1805
                        if (ist->discard &&
1806
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1807
                            ost->source_index = j;
1808
                            found = 1;
1809
                            break;
1810
                        }
1811
                    }
1812
                }
1813

    
1814
                if (!found) {
1815
                    if(! opt_programid) {
1816
                        /* try again and reuse existing stream */
1817
                        for(j=0;j<nb_istreams;j++) {
1818
                            ist = ist_table[j];
1819
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1820
                                ost->source_index = j;
1821
                                found = 1;
1822
                            }
1823
                        }
1824
                    }
1825
                    if (!found) {
1826
                        int i= ost->file_index;
1827
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1828
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1829
                                ost->file_index, ost->index);
1830
                        av_exit(1);
1831
                    }
1832
                }
1833
            }
1834
            ist = ist_table[ost->source_index];
1835
            ist->discard = 0;
1836
            ost->sync_ist = (nb_stream_maps > 0) ?
1837
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1838
                         stream_maps[n].sync_stream_index] : ist;
1839
        }
1840
    }
1841

    
1842
    /* for each output stream, we compute the right encoding parameters */
1843
    for(i=0;i<nb_ostreams;i++) {
1844
        AVMetadataTag *lang;
1845
        ost = ost_table[i];
1846
        os = output_files[ost->file_index];
1847
        ist = ist_table[ost->source_index];
1848

    
1849
        codec = ost->st->codec;
1850
        icodec = ist->st->codec;
1851

    
1852
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1853
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1854
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1855

    
1856
        ost->st->disposition = ist->st->disposition;
1857
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1858
        codec->chroma_sample_location = icodec->chroma_sample_location;
1859

    
1860
        if (ost->st->stream_copy) {
1861
            /* if stream_copy is selected, no need to decode or encode */
1862
            codec->codec_id = icodec->codec_id;
1863
            codec->codec_type = icodec->codec_type;
1864

    
1865
            if(!codec->codec_tag){
1866
                if(   !os->oformat->codec_tag
1867
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1868
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1869
                    codec->codec_tag = icodec->codec_tag;
1870
            }
1871

    
1872
            codec->bit_rate = icodec->bit_rate;
1873
            codec->extradata= icodec->extradata;
1874
            codec->extradata_size= icodec->extradata_size;
1875
            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){
1876
                codec->time_base = icodec->time_base;
1877
                codec->time_base.num *= icodec->ticks_per_frame;
1878
            }else
1879
                codec->time_base = ist->st->time_base;
1880
            switch(codec->codec_type) {
1881
            case CODEC_TYPE_AUDIO:
1882
                if(audio_volume != 256) {
1883
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1884
                    av_exit(1);
1885
                }
1886
                codec->channel_layout = icodec->channel_layout;
1887
                codec->sample_rate = icodec->sample_rate;
1888
                codec->channels = icodec->channels;
1889
                codec->frame_size = icodec->frame_size;
1890
                codec->block_align= icodec->block_align;
1891
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1892
                    codec->block_align= 0;
1893
                if(codec->codec_id == CODEC_ID_AC3)
1894
                    codec->block_align= 0;
1895
                break;
1896
            case CODEC_TYPE_VIDEO:
1897
                codec->pix_fmt = icodec->pix_fmt;
1898
                codec->width = icodec->width;
1899
                codec->height = icodec->height;
1900
                codec->has_b_frames = icodec->has_b_frames;
1901
                break;
1902
            case CODEC_TYPE_SUBTITLE:
1903
                codec->width = icodec->width;
1904
                codec->height = icodec->height;
1905
                break;
1906
            default:
1907
                abort();
1908
            }
1909
        } else {
1910
            switch(codec->codec_type) {
1911
            case CODEC_TYPE_AUDIO:
1912
                ost->fifo= av_fifo_alloc(1024);
1913
                if(!ost->fifo)
1914
                    goto fail;
1915
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1916
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1917
                icodec->request_channels = codec->channels;
1918
                ist->decoding_needed = 1;
1919
                ost->encoding_needed = 1;
1920
                break;
1921
            case CODEC_TYPE_VIDEO:
1922
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1923
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1924
                    av_exit(1);
1925
                }
1926
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1927
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1928
                ost->video_resample = ((codec->width != icodec->width -
1929
                                (frame_leftBand + frame_rightBand) +
1930
                                (frame_padleft + frame_padright)) ||
1931
                        (codec->height != icodec->height -
1932
                                (frame_topBand  + frame_bottomBand) +
1933
                                (frame_padtop + frame_padbottom)) ||
1934
                        (codec->pix_fmt != icodec->pix_fmt));
1935
                if (ost->video_crop) {
1936
                    ost->topBand    = ost->original_topBand    = frame_topBand;
1937
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1938
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
1939
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
1940
                }
1941
                if (ost->video_pad) {
1942
                    ost->padtop = frame_padtop;
1943
                    ost->padleft = frame_padleft;
1944
                    ost->padbottom = frame_padbottom;
1945
                    ost->padright = frame_padright;
1946
                    if (!ost->video_resample) {
1947
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1948
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1949
                                         codec->width, codec->height))
1950
                            goto fail;
1951
                    }
1952
                }
1953
                if (ost->video_resample) {
1954
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1955
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1956
                                         codec->width, codec->height)) {
1957
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1958
                        av_exit(1);
1959
                    }
1960
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1961
                    ost->img_resample_ctx = sws_getContext(
1962
                            icodec->width - (frame_leftBand + frame_rightBand),
1963
                            icodec->height - (frame_topBand + frame_bottomBand),
1964
                            icodec->pix_fmt,
1965
                            codec->width - (frame_padleft + frame_padright),
1966
                            codec->height - (frame_padtop + frame_padbottom),
1967
                            codec->pix_fmt,
1968
                            sws_flags, NULL, NULL, NULL);
1969
                    if (ost->img_resample_ctx == NULL) {
1970
                        fprintf(stderr, "Cannot get resampling context\n");
1971
                        av_exit(1);
1972
                    }
1973

    
1974
                    ost->original_height = icodec->height;
1975
                    ost->original_width  = icodec->width;
1976

    
1977
                    codec->bits_per_raw_sample= 0;
1978
                }
1979
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
1980
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
1981
                ost->resample_pix_fmt= icodec->pix_fmt;
1982
                ost->encoding_needed = 1;
1983
                ist->decoding_needed = 1;
1984
                break;
1985
            case CODEC_TYPE_SUBTITLE:
1986
                ost->encoding_needed = 1;
1987
                ist->decoding_needed = 1;
1988
                break;
1989
            default:
1990
                abort();
1991
                break;
1992
            }
1993
            /* two pass mode */
1994
            if (ost->encoding_needed &&
1995
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1996
                char logfilename[1024];
1997
                FILE *f;
1998
                int size;
1999
                char *logbuffer;
2000

    
2001
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2002
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2003
                         i);
2004
                if (codec->flags & CODEC_FLAG_PASS1) {
2005
                    f = fopen(logfilename, "w");
2006
                    if (!f) {
2007
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2008
                        av_exit(1);
2009
                    }
2010
                    ost->logfile = f;
2011
                } else {
2012
                    /* read the log file */
2013
                    f = fopen(logfilename, "r");
2014
                    if (!f) {
2015
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2016
                        av_exit(1);
2017
                    }
2018
                    fseek(f, 0, SEEK_END);
2019
                    size = ftell(f);
2020
                    fseek(f, 0, SEEK_SET);
2021
                    logbuffer = av_malloc(size + 1);
2022
                    if (!logbuffer) {
2023
                        fprintf(stderr, "Could not allocate log buffer\n");
2024
                        av_exit(1);
2025
                    }
2026
                    size = fread(logbuffer, 1, size, f);
2027
                    fclose(f);
2028
                    logbuffer[size] = '\0';
2029
                    codec->stats_in = logbuffer;
2030
                }
2031
            }
2032
        }
2033
        if(codec->codec_type == CODEC_TYPE_VIDEO){
2034
            int size= codec->width * codec->height;
2035
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2036
        }
2037
    }
2038

    
2039
    if (!bit_buffer)
2040
        bit_buffer = av_malloc(bit_buffer_size);
2041
    if (!bit_buffer) {
2042
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2043
                bit_buffer_size);
2044
        ret = AVERROR(ENOMEM);
2045
        goto fail;
2046
    }
2047

    
2048
    /* open each encoder */
2049
    for(i=0;i<nb_ostreams;i++) {
2050
        ost = ost_table[i];
2051
        if (ost->encoding_needed) {
2052
            AVCodec *codec = output_codecs[i];
2053
            if (!codec)
2054
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2055
            if (!codec) {
2056
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2057
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2058
                ret = AVERROR(EINVAL);
2059
                goto dump_format;
2060
            }
2061
            if (avcodec_open(ost->st->codec, codec) < 0) {
2062
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2063
                        ost->file_index, ost->index);
2064
                ret = AVERROR(EINVAL);
2065
                goto dump_format;
2066
            }
2067
            extra_size += ost->st->codec->extradata_size;
2068
        }
2069
    }
2070

    
2071
    /* open each decoder */
2072
    for(i=0;i<nb_istreams;i++) {
2073
        ist = ist_table[i];
2074
        if (ist->decoding_needed) {
2075
            AVCodec *codec = input_codecs[i];
2076
            if (!codec)
2077
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2078
            if (!codec) {
2079
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2080
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2081
                ret = AVERROR(EINVAL);
2082
                goto dump_format;
2083
            }
2084
            if (avcodec_open(ist->st->codec, codec) < 0) {
2085
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2086
                        ist->file_index, ist->index);
2087
                ret = AVERROR(EINVAL);
2088
                goto dump_format;
2089
            }
2090
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2091
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2092
        }
2093
    }
2094

    
2095
    /* init pts */
2096
    for(i=0;i<nb_istreams;i++) {
2097
        ist = ist_table[i];
2098
        ist->pts = 0;
2099
        ist->next_pts = AV_NOPTS_VALUE;
2100
        ist->is_start = 1;
2101
    }
2102

    
2103
    /* set meta data information from input file if required */
2104
    for (i=0;i<nb_meta_data_maps;i++) {
2105
        AVFormatContext *out_file;
2106
        AVFormatContext *in_file;
2107
        AVMetadataTag *mtag;
2108

    
2109
        int out_file_index = meta_data_maps[i].out_file;
2110
        int in_file_index = meta_data_maps[i].in_file;
2111
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2112
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2113
                     out_file_index, out_file_index, in_file_index);
2114
            ret = AVERROR(EINVAL);
2115
            goto dump_format;
2116
        }
2117
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2118
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2119
                     in_file_index, out_file_index, in_file_index);
2120
            ret = AVERROR(EINVAL);
2121
            goto dump_format;
2122
        }
2123

    
2124
        out_file = output_files[out_file_index];
2125
        in_file = input_files[in_file_index];
2126

    
2127

    
2128
        mtag=NULL;
2129
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2130
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2131
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2132
                                    in_file->iformat->metadata_conv);
2133
    }
2134

    
2135
    /* open files and write file headers */
2136
    for(i=0;i<nb_output_files;i++) {
2137
        os = output_files[i];
2138
        if (av_write_header(os) < 0) {
2139
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2140
            ret = AVERROR(EINVAL);
2141
            goto dump_format;
2142
        }
2143
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2144
            want_sdp = 0;
2145
        }
2146
    }
2147

    
2148
 dump_format:
2149
    /* dump the file output parameters - cannot be done before in case
2150
       of stream copy */
2151
    for(i=0;i<nb_output_files;i++) {
2152
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2153
    }
2154

    
2155
    /* dump the stream mapping */
2156
    if (verbose >= 0) {
2157
        fprintf(stderr, "Stream mapping:\n");
2158
        for(i=0;i<nb_ostreams;i++) {
2159
            ost = ost_table[i];
2160
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2161
                    ist_table[ost->source_index]->file_index,
2162
                    ist_table[ost->source_index]->index,
2163
                    ost->file_index,
2164
                    ost->index);
2165
            if (ost->sync_ist != ist_table[ost->source_index])
2166
                fprintf(stderr, " [sync #%d.%d]",
2167
                        ost->sync_ist->file_index,
2168
                        ost->sync_ist->index);
2169
            fprintf(stderr, "\n");
2170
        }
2171
    }
2172

    
2173
    if (ret) {
2174
        fprintf(stderr, "%s\n", error);
2175
        goto fail;
2176
    }
2177

    
2178
    if (want_sdp) {
2179
        print_sdp(output_files, nb_output_files);
2180
    }
2181

    
2182
    if (!using_stdin && verbose >= 0) {
2183
        fprintf(stderr, "Press [q] to stop encoding\n");
2184
        url_set_interrupt_cb(decode_interrupt_cb);
2185
    }
2186
    term_init();
2187

    
2188
    timer_start = av_gettime();
2189

    
2190
    for(; received_sigterm == 0;) {
2191
        int file_index, ist_index;
2192
        AVPacket pkt;
2193
        double ipts_min;
2194
        double opts_min;
2195

    
2196
    redo:
2197
        ipts_min= 1e100;
2198
        opts_min= 1e100;
2199
        /* if 'q' pressed, exits */
2200
        if (!using_stdin) {
2201
            if (q_pressed)
2202
                break;
2203
            /* read_key() returns 0 on EOF */
2204
            key = read_key();
2205
            if (key == 'q')
2206
                break;
2207
        }
2208

    
2209
        /* select the stream that we must read now by looking at the
2210
           smallest output pts */
2211
        file_index = -1;
2212
        for(i=0;i<nb_ostreams;i++) {
2213
            double ipts, opts;
2214
            ost = ost_table[i];
2215
            os = output_files[ost->file_index];
2216
            ist = ist_table[ost->source_index];
2217
            if(no_packet[ist->file_index])
2218
                continue;
2219
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2220
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2221
            else
2222
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2223
            ipts = (double)ist->pts;
2224
            if (!file_table[ist->file_index].eof_reached){
2225
                if(ipts < ipts_min) {
2226
                    ipts_min = ipts;
2227
                    if(input_sync ) file_index = ist->file_index;
2228
                }
2229
                if(opts < opts_min) {
2230
                    opts_min = opts;
2231
                    if(!input_sync) file_index = ist->file_index;
2232
                }
2233
            }
2234
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2235
                file_index= -1;
2236
                break;
2237
            }
2238
        }
2239
        /* if none, if is finished */
2240
        if (file_index < 0) {
2241
            if(no_packet_count){
2242
                no_packet_count=0;
2243
                memset(no_packet, 0, sizeof(no_packet));
2244
                usleep(10000);
2245
                continue;
2246
            }
2247
            break;
2248
        }
2249

    
2250
        /* finish if recording time exhausted */
2251
        if (opts_min >= (recording_time / 1000000.0))
2252
            break;
2253

    
2254
        /* finish if limit size exhausted */
2255
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2256
            break;
2257

    
2258
        /* read a frame from it and output it in the fifo */
2259
        is = input_files[file_index];
2260
        ret= av_read_frame(is, &pkt);
2261
        if(ret == AVERROR(EAGAIN)){
2262
            no_packet[file_index]=1;
2263
            no_packet_count++;
2264
            continue;
2265
        }
2266
        if (ret < 0) {
2267
            file_table[file_index].eof_reached = 1;
2268
            if (opt_shortest)
2269
                break;
2270
            else
2271
                continue;
2272
        }
2273

    
2274
        no_packet_count=0;
2275
        memset(no_packet, 0, sizeof(no_packet));
2276

    
2277
        if (do_pkt_dump) {
2278
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2279
        }
2280
        /* the following test is needed in case new streams appear
2281
           dynamically in stream : we ignore them */
2282
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2283
            goto discard_packet;
2284
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2285
        ist = ist_table[ist_index];
2286
        if (ist->discard)
2287
            goto discard_packet;
2288

    
2289
        if (pkt.dts != AV_NOPTS_VALUE)
2290
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2291
        if (pkt.pts != AV_NOPTS_VALUE)
2292
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2293

    
2294
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2295
            if(pkt.pts != AV_NOPTS_VALUE)
2296
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2297
            if(pkt.dts != AV_NOPTS_VALUE)
2298
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2299
        }
2300

    
2301
//        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);
2302
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2303
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2304
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2305
            int64_t delta= pkt_dts - ist->next_pts;
2306
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2307
                input_files_ts_offset[ist->file_index]-= delta;
2308
                if (verbose > 2)
2309
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2310
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2311
                if(pkt.pts != AV_NOPTS_VALUE)
2312
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2313
            }
2314
        }
2315

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

    
2319
            if (verbose >= 0)
2320
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2321
                        ist->file_index, ist->index);
2322
            if (exit_on_error)
2323
                av_exit(1);
2324
            av_free_packet(&pkt);
2325
            goto redo;
2326
        }
2327

    
2328
    discard_packet:
2329
        av_free_packet(&pkt);
2330

    
2331
        /* dump report by using the output first video and audio streams */
2332
        print_report(output_files, ost_table, nb_ostreams, 0);
2333
    }
2334

    
2335
    /* at the end of stream, we must flush the decoder buffers */
2336
    for(i=0;i<nb_istreams;i++) {
2337
        ist = ist_table[i];
2338
        if (ist->decoding_needed) {
2339
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2340
        }
2341
    }
2342

    
2343
    term_exit();
2344

    
2345
    /* write the trailer if needed and close file */
2346
    for(i=0;i<nb_output_files;i++) {
2347
        os = output_files[i];
2348
        av_write_trailer(os);
2349
    }
2350

    
2351
    /* dump report by using the first video and audio streams */
2352
    print_report(output_files, ost_table, nb_ostreams, 1);
2353

    
2354
    /* close each encoder */
2355
    for(i=0;i<nb_ostreams;i++) {
2356
        ost = ost_table[i];
2357
        if (ost->encoding_needed) {
2358
            av_freep(&ost->st->codec->stats_in);
2359
            avcodec_close(ost->st->codec);
2360
        }
2361
    }
2362

    
2363
    /* close each decoder */
2364
    for(i=0;i<nb_istreams;i++) {
2365
        ist = ist_table[i];
2366
        if (ist->decoding_needed) {
2367
            avcodec_close(ist->st->codec);
2368
        }
2369
    }
2370

    
2371
    /* finished ! */
2372
    ret = 0;
2373

    
2374
 fail:
2375
    av_freep(&bit_buffer);
2376
    av_free(file_table);
2377

    
2378
    if (ist_table) {
2379
        for(i=0;i<nb_istreams;i++) {
2380
            ist = ist_table[i];
2381
            av_free(ist);
2382
        }
2383
        av_free(ist_table);
2384
    }
2385
    if (ost_table) {
2386
        for(i=0;i<nb_ostreams;i++) {
2387
            ost = ost_table[i];
2388
            if (ost) {
2389
                if (ost->logfile) {
2390
                    fclose(ost->logfile);
2391
                    ost->logfile = NULL;
2392
                }
2393
                av_fifo_free(ost->fifo); /* works even if fifo is not
2394
                                             initialized but set to zero */
2395
                av_free(ost->pict_tmp.data[0]);
2396
                if (ost->video_resample)
2397
                    sws_freeContext(ost->img_resample_ctx);
2398
                if (ost->resample)
2399
                    audio_resample_close(ost->resample);
2400
                if (ost->reformat_ctx)
2401
                    av_audio_convert_free(ost->reformat_ctx);
2402
                av_free(ost);
2403
            }
2404
        }
2405
        av_free(ost_table);
2406
    }
2407
    return ret;
2408
}
2409

    
2410
static void opt_format(const char *arg)
2411
{
2412
    /* compatibility stuff for pgmyuv */
2413
    if (!strcmp(arg, "pgmyuv")) {
2414
        pgmyuv_compatibility_hack=1;
2415
//        opt_image_format(arg);
2416
        arg = "image2";
2417
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2418
    }
2419

    
2420
    last_asked_format = arg;
2421
}
2422

    
2423
static void opt_video_rc_override_string(const char *arg)
2424
{
2425
    video_rc_override_string = arg;
2426
}
2427

    
2428
static int opt_me_threshold(const char *opt, const char *arg)
2429
{
2430
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2431
    return 0;
2432
}
2433

    
2434
static int opt_verbose(const char *opt, const char *arg)
2435
{
2436
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2437
    return 0;
2438
}
2439

    
2440
static int opt_frame_rate(const char *opt, const char *arg)
2441
{
2442
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2443
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2444
        av_exit(1);
2445
    }
2446
    return 0;
2447
}
2448

    
2449
static int opt_bitrate(const char *opt, const char *arg)
2450
{
2451
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2452

    
2453
    opt_default(opt, arg);
2454

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

    
2458
    return 0;
2459
}
2460

    
2461
static void opt_frame_crop_top(const char *arg)
2462
{
2463
    frame_topBand = atoi(arg);
2464
    if (frame_topBand < 0) {
2465
        fprintf(stderr, "Incorrect top crop size\n");
2466
        av_exit(1);
2467
    }
2468
    if ((frame_topBand) >= frame_height){
2469
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2470
        av_exit(1);
2471
    }
2472
    frame_height -= frame_topBand;
2473
}
2474

    
2475
static void opt_frame_crop_bottom(const char *arg)
2476
{
2477
    frame_bottomBand = atoi(arg);
2478
    if (frame_bottomBand < 0) {
2479
        fprintf(stderr, "Incorrect bottom crop size\n");
2480
        av_exit(1);
2481
    }
2482
    if ((frame_bottomBand) >= frame_height){
2483
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2484
        av_exit(1);
2485
    }
2486
    frame_height -= frame_bottomBand;
2487
}
2488

    
2489
static void opt_frame_crop_left(const char *arg)
2490
{
2491
    frame_leftBand = atoi(arg);
2492
    if (frame_leftBand < 0) {
2493
        fprintf(stderr, "Incorrect left crop size\n");
2494
        av_exit(1);
2495
    }
2496
    if ((frame_leftBand) >= frame_width){
2497
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2498
        av_exit(1);
2499
    }
2500
    frame_width -= frame_leftBand;
2501
}
2502

    
2503
static void opt_frame_crop_right(const char *arg)
2504
{
2505
    frame_rightBand = atoi(arg);
2506
    if (frame_rightBand < 0) {
2507
        fprintf(stderr, "Incorrect right crop size\n");
2508
        av_exit(1);
2509
    }
2510
    if ((frame_rightBand) >= frame_width){
2511
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2512
        av_exit(1);
2513
    }
2514
    frame_width -= frame_rightBand;
2515
}
2516

    
2517
static void opt_frame_size(const char *arg)
2518
{
2519
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2520
        fprintf(stderr, "Incorrect frame size\n");
2521
        av_exit(1);
2522
    }
2523
}
2524

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

    
2531
    r = (rgb >> 16);
2532
    g = ((rgb >> 8) & 255);
2533
    b = (rgb & 255);
2534

    
2535
    padcolor[0] = RGB_TO_Y(r,g,b);
2536
    padcolor[1] = RGB_TO_U(r,g,b,0);
2537
    padcolor[2] = RGB_TO_V(r,g,b,0);
2538
}
2539

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

    
2549
static void opt_frame_pad_bottom(const char *arg)
2550
{
2551
    frame_padbottom = atoi(arg);
2552
    if (frame_padbottom < 0) {
2553
        fprintf(stderr, "Incorrect bottom pad size\n");
2554
        av_exit(1);
2555
    }
2556
}
2557

    
2558

    
2559
static void opt_frame_pad_left(const char *arg)
2560
{
2561
    frame_padleft = atoi(arg);
2562
    if (frame_padleft < 0) {
2563
        fprintf(stderr, "Incorrect left pad size\n");
2564
        av_exit(1);
2565
    }
2566
}
2567

    
2568

    
2569
static void opt_frame_pad_right(const char *arg)
2570
{
2571
    frame_padright = atoi(arg);
2572
    if (frame_padright < 0) {
2573
        fprintf(stderr, "Incorrect right pad size\n");
2574
        av_exit(1);
2575
    }
2576
}
2577

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

    
2592
static void opt_frame_aspect_ratio(const char *arg)
2593
{
2594
    int x = 0, y = 0;
2595
    double ar = 0;
2596
    const char *p;
2597
    char *end;
2598

    
2599
    p = strchr(arg, ':');
2600
    if (p) {
2601
        x = strtol(arg, &end, 10);
2602
        if (end == p)
2603
            y = strtol(end+1, &end, 10);
2604
        if (x > 0 && y > 0)
2605
            ar = (double)x / (double)y;
2606
    } else
2607
        ar = strtod(arg, NULL);
2608

    
2609
    if (!ar) {
2610
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2611
        av_exit(1);
2612
    }
2613
    frame_aspect_ratio = ar;
2614
}
2615

    
2616
static int opt_metadata(const char *opt, const char *arg)
2617
{
2618
    char *mid= strchr(arg, '=');
2619

    
2620
    if(!mid){
2621
        fprintf(stderr, "Missing =\n");
2622
        av_exit(1);
2623
    }
2624
    *mid++= 0;
2625

    
2626
    metadata_count++;
2627
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2628
    metadata[metadata_count-1].key  = av_strdup(arg);
2629
    metadata[metadata_count-1].value= av_strdup(mid);
2630

    
2631
    return 0;
2632
}
2633

    
2634
static void opt_qscale(const char *arg)
2635
{
2636
    video_qscale = atof(arg);
2637
    if (video_qscale <= 0 ||
2638
        video_qscale > 255) {
2639
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2640
        av_exit(1);
2641
    }
2642
}
2643

    
2644
static void opt_top_field_first(const char *arg)
2645
{
2646
    top_field_first= atoi(arg);
2647
}
2648

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

    
2659
static void opt_audio_sample_fmt(const char *arg)
2660
{
2661
    if (strcmp(arg, "list"))
2662
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2663
    else {
2664
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2665
        av_exit(0);
2666
    }
2667
}
2668

    
2669
static int opt_audio_rate(const char *opt, const char *arg)
2670
{
2671
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2672
    return 0;
2673
}
2674

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

    
2681
static void opt_video_channel(const char *arg)
2682
{
2683
    video_channel = strtol(arg, NULL, 0);
2684
}
2685

    
2686
static void opt_video_standard(const char *arg)
2687
{
2688
    video_standard = av_strdup(arg);
2689
}
2690

    
2691
static void opt_codec(int *pstream_copy, char **pcodec_name,
2692
                      int codec_type, const char *arg)
2693
{
2694
    av_freep(pcodec_name);
2695
    if (!strcmp(arg, "copy")) {
2696
        *pstream_copy = 1;
2697
    } else {
2698
        *pcodec_name = av_strdup(arg);
2699
    }
2700
}
2701

    
2702
static void opt_audio_codec(const char *arg)
2703
{
2704
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2705
}
2706

    
2707
static void opt_audio_tag(const char *arg)
2708
{
2709
    char *tail;
2710
    audio_codec_tag= strtol(arg, &tail, 0);
2711

    
2712
    if(!tail || *tail)
2713
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2714
}
2715

    
2716
static void opt_video_tag(const char *arg)
2717
{
2718
    char *tail;
2719
    video_codec_tag= strtol(arg, &tail, 0);
2720

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

    
2725
static void opt_video_codec(const char *arg)
2726
{
2727
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2728
}
2729

    
2730
static void opt_subtitle_codec(const char *arg)
2731
{
2732
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2733
}
2734

    
2735
static void opt_subtitle_tag(const char *arg)
2736
{
2737
    char *tail;
2738
    subtitle_codec_tag= strtol(arg, &tail, 0);
2739

    
2740
    if(!tail || *tail)
2741
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2742
}
2743

    
2744
static void opt_map(const char *arg)
2745
{
2746
    AVStreamMap *m;
2747
    char *p;
2748

    
2749
    m = &stream_maps[nb_stream_maps++];
2750

    
2751
    m->file_index = strtol(arg, &p, 0);
2752
    if (*p)
2753
        p++;
2754

    
2755
    m->stream_index = strtol(p, &p, 0);
2756
    if (*p) {
2757
        p++;
2758
        m->sync_file_index = strtol(p, &p, 0);
2759
        if (*p)
2760
            p++;
2761
        m->sync_stream_index = strtol(p, &p, 0);
2762
    } else {
2763
        m->sync_file_index = m->file_index;
2764
        m->sync_stream_index = m->stream_index;
2765
    }
2766
}
2767

    
2768
static void opt_map_meta_data(const char *arg)
2769
{
2770
    AVMetaDataMap *m;
2771
    char *p;
2772

    
2773
    m = &meta_data_maps[nb_meta_data_maps++];
2774

    
2775
    m->out_file = strtol(arg, &p, 0);
2776
    if (*p)
2777
        p++;
2778

    
2779
    m->in_file = strtol(p, &p, 0);
2780
}
2781

    
2782
static void opt_input_ts_scale(const char *arg)
2783
{
2784
    unsigned int stream;
2785
    double scale;
2786
    char *p;
2787

    
2788
    stream = strtol(arg, &p, 0);
2789
    if (*p)
2790
        p++;
2791
    scale= strtod(p, &p);
2792

    
2793
    if(stream >= MAX_STREAMS)
2794
        av_exit(1);
2795

    
2796
    input_files_ts_scale[nb_input_files][stream]= scale;
2797
}
2798

    
2799
static int opt_recording_time(const char *opt, const char *arg)
2800
{
2801
    recording_time = parse_time_or_die(opt, arg, 1);
2802
    return 0;
2803
}
2804

    
2805
static int opt_start_time(const char *opt, const char *arg)
2806
{
2807
    start_time = parse_time_or_die(opt, arg, 1);
2808
    return 0;
2809
}
2810

    
2811
static int opt_rec_timestamp(const char *opt, const char *arg)
2812
{
2813
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2814
    return 0;
2815
}
2816

    
2817
static int opt_input_ts_offset(const char *opt, const char *arg)
2818
{
2819
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2820
    return 0;
2821
}
2822

    
2823
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2824
{
2825
    const char *codec_string = encoder ? "encoder" : "decoder";
2826
    AVCodec *codec;
2827

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

    
2844
static void opt_input_file(const char *filename)
2845
{
2846
    AVFormatContext *ic;
2847
    AVFormatParameters params, *ap = &params;
2848
    AVInputFormat *file_iformat = NULL;
2849
    int err, i, ret, rfps, rfps_base;
2850
    int64_t timestamp;
2851

    
2852
    if (last_asked_format) {
2853
        file_iformat = av_find_input_format(last_asked_format);
2854
        last_asked_format = NULL;
2855
    }
2856

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

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

    
2863
    /* get default parameters from command line */
2864
    ic = avformat_alloc_context();
2865
    if (!ic) {
2866
        print_error(filename, AVERROR(ENOMEM));
2867
        av_exit(1);
2868
    }
2869

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

    
2887
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2888

    
2889
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2890
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2891
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2892
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2893

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

    
2907
    ic->loop_input = loop_input;
2908

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

    
2917
    timestamp = start_time;
2918
    /* add the stream start time */
2919
    if (ic->start_time != AV_NOPTS_VALUE)
2920
        timestamp += ic->start_time;
2921

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

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

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

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

    
2976
                    (float)rfps / rfps_base, rfps, rfps_base);
2977
            }
2978
            /* update the current frame rate to match the stream frame rate */
2979
            frame_rate.num = rfps;
2980
            frame_rate.den = rfps_base;
2981

    
2982
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2983
            if(video_disable)
2984
                st->discard= AVDISCARD_ALL;
2985
            else if(video_discard)
2986
                st->discard= video_discard;
2987
            break;
2988
        case CODEC_TYPE_DATA:
2989
            break;
2990
        case CODEC_TYPE_SUBTITLE:
2991
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2992
            if(subtitle_disable)
2993
                st->discard = AVDISCARD_ALL;
2994
            break;
2995
        case CODEC_TYPE_ATTACHMENT:
2996
        case CODEC_TYPE_UNKNOWN:
2997
            nb_icodecs++;
2998
            break;
2999
        default:
3000
            abort();
3001
        }
3002
    }
3003

    
3004
    input_files[nb_input_files] = ic;
3005
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3006
    /* dump the file content */
3007
    if (verbose >= 0)
3008
        dump_format(ic, nb_input_files, filename, 0);
3009

    
3010
    nb_input_files++;
3011

    
3012
    video_channel = 0;
3013

    
3014
    av_freep(&video_codec_name);
3015
    av_freep(&audio_codec_name);
3016
    av_freep(&subtitle_codec_name);
3017
}
3018

    
3019
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3020
                                         int *has_subtitle_ptr)
3021
{
3022
    int has_video, has_audio, has_subtitle, i, j;
3023
    AVFormatContext *ic;
3024

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

    
3056
static void new_video_stream(AVFormatContext *oc)
3057
{
3058
    AVStream *st;
3059
    AVCodecContext *video_enc;
3060
    enum CodecID codec_id;
3061

    
3062
    st = av_new_stream(oc, oc->nb_streams);
3063
    if (!st) {
3064
        fprintf(stderr, "Could not alloc stream\n");
3065
        av_exit(1);
3066
    }
3067
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3068
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3069
    video_bitstream_filters= NULL;
3070

    
3071
    avcodec_thread_init(st->codec, thread_count);
3072

    
3073
    video_enc = st->codec;
3074

    
3075
    if(video_codec_tag)
3076
        video_enc->codec_tag= video_codec_tag;
3077

    
3078
    if(   (video_global_header&1)
3079
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3080
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3081
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3082
    }
3083
    if(video_global_header&2){
3084
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3085
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3086
    }
3087

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

    
3099
        if (video_codec_name) {
3100
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3101
            codec = avcodec_find_encoder_by_name(video_codec_name);
3102
            output_codecs[nb_ocodecs] = codec;
3103
        } else {
3104
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3105
            codec = avcodec_find_encoder(codec_id);
3106
        }
3107

    
3108
        video_enc->codec_id = codec_id;
3109

    
3110
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3111

    
3112
        if (codec && codec->supported_framerates && !force_fps)
3113
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3114
        video_enc->time_base.den = fps.num;
3115
        video_enc->time_base.num = fps.den;
3116

    
3117
        video_enc->width = frame_width + frame_padright + frame_padleft;
3118
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3119
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3120
        video_enc->pix_fmt = frame_pix_fmt;
3121
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3122

    
3123
        if(codec && codec->pix_fmts){
3124
            const enum PixelFormat *p= codec->pix_fmts;
3125
            for(; *p!=-1; p++){
3126
                if(*p == video_enc->pix_fmt)
3127
                    break;
3128
            }
3129
            if(*p == -1)
3130
                video_enc->pix_fmt = codec->pix_fmts[0];
3131
        }
3132

    
3133
        if (intra_only)
3134
            video_enc->gop_size = 0;
3135
        if (video_qscale || same_quality) {
3136
            video_enc->flags |= CODEC_FLAG_QSCALE;
3137
            video_enc->global_quality=
3138
                st->quality = FF_QP2LAMBDA * video_qscale;
3139
        }
3140

    
3141
        if(intra_matrix)
3142
            video_enc->intra_matrix = intra_matrix;
3143
        if(inter_matrix)
3144
            video_enc->inter_matrix = inter_matrix;
3145

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

    
3176
        if (do_psnr)
3177
            video_enc->flags|= CODEC_FLAG_PSNR;
3178

    
3179
        /* two pass mode */
3180
        if (do_pass) {
3181
            if (do_pass == 1) {
3182
                video_enc->flags |= CODEC_FLAG_PASS1;
3183
            } else {
3184
                video_enc->flags |= CODEC_FLAG_PASS2;
3185
            }
3186
        }
3187
    }
3188
    nb_ocodecs++;
3189
    if (video_language) {
3190
        av_metadata_set(&st->metadata, "language", video_language);
3191
        av_freep(&video_language);
3192
    }
3193

    
3194
    /* reset some key parameters */
3195
    video_disable = 0;
3196
    av_freep(&video_codec_name);
3197
    video_stream_copy = 0;
3198
}
3199

    
3200
static void new_audio_stream(AVFormatContext *oc)
3201
{
3202
    AVStream *st;
3203
    AVCodecContext *audio_enc;
3204
    enum CodecID codec_id;
3205

    
3206
    st = av_new_stream(oc, oc->nb_streams);
3207
    if (!st) {
3208
        fprintf(stderr, "Could not alloc stream\n");
3209
        av_exit(1);
3210
    }
3211
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3212

    
3213
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3214
    audio_bitstream_filters= NULL;
3215

    
3216
    avcodec_thread_init(st->codec, thread_count);
3217

    
3218
    audio_enc = st->codec;
3219
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3220

    
3221
    if(audio_codec_tag)
3222
        audio_enc->codec_tag= audio_codec_tag;
3223

    
3224
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3225
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3226
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3227
    }
3228
    if (audio_stream_copy) {
3229
        st->stream_copy = 1;
3230
        audio_enc->channels = audio_channels;
3231
    } else {
3232
        AVCodec *codec;
3233

    
3234
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3235

    
3236
        if (audio_codec_name) {
3237
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3238
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3239
            output_codecs[nb_ocodecs] = codec;
3240
        } else {
3241
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3242
            codec = avcodec_find_encoder(codec_id);
3243
        }
3244
        audio_enc->codec_id = codec_id;
3245

    
3246
        if (audio_qscale > QSCALE_NONE) {
3247
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3248
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3249
        }
3250
        audio_enc->channels = audio_channels;
3251
        audio_enc->sample_fmt = audio_sample_fmt;
3252
        audio_enc->channel_layout = channel_layout;
3253
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3254
            audio_enc->channel_layout = 0;
3255

    
3256
        if(codec && codec->sample_fmts){
3257
            const enum SampleFormat *p= codec->sample_fmts;
3258
            for(; *p!=-1; p++){
3259
                if(*p == audio_enc->sample_fmt)
3260
                    break;
3261
            }
3262
            if(*p == -1)
3263
                audio_enc->sample_fmt = codec->sample_fmts[0];
3264
        }
3265
    }
3266
    nb_ocodecs++;
3267
    audio_enc->sample_rate = audio_sample_rate;
3268
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3269
    if (audio_language) {
3270
        av_metadata_set(&st->metadata, "language", audio_language);
3271
        av_freep(&audio_language);
3272
    }
3273

    
3274
    /* reset some key parameters */
3275
    audio_disable = 0;
3276
    av_freep(&audio_codec_name);
3277
    audio_stream_copy = 0;
3278
}
3279

    
3280
static void new_subtitle_stream(AVFormatContext *oc)
3281
{
3282
    AVStream *st;
3283
    AVCodecContext *subtitle_enc;
3284

    
3285
    st = av_new_stream(oc, oc->nb_streams);
3286
    if (!st) {
3287
        fprintf(stderr, "Could not alloc stream\n");
3288
        av_exit(1);
3289
    }
3290
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3291

    
3292
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3293
    subtitle_bitstream_filters= NULL;
3294

    
3295
    subtitle_enc = st->codec;
3296
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3297

    
3298
    if(subtitle_codec_tag)
3299
        subtitle_enc->codec_tag= subtitle_codec_tag;
3300

    
3301
    if (subtitle_stream_copy) {
3302
        st->stream_copy = 1;
3303
    } else {
3304
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3305
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3306
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3307
    }
3308
    nb_ocodecs++;
3309

    
3310
    if (subtitle_language) {
3311
        av_metadata_set(&st->metadata, "language", subtitle_language);
3312
        av_freep(&subtitle_language);
3313
    }
3314

    
3315
    subtitle_disable = 0;
3316
    av_freep(&subtitle_codec_name);
3317
    subtitle_stream_copy = 0;
3318
}
3319

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

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

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

    
3353
static void opt_output_file(const char *filename)
3354
{
3355
    AVFormatContext *oc;
3356
    int use_video, use_audio, use_subtitle;
3357
    int input_has_video, input_has_audio, input_has_subtitle;
3358
    AVFormatParameters params, *ap = &params;
3359
    AVOutputFormat *file_oformat;
3360

    
3361
    if (!strcmp(filename, "-"))
3362
        filename = "pipe:";
3363

    
3364
    oc = avformat_alloc_context();
3365
    if (!oc) {
3366
        print_error(filename, AVERROR(ENOMEM));
3367
        av_exit(1);
3368
    }
3369

    
3370
    if (last_asked_format) {
3371
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3372
        if (!file_oformat) {
3373
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3374
            av_exit(1);
3375
        }
3376
        last_asked_format = NULL;
3377
    } else {
3378
        file_oformat = av_guess_format(NULL, filename, NULL);
3379
        if (!file_oformat) {
3380
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3381
                    filename);
3382
            av_exit(1);
3383
        }
3384
    }
3385

    
3386
    oc->oformat = file_oformat;
3387
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3388

    
3389
    if (!strcmp(file_oformat->name, "ffm") &&
3390
        av_strstart(filename, "http:", NULL)) {
3391
        /* special case for files sent to ffserver: we get the stream
3392
           parameters from ffserver */
3393
        int err = read_ffserver_streams(oc, filename);
3394
        if (err < 0) {
3395
            print_error(filename, err);
3396
            av_exit(1);
3397
        }
3398
    } else {
3399
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3400
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3401
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3402

    
3403
        /* disable if no corresponding type found and at least one
3404
           input file */
3405
        if (nb_input_files > 0) {
3406
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3407
                                         &input_has_subtitle);
3408
            if (!input_has_video)
3409
                use_video = 0;
3410
            if (!input_has_audio)
3411
                use_audio = 0;
3412
            if (!input_has_subtitle)
3413
                use_subtitle = 0;
3414
        }
3415

    
3416
        /* manual disable */
3417
        if (audio_disable) {
3418
            use_audio = 0;
3419
        }
3420
        if (video_disable) {
3421
            use_video = 0;
3422
        }
3423
        if (subtitle_disable) {
3424
            use_subtitle = 0;
3425
        }
3426

    
3427
        if (use_video) {
3428
            new_video_stream(oc);
3429
        }
3430

    
3431
        if (use_audio) {
3432
            new_audio_stream(oc);
3433
        }
3434

    
3435
        if (use_subtitle) {
3436
            new_subtitle_stream(oc);
3437
        }
3438

    
3439
        oc->timestamp = rec_timestamp;
3440

    
3441
        for(; metadata_count>0; metadata_count--){
3442
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3443
                                           metadata[metadata_count-1].value);
3444
        }
3445
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3446
    }
3447

    
3448
    output_files[nb_output_files++] = oc;
3449

    
3450
    /* check filename in case of an image number is expected */
3451
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3452
        if (!av_filename_number_test(oc->filename)) {
3453
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3454
            av_exit(1);
3455
        }
3456
    }
3457

    
3458
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3459
        /* test if it already exists to avoid loosing precious files */
3460
        if (!file_overwrite &&
3461
            (strchr(filename, ':') == NULL ||
3462
             filename[1] == ':' ||
3463
             av_strstart(filename, "file:", NULL))) {
3464
            if (url_exist(filename)) {
3465
                if (!using_stdin) {
3466
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3467
                    fflush(stderr);
3468
                    if (!read_yesno()) {
3469
                        fprintf(stderr, "Not overwriting - exiting\n");
3470
                        av_exit(1);
3471
                    }
3472
                }
3473
                else {
3474
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3475
                    av_exit(1);
3476
                }
3477
            }
3478
        }
3479

    
3480
        /* open the file */
3481
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3482
            fprintf(stderr, "Could not open '%s'\n", filename);
3483
            av_exit(1);
3484
        }
3485
    }
3486

    
3487
    memset(ap, 0, sizeof(*ap));
3488
    if (av_set_parameters(oc, ap) < 0) {
3489
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3490
                oc->filename);
3491
        av_exit(1);
3492
    }
3493

    
3494
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3495
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3496
    oc->loop_output = loop_output;
3497
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3498

    
3499
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3500
}
3501

    
3502
/* same option as mencoder */
3503
static void opt_pass(const char *pass_str)
3504
{
3505
    int pass;
3506
    pass = atoi(pass_str);
3507
    if (pass != 1 && pass != 2) {
3508
        fprintf(stderr, "pass number can be only 1 or 2\n");
3509
        av_exit(1);
3510
    }
3511
    do_pass = pass;
3512
}
3513

    
3514
static int64_t getutime(void)
3515
{
3516
#if HAVE_GETRUSAGE
3517
    struct rusage rusage;
3518

    
3519
    getrusage(RUSAGE_SELF, &rusage);
3520
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3521
#elif HAVE_GETPROCESSTIMES
3522
    HANDLE proc;
3523
    FILETIME c, e, k, u;
3524
    proc = GetCurrentProcess();
3525
    GetProcessTimes(proc, &c, &e, &k, &u);
3526
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3527
#else
3528
    return av_gettime();
3529
#endif
3530
}
3531

    
3532
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3533
{
3534
    int i;
3535
    const char *p = str;
3536
    for(i = 0;; i++) {
3537
        dest[i] = atoi(p);
3538
        if(i == 63)
3539
            break;
3540
        p = strchr(p, ',');
3541
        if(!p) {
3542
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3543
            av_exit(1);
3544
        }
3545
        p++;
3546
    }
3547
}
3548

    
3549
static void opt_inter_matrix(const char *arg)
3550
{
3551
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3552
    parse_matrix_coeffs(inter_matrix, arg);
3553
}
3554

    
3555
static void opt_intra_matrix(const char *arg)
3556
{
3557
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3558
    parse_matrix_coeffs(intra_matrix, arg);
3559
}
3560

    
3561
/**
3562
 * Trivial log callback.
3563
 * Only suitable for show_help and similar since it lacks prefix handling.
3564
 */
3565
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3566
{
3567
    vfprintf(stdout, fmt, vl);
3568
}
3569

    
3570
static void show_usage(void)
3571
{
3572
    printf("Hyper fast Audio and Video encoder\n");
3573
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3574
    printf("\n");
3575
}
3576

    
3577
static void show_help(void)
3578
{
3579
    av_log_set_callback(log_callback_help);
3580
    show_usage();
3581
    show_help_options(options, "Main options:\n",
3582
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3583
    show_help_options(options, "\nAdvanced options:\n",
3584
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3585
                      OPT_EXPERT);
3586
    show_help_options(options, "\nVideo options:\n",
3587
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3588
                      OPT_VIDEO);
3589
    show_help_options(options, "\nAdvanced Video options:\n",
3590
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3591
                      OPT_VIDEO | OPT_EXPERT);
3592
    show_help_options(options, "\nAudio options:\n",
3593
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3594
                      OPT_AUDIO);
3595
    show_help_options(options, "\nAdvanced Audio options:\n",
3596
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3597
                      OPT_AUDIO | OPT_EXPERT);
3598
    show_help_options(options, "\nSubtitle options:\n",
3599
                      OPT_SUBTITLE | OPT_GRAB,
3600
                      OPT_SUBTITLE);
3601
    show_help_options(options, "\nAudio/Video grab options:\n",
3602
                      OPT_GRAB,
3603
                      OPT_GRAB);
3604
    printf("\n");
3605
    av_opt_show(avcodec_opts[0], NULL);
3606
    printf("\n");
3607
    av_opt_show(avformat_opts, NULL);
3608
    printf("\n");
3609
    av_opt_show(sws_opts, NULL);
3610
}
3611

    
3612
static void opt_target(const char *arg)
3613
{
3614
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3615
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3616

    
3617
    if(!strncmp(arg, "pal-", 4)) {
3618
        norm = PAL;
3619
        arg += 4;
3620
    } else if(!strncmp(arg, "ntsc-", 5)) {
3621
        norm = NTSC;
3622
        arg += 5;
3623
    } else if(!strncmp(arg, "film-", 5)) {
3624
        norm = FILM;
3625
        arg += 5;
3626
    } else {
3627
        int fr;
3628
        /* Calculate FR via float to avoid int overflow */
3629
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3630
        if(fr == 25000) {
3631
            norm = PAL;
3632
        } else if((fr == 29970) || (fr == 23976)) {
3633
            norm = NTSC;
3634
        } else {
3635
            /* Try to determine PAL/NTSC by peeking in the input files */
3636
            if(nb_input_files) {
3637
                int i, j;
3638
                for(j = 0; j < nb_input_files; j++) {
3639
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3640
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3641
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3642
                            continue;
3643
                        fr = c->time_base.den * 1000 / c->time_base.num;
3644
                        if(fr == 25000) {
3645
                            norm = PAL;
3646
                            break;
3647
                        } else if((fr == 29970) || (fr == 23976)) {
3648
                            norm = NTSC;
3649
                            break;
3650
                        }
3651
                    }
3652
                    if(norm != UNKNOWN)
3653
                        break;
3654
                }
3655
            }
3656
        }
3657
        if(verbose && norm != UNKNOWN)
3658
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3659
    }
3660

    
3661
    if(norm == UNKNOWN) {
3662
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3663
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3664
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3665
        av_exit(1);
3666
    }
3667

    
3668
    if(!strcmp(arg, "vcd")) {
3669

    
3670
        opt_video_codec("mpeg1video");
3671
        opt_audio_codec("mp2");
3672
        opt_format("vcd");
3673

    
3674
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3675
        opt_frame_rate(NULL, frame_rates[norm]);
3676
        opt_default("g", norm == PAL ? "15" : "18");
3677

    
3678
        opt_default("b", "1150000");
3679
        opt_default("maxrate", "1150000");
3680
        opt_default("minrate", "1150000");
3681
        opt_default("bufsize", "327680"); // 40*1024*8;
3682

    
3683
        opt_default("ab", "224000");
3684
        audio_sample_rate = 44100;
3685
        audio_channels = 2;
3686

    
3687
        opt_default("packetsize", "2324");
3688
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3689

    
3690
        /* We have to offset the PTS, so that it is consistent with the SCR.
3691
           SCR starts at 36000, but the first two packs contain only padding
3692
           and the first pack from the other stream, respectively, may also have
3693
           been written before.
3694
           So the real data starts at SCR 36000+3*1200. */
3695
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3696
    } else if(!strcmp(arg, "svcd")) {
3697

    
3698
        opt_video_codec("mpeg2video");
3699
        opt_audio_codec("mp2");
3700
        opt_format("svcd");
3701

    
3702
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3703
        opt_frame_rate(NULL, frame_rates[norm]);
3704
        opt_default("g", norm == PAL ? "15" : "18");
3705

    
3706
        opt_default("b", "2040000");
3707
        opt_default("maxrate", "2516000");
3708
        opt_default("minrate", "0"); //1145000;
3709
        opt_default("bufsize", "1835008"); //224*1024*8;
3710
        opt_default("flags", "+scan_offset");
3711

    
3712

    
3713
        opt_default("ab", "224000");
3714
        audio_sample_rate = 44100;
3715

    
3716
        opt_default("packetsize", "2324");
3717

    
3718
    } else if(!strcmp(arg, "dvd")) {
3719

    
3720
        opt_video_codec("mpeg2video");
3721
        opt_audio_codec("ac3");
3722
        opt_format("dvd");
3723

    
3724
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3725
        opt_frame_rate(NULL, frame_rates[norm]);
3726
        opt_default("g", norm == PAL ? "15" : "18");
3727

    
3728
        opt_default("b", "6000000");
3729
        opt_default("maxrate", "9000000");
3730
        opt_default("minrate", "0"); //1500000;
3731
        opt_default("bufsize", "1835008"); //224*1024*8;
3732

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

    
3736
        opt_default("ab", "448000");
3737
        audio_sample_rate = 48000;
3738

    
3739
    } else if(!strncmp(arg, "dv", 2)) {
3740

    
3741
        opt_format("dv");
3742

    
3743
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3744
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3745
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3746
        opt_frame_rate(NULL, frame_rates[norm]);
3747

    
3748
        audio_sample_rate = 48000;
3749
        audio_channels = 2;
3750

    
3751
    } else {
3752
        fprintf(stderr, "Unknown target: %s\n", arg);
3753
        av_exit(1);
3754
    }
3755
}
3756

    
3757
static void opt_vstats_file (const char *arg)
3758
{
3759
    av_free (vstats_filename);
3760
    vstats_filename=av_strdup (arg);
3761
}
3762

    
3763
static void opt_vstats (void)
3764
{
3765
    char filename[40];
3766
    time_t today2 = time(NULL);
3767
    struct tm *today = localtime(&today2);
3768

    
3769
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3770
             today->tm_sec);
3771
    opt_vstats_file(filename);
3772
}
3773

    
3774
static int opt_bsf(const char *opt, const char *arg)
3775
{
3776
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3777
    AVBitStreamFilterContext **bsfp;
3778

    
3779
    if(!bsfc){
3780
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3781
        av_exit(1);
3782
    }
3783

    
3784
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3785
          *opt == 'a' ? &audio_bitstream_filters :
3786
                        &subtitle_bitstream_filters;
3787
    while(*bsfp)
3788
        bsfp= &(*bsfp)->next;
3789

    
3790
    *bsfp= bsfc;
3791

    
3792
    return 0;
3793
}
3794

    
3795
static int opt_preset(const char *opt, const char *arg)
3796
{
3797
    FILE *f=NULL;
3798
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3799
    int i;
3800
    const char *base[2]= { getenv("HOME"),
3801
                           FFMPEG_DATADIR,
3802
                         };
3803

    
3804
    if (*opt != 'f') {
3805
        for(i=!base[0]; i<2 && !f; i++){
3806
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3807
            f= fopen(filename, "r");
3808
            if(!f){
3809
                char *codec_name= *opt == 'v' ? video_codec_name :
3810
                                  *opt == 'a' ? audio_codec_name :
3811
                                                subtitle_codec_name;
3812
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3813
                f= fopen(filename, "r");
3814
            }
3815
        }
3816
    } else {
3817
        av_strlcpy(filename, arg, sizeof(filename));
3818
        f= fopen(filename, "r");
3819
    }
3820

    
3821
    if(!f){
3822
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3823
        av_exit(1);
3824
    }
3825

    
3826
    while(!feof(f)){
3827
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3828
        if(line[0] == '#' && !e)
3829
            continue;
3830
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3831
        if(e){
3832
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3833
            av_exit(1);
3834
        }
3835
        if(!strcmp(tmp, "acodec")){
3836
            opt_audio_codec(tmp2);
3837
        }else if(!strcmp(tmp, "vcodec")){
3838
            opt_video_codec(tmp2);
3839
        }else if(!strcmp(tmp, "scodec")){
3840
            opt_subtitle_codec(tmp2);
3841
        }else if(opt_default(tmp, tmp2) < 0){
3842
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3843
            av_exit(1);
3844
        }
3845
    }
3846

    
3847
    fclose(f);
3848

    
3849
    return 0;
3850
}
3851

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

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

    
3935
    /* audio options */
3936
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3937
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3938
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3939
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3940
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3941
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3942
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3943
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3944
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3945
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3946
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3947
    { "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" },
3948

    
3949
    /* subtitle options */
3950
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3951
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3952
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3953
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3954
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3955

    
3956
    /* grab options */
3957
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3958
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3959
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3960

    
3961
    /* muxer options */
3962
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3963
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3964

    
3965
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3966
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3967
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3968

    
3969
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3970
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3971
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3972
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3973

    
3974
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3975
    { NULL, },
3976
};
3977

    
3978
int main(int argc, char **argv)
3979
{
3980
    int i;
3981
    int64_t ti;
3982

    
3983
    avcodec_register_all();
3984
    avdevice_register_all();
3985
    av_register_all();
3986

    
3987
#if HAVE_ISATTY
3988
    if(isatty(STDIN_FILENO))
3989
        url_set_interrupt_cb(decode_interrupt_cb);
3990
#endif
3991

    
3992
    for(i=0; i<CODEC_TYPE_NB; i++){
3993
        avcodec_opts[i]= avcodec_alloc_context2(i);
3994
    }
3995
    avformat_opts = avformat_alloc_context();
3996
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3997

    
3998
    show_banner();
3999

    
4000
    /* parse options */
4001
    parse_options(argc, argv, options, opt_output_file);
4002

    
4003
    if(nb_output_files <= 0 && nb_input_files == 0) {
4004
        show_usage();
4005
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4006
        av_exit(1);
4007
    }
4008

    
4009
    /* file converter / grab */
4010
    if (nb_output_files <= 0) {
4011
        fprintf(stderr, "At least one output file must be specified\n");
4012
        av_exit(1);
4013
    }
4014

    
4015
    if (nb_input_files == 0) {
4016
        fprintf(stderr, "At least one input file must be specified\n");
4017
        av_exit(1);
4018
    }
4019

    
4020
    ti = getutime();
4021
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4022
                  stream_maps, nb_stream_maps) < 0)
4023
        av_exit(1);
4024
    ti = getutime() - ti;
4025
    if (do_benchmark) {
4026
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4027
    }
4028

    
4029
    return av_exit(0);
4030
}