Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 04d2540c

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/pixdesc.h"
42
#include "libavutil/avstring.h"
43
#include "libavformat/os_support.h"
44

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

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

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

    
67
#include "cmdutils.h"
68

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

    
72
#undef exit
73

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

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

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

    
91
static const OptionDef options[];
92

    
93
#define MAX_FILES 100
94

    
95
static const char *last_asked_format = NULL;
96
static AVFormatContext *input_files[MAX_FILES];
97
static int64_t input_files_ts_offset[MAX_FILES];
98
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
99
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
100
static int nb_input_files = 0;
101
static int nb_icodecs;
102

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

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

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

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

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

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

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

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

    
194
static int rate_emu = 0;
195

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

    
199
static int audio_volume = 256;
200

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

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

    
218
static unsigned int sws_flags = SWS_BICUBIC;
219

    
220
static int64_t timer_start;
221

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

    
226
static short *samples;
227

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

    
233
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
234

    
235
struct AVInputStream;
236

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

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

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

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

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

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

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

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

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

    
313
#if HAVE_TERMIOS_H
314

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

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

    
326
static volatile int received_sigterm = 0;
327

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

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

    
340
    tcgetattr (0, &tty);
341
    oldtty = tty;
342

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

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

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

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

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

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

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

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

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

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

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

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

    
441
    av_free(opt_names);
442

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

    
447
    av_free(video_standard);
448

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

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

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

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

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

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

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

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

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

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

    
513
    if (!nopts)
514
        s->timestamp = av_gettime();
515

    
516
    av_close_input_file(ic);
517
    return 0;
518
}
519

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

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

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

    
549
        bsfc= bsfc->next;
550
    }
551

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

    
559
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
560

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

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

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

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

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

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

    
600
    if (enc->channels != dec->channels)
601
        ost->audio_resample = 1;
602

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

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

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

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

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

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

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

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

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

    
718
        frame_bytes = enc->frame_size * osize * enc->channels;
719

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

    
724
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
725

    
726
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
727

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

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

    
749
        ost->sync_opts += size_out / (osize * enc->channels);
750

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

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

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

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

    
787
    dec = ist->st->codec;
788

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

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

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

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

    
814
    if (picture != picture2)
815
        *picture = *picture2;
816
    *bufp = buf;
817
}
818

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

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

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

    
841
    enc = ost->st->codec;
842

    
843
    if (!subtitle_out) {
844
        subtitle_out = av_malloc(subtitle_out_max_size);
845
    }
846

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

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

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

    
885
static int bit_buffer_size= 1024*256;
886
static uint8_t *bit_buffer= NULL;
887

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

    
900
    avcodec_get_frame_defaults(&picture_crop_temp);
901
    avcodec_get_frame_defaults(&picture_pad_temp);
902

    
903
    enc = ost->st->codec;
904
    dec = ist->st->codec;
905

    
906
    /* by default, we output a single frame */
907
    nb_frames = 1;
908

    
909
    *frame_size = 0;
910

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

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

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

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

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

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

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

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

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

    
997
            ost->topBand    = topBand;
998
            ost->bottomBand = bottomBand;
999
            ost->leftBand   = leftBand;
1000
            ost->rightBand  = rightBand;
1001

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1180

    
1181
    oc = output_files[0];
1182

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

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

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

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

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

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

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

    
1261
        fflush(stderr);
1262
    }
1263

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

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

    
1293
    if(ist->next_pts == AV_NOPTS_VALUE)
1294
        ist->next_pts= ist->pts;
1295

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

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

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

    
1316
        if(avpkt.size && avpkt.size != pkt->size &&
1317
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1318
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1319
            ist->showed_multi_packet_warning=1;
1320
        }
1321

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

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

    
1411
        buffer_to_free = NULL;
1412
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1413
            pre_process_video_frame(ist, (AVPicture *)&picture,
1414
                                    &buffer_to_free);
1415
        }
1416

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

    
1431
        /* frame rate emulation */
1432
        if (rate_emu) {
1433
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1434
            int64_t now = av_gettime() - ist->start;
1435
            if (pts > now)
1436
                usleep(pts - now);
1437
        }
1438

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

    
1445
                ost = ost_table[i];
1446
                if (ost->source_index == ist_index) {
1447
                    os = output_files[ost->file_index];
1448

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

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

    
1475
                        av_init_packet(&opkt);
1476

    
1477
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1478
                            continue;
1479

    
1480
                        /* no reencoding needed : output the packet directly */
1481
                        /* force the input stream PTS */
1482

    
1483
                        avcodec_get_frame_defaults(&avframe);
1484
                        ost->st->codec->coded_frame= &avframe;
1485
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1486

    
1487
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1488
                            audio_size += data_size;
1489
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1490
                            video_size += data_size;
1491
                            ost->sync_opts++;
1492
                        }
1493

    
1494
                        opkt.stream_index= ost->index;
1495
                        if(pkt->pts != AV_NOPTS_VALUE)
1496
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1497
                        else
1498
                            opkt.pts= AV_NOPTS_VALUE;
1499

    
1500
                        if (pkt->dts == AV_NOPTS_VALUE)
1501
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1502
                        else
1503
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1504
                        opkt.dts -= ost_tb_start_time;
1505

    
1506
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1507
                        opkt.flags= pkt->flags;
1508

    
1509
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1510
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1511
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1512
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1513
                           ) {
1514
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1515
                                opkt.destruct= av_destruct_packet;
1516
                        } else {
1517
                            opkt.data = data_buf;
1518
                            opkt.size = data_size;
1519
                        }
1520

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

    
1547
        for(i=0;i<nb_ostreams;i++) {
1548
            ost = ost_table[i];
1549
            if (ost->source_index == ist_index) {
1550
                AVCodecContext *enc= ost->st->codec;
1551
                os = output_files[ost->file_index];
1552

    
1553
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1554
                    continue;
1555
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1556
                    continue;
1557

    
1558
                if (ost->encoding_needed) {
1559
                    for(;;) {
1560
                        AVPacket pkt;
1561
                        int fifo_bytes;
1562
                        av_init_packet(&pkt);
1563
                        pkt.stream_index= ost->index;
1564

    
1565
                        switch(ost->st->codec->codec_type) {
1566
                        case CODEC_TYPE_AUDIO:
1567
                            fifo_bytes = av_fifo_size(ost->fifo);
1568
                            ret = 0;
1569
                            /* encode any samples remaining in fifo */
1570
                            if (fifo_bytes > 0) {
1571
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1572
                                int fs_tmp = enc->frame_size;
1573

    
1574
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1575
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1576
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1577
                                } else { /* pad */
1578
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1579
                                    if (samples_size < frame_bytes)
1580
                                        av_exit(1);
1581
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1582
                                }
1583

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

    
1616
                        if(ret<=0)
1617
                            break;
1618
                        pkt.data= bit_buffer;
1619
                        pkt.size= ret;
1620
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1621
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1622
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1623
                    }
1624
                }
1625
            }
1626
        }
1627
    }
1628

    
1629
    return 0;
1630
 fail_decode:
1631
    return -1;
1632
}
1633

    
1634
static void print_sdp(AVFormatContext **avc, int n)
1635
{
1636
    char sdp[2048];
1637

    
1638
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1639
    printf("SDP:\n%s\n", sdp);
1640
    fflush(stdout);
1641
}
1642

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

    
1666
    return -1;
1667
}
1668

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

    
1690
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1691
    if (!file_table)
1692
        goto fail;
1693

    
1694
    /* input stream init */
1695
    j = 0;
1696
    for(i=0;i<nb_input_files;i++) {
1697
        is = input_files[i];
1698
        file_table[i].ist_index = j;
1699
        file_table[i].nb_streams = is->nb_streams;
1700
        j += is->nb_streams;
1701
    }
1702
    nb_istreams = j;
1703

    
1704
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1705
    if (!ist_table)
1706
        goto fail;
1707

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

    
1725
            if (rate_emu) {
1726
                ist->start = av_gettime();
1727
            }
1728
        }
1729
    }
1730

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

    
1747
    /* Sanity check the mapping args -- do the input files & streams exist? */
1748
    for(i=0;i<nb_stream_maps;i++) {
1749
        int fi = stream_maps[i].file_index;
1750
        int si = stream_maps[i].stream_index;
1751

    
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 input stream #%d.%d\n", fi, si);
1755
            av_exit(1);
1756
        }
1757
        fi = stream_maps[i].sync_file_index;
1758
        si = stream_maps[i].sync_stream_index;
1759
        if (fi < 0 || fi > nb_input_files - 1 ||
1760
            si < 0 || si > file_table[fi].nb_streams - 1) {
1761
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1762
            av_exit(1);
1763
        }
1764
    }
1765

    
1766
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1767
    if (!ost_table)
1768
        goto fail;
1769
    for(i=0;i<nb_ostreams;i++) {
1770
        ost = av_mallocz(sizeof(AVOutputStream));
1771
        if (!ost)
1772
            goto fail;
1773
        ost_table[i] = ost;
1774
    }
1775

    
1776
    n = 0;
1777
    for(k=0;k<nb_output_files;k++) {
1778
        os = output_files[k];
1779
        for(i=0;i<os->nb_streams;i++,n++) {
1780
            int found;
1781
            ost = ost_table[n];
1782
            ost->file_index = k;
1783
            ost->index = i;
1784
            ost->st = os->streams[i];
1785
            if (nb_stream_maps > 0) {
1786
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1787
                    stream_maps[n].stream_index;
1788

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

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

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

    
1849
    /* for each output stream, we compute the right encoding parameters */
1850
    for(i=0;i<nb_ostreams;i++) {
1851
        AVMetadataTag *lang;
1852
        ost = ost_table[i];
1853
        os = output_files[ost->file_index];
1854
        ist = ist_table[ost->source_index];
1855

    
1856
        codec = ost->st->codec;
1857
        icodec = ist->st->codec;
1858

    
1859
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1860
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1861
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1862

    
1863
        ost->st->disposition = ist->st->disposition;
1864
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1865
        codec->chroma_sample_location = icodec->chroma_sample_location;
1866

    
1867
        if (ost->st->stream_copy) {
1868
            /* if stream_copy is selected, no need to decode or encode */
1869
            codec->codec_id = icodec->codec_id;
1870
            codec->codec_type = icodec->codec_type;
1871

    
1872
            if(!codec->codec_tag){
1873
                if(   !os->oformat->codec_tag
1874
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1875
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1876
                    codec->codec_tag = icodec->codec_tag;
1877
            }
1878

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

    
1981
                    ost->original_height = icodec->height;
1982
                    ost->original_width  = icodec->width;
1983

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

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

    
2046
    if (!bit_buffer)
2047
        bit_buffer = av_malloc(bit_buffer_size);
2048
    if (!bit_buffer) {
2049
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2050
                bit_buffer_size);
2051
        ret = AVERROR(ENOMEM);
2052
        goto fail;
2053
    }
2054

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

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

    
2102
    /* init pts */
2103
    for(i=0;i<nb_istreams;i++) {
2104
        ist = ist_table[i];
2105
        ist->pts = 0;
2106
        ist->next_pts = AV_NOPTS_VALUE;
2107
        ist->is_start = 1;
2108
    }
2109

    
2110
    /* set meta data information from input file if required */
2111
    for (i=0;i<nb_meta_data_maps;i++) {
2112
        AVFormatContext *out_file;
2113
        AVFormatContext *in_file;
2114
        AVMetadataTag *mtag;
2115

    
2116
        int out_file_index = meta_data_maps[i].out_file;
2117
        int in_file_index = meta_data_maps[i].in_file;
2118
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2119
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2120
                     out_file_index, out_file_index, in_file_index);
2121
            ret = AVERROR(EINVAL);
2122
            goto dump_format;
2123
        }
2124
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2125
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2126
                     in_file_index, out_file_index, in_file_index);
2127
            ret = AVERROR(EINVAL);
2128
            goto dump_format;
2129
        }
2130

    
2131
        out_file = output_files[out_file_index];
2132
        in_file = input_files[in_file_index];
2133

    
2134

    
2135
        mtag=NULL;
2136
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2137
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2138
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2139
                                    in_file->iformat->metadata_conv);
2140
    }
2141

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

    
2155
 dump_format:
2156
    /* dump the file output parameters - cannot be done before in case
2157
       of stream copy */
2158
    for(i=0;i<nb_output_files;i++) {
2159
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2160
    }
2161

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

    
2180
    if (ret) {
2181
        fprintf(stderr, "%s\n", error);
2182
        goto fail;
2183
    }
2184

    
2185
    if (want_sdp) {
2186
        print_sdp(output_files, nb_output_files);
2187
    }
2188

    
2189
    if (!using_stdin && verbose >= 0) {
2190
        fprintf(stderr, "Press [q] to stop encoding\n");
2191
        url_set_interrupt_cb(decode_interrupt_cb);
2192
    }
2193
    term_init();
2194

    
2195
    timer_start = av_gettime();
2196

    
2197
    for(; received_sigterm == 0;) {
2198
        int file_index, ist_index;
2199
        AVPacket pkt;
2200
        double ipts_min;
2201
        double opts_min;
2202

    
2203
    redo:
2204
        ipts_min= 1e100;
2205
        opts_min= 1e100;
2206
        /* if 'q' pressed, exits */
2207
        if (!using_stdin) {
2208
            if (q_pressed)
2209
                break;
2210
            /* read_key() returns 0 on EOF */
2211
            key = read_key();
2212
            if (key == 'q')
2213
                break;
2214
        }
2215

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

    
2254
        /* finish if recording time exhausted */
2255
        if (opts_min >= (recording_time / 1000000.0))
2256
            break;
2257

    
2258
        /* finish if limit size exhausted */
2259
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2260
            break;
2261

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

    
2278
        no_packet_count=0;
2279
        memset(no_packet, 0, sizeof(no_packet));
2280

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

    
2293
        if (pkt.dts != AV_NOPTS_VALUE)
2294
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2295
        if (pkt.pts != AV_NOPTS_VALUE)
2296
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2297

    
2298
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2299
            if(pkt.pts != AV_NOPTS_VALUE)
2300
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2301
            if(pkt.dts != AV_NOPTS_VALUE)
2302
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2303
        }
2304

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

    
2320
        /* finish if recording time exhausted */
2321
        if (pkt.pts * av_q2d(ist->st->time_base) >= (recording_time / 1000000.0))
2322
            goto discard_packet;
2323

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

    
2327
            if (verbose >= 0)
2328
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2329
                        ist->file_index, ist->index);
2330
            if (exit_on_error)
2331
                av_exit(1);
2332
            av_free_packet(&pkt);
2333
            goto redo;
2334
        }
2335

    
2336
    discard_packet:
2337
        av_free_packet(&pkt);
2338

    
2339
        /* dump report by using the output first video and audio streams */
2340
        print_report(output_files, ost_table, nb_ostreams, 0);
2341
    }
2342

    
2343
    /* at the end of stream, we must flush the decoder buffers */
2344
    for(i=0;i<nb_istreams;i++) {
2345
        ist = ist_table[i];
2346
        if (ist->decoding_needed) {
2347
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2348
        }
2349
    }
2350

    
2351
    term_exit();
2352

    
2353
    /* write the trailer if needed and close file */
2354
    for(i=0;i<nb_output_files;i++) {
2355
        os = output_files[i];
2356
        av_write_trailer(os);
2357
    }
2358

    
2359
    /* dump report by using the first video and audio streams */
2360
    print_report(output_files, ost_table, nb_ostreams, 1);
2361

    
2362
    /* close each encoder */
2363
    for(i=0;i<nb_ostreams;i++) {
2364
        ost = ost_table[i];
2365
        if (ost->encoding_needed) {
2366
            av_freep(&ost->st->codec->stats_in);
2367
            avcodec_close(ost->st->codec);
2368
        }
2369
    }
2370

    
2371
    /* close each decoder */
2372
    for(i=0;i<nb_istreams;i++) {
2373
        ist = ist_table[i];
2374
        if (ist->decoding_needed) {
2375
            avcodec_close(ist->st->codec);
2376
        }
2377
    }
2378

    
2379
    /* finished ! */
2380
    ret = 0;
2381

    
2382
 fail:
2383
    av_freep(&bit_buffer);
2384
    av_free(file_table);
2385

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

    
2418
static void opt_format(const char *arg)
2419
{
2420
    /* compatibility stuff for pgmyuv */
2421
    if (!strcmp(arg, "pgmyuv")) {
2422
        pgmyuv_compatibility_hack=1;
2423
//        opt_image_format(arg);
2424
        arg = "image2";
2425
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2426
    }
2427

    
2428
    last_asked_format = arg;
2429
}
2430

    
2431
static void opt_video_rc_override_string(const char *arg)
2432
{
2433
    video_rc_override_string = arg;
2434
}
2435

    
2436
static int opt_me_threshold(const char *opt, const char *arg)
2437
{
2438
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2439
    return 0;
2440
}
2441

    
2442
static int opt_verbose(const char *opt, const char *arg)
2443
{
2444
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2445
    return 0;
2446
}
2447

    
2448
static int opt_frame_rate(const char *opt, const char *arg)
2449
{
2450
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2451
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2452
        av_exit(1);
2453
    }
2454
    return 0;
2455
}
2456

    
2457
static int opt_bitrate(const char *opt, const char *arg)
2458
{
2459
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2460

    
2461
    opt_default(opt, arg);
2462

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

    
2466
    return 0;
2467
}
2468

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

    
2483
static void opt_frame_crop_bottom(const char *arg)
2484
{
2485
    frame_bottomBand = atoi(arg);
2486
    if (frame_bottomBand < 0) {
2487
        fprintf(stderr, "Incorrect bottom crop size\n");
2488
        av_exit(1);
2489
    }
2490
    if ((frame_bottomBand) >= frame_height){
2491
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2492
        av_exit(1);
2493
    }
2494
    frame_height -= frame_bottomBand;
2495
}
2496

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

    
2511
static void opt_frame_crop_right(const char *arg)
2512
{
2513
    frame_rightBand = atoi(arg);
2514
    if (frame_rightBand < 0) {
2515
        fprintf(stderr, "Incorrect right crop size\n");
2516
        av_exit(1);
2517
    }
2518
    if ((frame_rightBand) >= frame_width){
2519
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2520
        av_exit(1);
2521
    }
2522
    frame_width -= frame_rightBand;
2523
}
2524

    
2525
static void opt_frame_size(const char *arg)
2526
{
2527
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2528
        fprintf(stderr, "Incorrect frame size\n");
2529
        av_exit(1);
2530
    }
2531
}
2532

    
2533
static void opt_pad_color(const char *arg) {
2534
    /* Input is expected to be six hex digits similar to
2535
       how colors are expressed in html tags (but without the #) */
2536
    int rgb = strtol(arg, NULL, 16);
2537
    int r,g,b;
2538

    
2539
    r = (rgb >> 16);
2540
    g = ((rgb >> 8) & 255);
2541
    b = (rgb & 255);
2542

    
2543
    padcolor[0] = RGB_TO_Y(r,g,b);
2544
    padcolor[1] = RGB_TO_U(r,g,b,0);
2545
    padcolor[2] = RGB_TO_V(r,g,b,0);
2546
}
2547

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

    
2557
static void opt_frame_pad_bottom(const char *arg)
2558
{
2559
    frame_padbottom = atoi(arg);
2560
    if (frame_padbottom < 0) {
2561
        fprintf(stderr, "Incorrect bottom pad size\n");
2562
        av_exit(1);
2563
    }
2564
}
2565

    
2566

    
2567
static void opt_frame_pad_left(const char *arg)
2568
{
2569
    frame_padleft = atoi(arg);
2570
    if (frame_padleft < 0) {
2571
        fprintf(stderr, "Incorrect left pad size\n");
2572
        av_exit(1);
2573
    }
2574
}
2575

    
2576

    
2577
static void opt_frame_pad_right(const char *arg)
2578
{
2579
    frame_padright = atoi(arg);
2580
    if (frame_padright < 0) {
2581
        fprintf(stderr, "Incorrect right pad size\n");
2582
        av_exit(1);
2583
    }
2584
}
2585

    
2586
static void opt_frame_pix_fmt(const char *arg)
2587
{
2588
    if (strcmp(arg, "list")) {
2589
        frame_pix_fmt = av_get_pix_fmt(arg);
2590
        if (frame_pix_fmt == PIX_FMT_NONE) {
2591
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2592
            av_exit(1);
2593
        }
2594
    } else {
2595
        show_pix_fmts();
2596
        av_exit(0);
2597
    }
2598
}
2599

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

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

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

    
2624
static int opt_metadata(const char *opt, const char *arg)
2625
{
2626
    char *mid= strchr(arg, '=');
2627

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

    
2634
    metadata_count++;
2635
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2636
    metadata[metadata_count-1].key  = av_strdup(arg);
2637
    metadata[metadata_count-1].value= av_strdup(mid);
2638

    
2639
    return 0;
2640
}
2641

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

    
2652
static void opt_top_field_first(const char *arg)
2653
{
2654
    top_field_first= atoi(arg);
2655
}
2656

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

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

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

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

    
2689
static void opt_video_channel(const char *arg)
2690
{
2691
    video_channel = strtol(arg, NULL, 0);
2692
}
2693

    
2694
static void opt_video_standard(const char *arg)
2695
{
2696
    video_standard = av_strdup(arg);
2697
}
2698

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

    
2710
static void opt_audio_codec(const char *arg)
2711
{
2712
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2713
}
2714

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

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

    
2724
static void opt_video_tag(const char *arg)
2725
{
2726
    char *tail;
2727
    video_codec_tag= strtol(arg, &tail, 0);
2728

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

    
2733
static void opt_video_codec(const char *arg)
2734
{
2735
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2736
}
2737

    
2738
static void opt_subtitle_codec(const char *arg)
2739
{
2740
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2741
}
2742

    
2743
static void opt_subtitle_tag(const char *arg)
2744
{
2745
    char *tail;
2746
    subtitle_codec_tag= strtol(arg, &tail, 0);
2747

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

    
2752
static void opt_map(const char *arg)
2753
{
2754
    AVStreamMap *m;
2755
    char *p;
2756

    
2757
    m = &stream_maps[nb_stream_maps++];
2758

    
2759
    m->file_index = strtol(arg, &p, 0);
2760
    if (*p)
2761
        p++;
2762

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

    
2776
static void opt_map_meta_data(const char *arg)
2777
{
2778
    AVMetaDataMap *m;
2779
    char *p;
2780

    
2781
    m = &meta_data_maps[nb_meta_data_maps++];
2782

    
2783
    m->out_file = strtol(arg, &p, 0);
2784
    if (*p)
2785
        p++;
2786

    
2787
    m->in_file = strtol(p, &p, 0);
2788
}
2789

    
2790
static void opt_input_ts_scale(const char *arg)
2791
{
2792
    unsigned int stream;
2793
    double scale;
2794
    char *p;
2795

    
2796
    stream = strtol(arg, &p, 0);
2797
    if (*p)
2798
        p++;
2799
    scale= strtod(p, &p);
2800

    
2801
    if(stream >= MAX_STREAMS)
2802
        av_exit(1);
2803

    
2804
    input_files_ts_scale[nb_input_files][stream]= scale;
2805
}
2806

    
2807
static int opt_recording_time(const char *opt, const char *arg)
2808
{
2809
    recording_time = parse_time_or_die(opt, arg, 1);
2810
    return 0;
2811
}
2812

    
2813
static int opt_start_time(const char *opt, const char *arg)
2814
{
2815
    start_time = parse_time_or_die(opt, arg, 1);
2816
    return 0;
2817
}
2818

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

    
2825
static int opt_input_ts_offset(const char *opt, const char *arg)
2826
{
2827
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2828
    return 0;
2829
}
2830

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

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

    
2852
static void opt_input_file(const char *filename)
2853
{
2854
    AVFormatContext *ic;
2855
    AVFormatParameters params, *ap = &params;
2856
    AVInputFormat *file_iformat = NULL;
2857
    int err, i, ret, rfps, rfps_base;
2858
    int64_t timestamp;
2859

    
2860
    if (last_asked_format) {
2861
        file_iformat = av_find_input_format(last_asked_format);
2862
        last_asked_format = NULL;
2863
    }
2864

    
2865
    if (!strcmp(filename, "-"))
2866
        filename = "pipe:";
2867

    
2868
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2869
                    !strcmp(filename, "/dev/stdin");
2870

    
2871
    /* get default parameters from command line */
2872
    ic = avformat_alloc_context();
2873
    if (!ic) {
2874
        print_error(filename, AVERROR(ENOMEM));
2875
        av_exit(1);
2876
    }
2877

    
2878
    memset(ap, 0, sizeof(*ap));
2879
    ap->prealloced_context = 1;
2880
    ap->sample_rate = audio_sample_rate;
2881
    ap->channels = audio_channels;
2882
    ap->time_base.den = frame_rate.num;
2883
    ap->time_base.num = frame_rate.den;
2884
    ap->width = frame_width + frame_padleft + frame_padright;
2885
    ap->height = frame_height + frame_padtop + frame_padbottom;
2886
    ap->pix_fmt = frame_pix_fmt;
2887
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2888
    ap->channel = video_channel;
2889
    ap->standard = video_standard;
2890

    
2891
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2892

    
2893
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2894
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2895
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2896
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2897

    
2898
    if(pgmyuv_compatibility_hack)
2899
        ic->video_codec_id= CODEC_ID_PGMYUV;
2900

    
2901
    /* open the input file with generic libav function */
2902
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2903
    if (err < 0) {
2904
        print_error(filename, err);
2905
        av_exit(1);
2906
    }
2907
    if(opt_programid) {
2908
        int i;
2909
        for(i=0; i<ic->nb_programs; i++)
2910
            if(ic->programs[i]->id != opt_programid)
2911
                ic->programs[i]->discard = AVDISCARD_ALL;
2912
    }
2913

    
2914
    ic->loop_input = loop_input;
2915

    
2916
    /* If not enough info to get the stream parameters, we decode the
2917
       first frames to get it. (used in mpeg case for example) */
2918
    ret = av_find_stream_info(ic);
2919
    if (ret < 0 && verbose >= 0) {
2920
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2921
        av_exit(1);
2922
    }
2923

    
2924
    timestamp = start_time;
2925
    /* add the stream start time */
2926
    if (ic->start_time != AV_NOPTS_VALUE)
2927
        timestamp += ic->start_time;
2928

    
2929
    /* if seeking requested, we execute it */
2930
    if (start_time != 0) {
2931
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2932
        if (ret < 0) {
2933
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2934
                    filename, (double)timestamp / AV_TIME_BASE);
2935
        }
2936
        /* reset seek info */
2937
        start_time = 0;
2938
    }
2939

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

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

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

    
2983
                    (float)rfps / rfps_base, rfps, rfps_base);
2984
            }
2985
            /* update the current frame rate to match the stream frame rate */
2986
            frame_rate.num = rfps;
2987
            frame_rate.den = rfps_base;
2988

    
2989
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2990
            if(video_disable)
2991
                st->discard= AVDISCARD_ALL;
2992
            else if(video_discard)
2993
                st->discard= video_discard;
2994
            break;
2995
        case CODEC_TYPE_DATA:
2996
            break;
2997
        case CODEC_TYPE_SUBTITLE:
2998
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2999
            if(subtitle_disable)
3000
                st->discard = AVDISCARD_ALL;
3001
            break;
3002
        case CODEC_TYPE_ATTACHMENT:
3003
        case CODEC_TYPE_UNKNOWN:
3004
            nb_icodecs++;
3005
            break;
3006
        default:
3007
            abort();
3008
        }
3009
    }
3010

    
3011
    input_files[nb_input_files] = ic;
3012
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3013
    /* dump the file content */
3014
    if (verbose >= 0)
3015
        dump_format(ic, nb_input_files, filename, 0);
3016

    
3017
    nb_input_files++;
3018

    
3019
    video_channel = 0;
3020

    
3021
    av_freep(&video_codec_name);
3022
    av_freep(&audio_codec_name);
3023
    av_freep(&subtitle_codec_name);
3024
}
3025

    
3026
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3027
                                         int *has_subtitle_ptr)
3028
{
3029
    int has_video, has_audio, has_subtitle, i, j;
3030
    AVFormatContext *ic;
3031

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

    
3063
static void new_video_stream(AVFormatContext *oc)
3064
{
3065
    AVStream *st;
3066
    AVCodecContext *video_enc;
3067
    enum CodecID codec_id;
3068

    
3069
    st = av_new_stream(oc, oc->nb_streams);
3070
    if (!st) {
3071
        fprintf(stderr, "Could not alloc stream\n");
3072
        av_exit(1);
3073
    }
3074
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3075
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3076
    video_bitstream_filters= NULL;
3077

    
3078
    avcodec_thread_init(st->codec, thread_count);
3079

    
3080
    video_enc = st->codec;
3081

    
3082
    if(video_codec_tag)
3083
        video_enc->codec_tag= video_codec_tag;
3084

    
3085
    if(   (video_global_header&1)
3086
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3087
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3088
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3089
    }
3090
    if(video_global_header&2){
3091
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3092
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3093
    }
3094

    
3095
    if (video_stream_copy) {
3096
        st->stream_copy = 1;
3097
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3098
        video_enc->sample_aspect_ratio =
3099
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3100
    } else {
3101
        const char *p;
3102
        int i;
3103
        AVCodec *codec;
3104
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3105

    
3106
        if (video_codec_name) {
3107
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3108
            codec = avcodec_find_encoder_by_name(video_codec_name);
3109
            output_codecs[nb_ocodecs] = codec;
3110
        } else {
3111
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3112
            codec = avcodec_find_encoder(codec_id);
3113
        }
3114

    
3115
        video_enc->codec_id = codec_id;
3116

    
3117
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3118

    
3119
        if (codec && codec->supported_framerates && !force_fps)
3120
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3121
        video_enc->time_base.den = fps.num;
3122
        video_enc->time_base.num = fps.den;
3123

    
3124
        video_enc->width = frame_width + frame_padright + frame_padleft;
3125
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3126
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3127
        video_enc->pix_fmt = frame_pix_fmt;
3128
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3129

    
3130
        if(codec && codec->pix_fmts){
3131
            const enum PixelFormat *p= codec->pix_fmts;
3132
            for(; *p!=-1; p++){
3133
                if(*p == video_enc->pix_fmt)
3134
                    break;
3135
            }
3136
            if(*p == -1)
3137
                video_enc->pix_fmt = codec->pix_fmts[0];
3138
        }
3139

    
3140
        if (intra_only)
3141
            video_enc->gop_size = 0;
3142
        if (video_qscale || same_quality) {
3143
            video_enc->flags |= CODEC_FLAG_QSCALE;
3144
            video_enc->global_quality=
3145
                st->quality = FF_QP2LAMBDA * video_qscale;
3146
        }
3147

    
3148
        if(intra_matrix)
3149
            video_enc->intra_matrix = intra_matrix;
3150
        if(inter_matrix)
3151
            video_enc->inter_matrix = inter_matrix;
3152

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

    
3183
        if (do_psnr)
3184
            video_enc->flags|= CODEC_FLAG_PSNR;
3185

    
3186
        /* two pass mode */
3187
        if (do_pass) {
3188
            if (do_pass == 1) {
3189
                video_enc->flags |= CODEC_FLAG_PASS1;
3190
            } else {
3191
                video_enc->flags |= CODEC_FLAG_PASS2;
3192
            }
3193
        }
3194
    }
3195
    nb_ocodecs++;
3196
    if (video_language) {
3197
        av_metadata_set(&st->metadata, "language", video_language);
3198
        av_freep(&video_language);
3199
    }
3200

    
3201
    /* reset some key parameters */
3202
    video_disable = 0;
3203
    av_freep(&video_codec_name);
3204
    video_stream_copy = 0;
3205
}
3206

    
3207
static void new_audio_stream(AVFormatContext *oc)
3208
{
3209
    AVStream *st;
3210
    AVCodecContext *audio_enc;
3211
    enum CodecID codec_id;
3212

    
3213
    st = av_new_stream(oc, oc->nb_streams);
3214
    if (!st) {
3215
        fprintf(stderr, "Could not alloc stream\n");
3216
        av_exit(1);
3217
    }
3218
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3219

    
3220
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3221
    audio_bitstream_filters= NULL;
3222

    
3223
    avcodec_thread_init(st->codec, thread_count);
3224

    
3225
    audio_enc = st->codec;
3226
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3227

    
3228
    if(audio_codec_tag)
3229
        audio_enc->codec_tag= audio_codec_tag;
3230

    
3231
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3232
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3233
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3234
    }
3235
    if (audio_stream_copy) {
3236
        st->stream_copy = 1;
3237
        audio_enc->channels = audio_channels;
3238
    } else {
3239
        AVCodec *codec;
3240

    
3241
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3242

    
3243
        if (audio_codec_name) {
3244
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3245
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3246
            output_codecs[nb_ocodecs] = codec;
3247
        } else {
3248
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3249
            codec = avcodec_find_encoder(codec_id);
3250
        }
3251
        audio_enc->codec_id = codec_id;
3252

    
3253
        if (audio_qscale > QSCALE_NONE) {
3254
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3255
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3256
        }
3257
        audio_enc->channels = audio_channels;
3258
        audio_enc->sample_fmt = audio_sample_fmt;
3259
        audio_enc->channel_layout = channel_layout;
3260
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3261
            audio_enc->channel_layout = 0;
3262

    
3263
        if(codec && codec->sample_fmts){
3264
            const enum SampleFormat *p= codec->sample_fmts;
3265
            for(; *p!=-1; p++){
3266
                if(*p == audio_enc->sample_fmt)
3267
                    break;
3268
            }
3269
            if(*p == -1)
3270
                audio_enc->sample_fmt = codec->sample_fmts[0];
3271
        }
3272
    }
3273
    nb_ocodecs++;
3274
    audio_enc->sample_rate = audio_sample_rate;
3275
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3276
    if (audio_language) {
3277
        av_metadata_set(&st->metadata, "language", audio_language);
3278
        av_freep(&audio_language);
3279
    }
3280

    
3281
    /* reset some key parameters */
3282
    audio_disable = 0;
3283
    av_freep(&audio_codec_name);
3284
    audio_stream_copy = 0;
3285
}
3286

    
3287
static void new_subtitle_stream(AVFormatContext *oc)
3288
{
3289
    AVStream *st;
3290
    AVCodecContext *subtitle_enc;
3291

    
3292
    st = av_new_stream(oc, oc->nb_streams);
3293
    if (!st) {
3294
        fprintf(stderr, "Could not alloc stream\n");
3295
        av_exit(1);
3296
    }
3297
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3298

    
3299
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3300
    subtitle_bitstream_filters= NULL;
3301

    
3302
    subtitle_enc = st->codec;
3303
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3304

    
3305
    if(subtitle_codec_tag)
3306
        subtitle_enc->codec_tag= subtitle_codec_tag;
3307

    
3308
    if (subtitle_stream_copy) {
3309
        st->stream_copy = 1;
3310
    } else {
3311
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3312
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3313
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3314
    }
3315
    nb_ocodecs++;
3316

    
3317
    if (subtitle_language) {
3318
        av_metadata_set(&st->metadata, "language", subtitle_language);
3319
        av_freep(&subtitle_language);
3320
    }
3321

    
3322
    subtitle_disable = 0;
3323
    av_freep(&subtitle_codec_name);
3324
    subtitle_stream_copy = 0;
3325
}
3326

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

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

    
3349
static void opt_new_subtitle_stream(void)
3350
{
3351
    AVFormatContext *oc;
3352
    if (nb_output_files <= 0) {
3353
        fprintf(stderr, "At least one output file must be specified\n");
3354
        av_exit(1);
3355
    }
3356
    oc = output_files[nb_output_files - 1];
3357
    new_subtitle_stream(oc);
3358
}
3359

    
3360
static void opt_output_file(const char *filename)
3361
{
3362
    AVFormatContext *oc;
3363
    int use_video, use_audio, use_subtitle;
3364
    int input_has_video, input_has_audio, input_has_subtitle;
3365
    AVFormatParameters params, *ap = &params;
3366
    AVOutputFormat *file_oformat;
3367

    
3368
    if (!strcmp(filename, "-"))
3369
        filename = "pipe:";
3370

    
3371
    oc = avformat_alloc_context();
3372
    if (!oc) {
3373
        print_error(filename, AVERROR(ENOMEM));
3374
        av_exit(1);
3375
    }
3376

    
3377
    if (last_asked_format) {
3378
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3379
        if (!file_oformat) {
3380
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3381
            av_exit(1);
3382
        }
3383
        last_asked_format = NULL;
3384
    } else {
3385
        file_oformat = av_guess_format(NULL, filename, NULL);
3386
        if (!file_oformat) {
3387
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3388
                    filename);
3389
            av_exit(1);
3390
        }
3391
    }
3392

    
3393
    oc->oformat = file_oformat;
3394
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3395

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

    
3410
        /* disable if no corresponding type found and at least one
3411
           input file */
3412
        if (nb_input_files > 0) {
3413
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3414
                                         &input_has_subtitle);
3415
            if (!input_has_video)
3416
                use_video = 0;
3417
            if (!input_has_audio)
3418
                use_audio = 0;
3419
            if (!input_has_subtitle)
3420
                use_subtitle = 0;
3421
        }
3422

    
3423
        /* manual disable */
3424
        if (audio_disable) {
3425
            use_audio = 0;
3426
        }
3427
        if (video_disable) {
3428
            use_video = 0;
3429
        }
3430
        if (subtitle_disable) {
3431
            use_subtitle = 0;
3432
        }
3433

    
3434
        if (use_video) {
3435
            new_video_stream(oc);
3436
        }
3437

    
3438
        if (use_audio) {
3439
            new_audio_stream(oc);
3440
        }
3441

    
3442
        if (use_subtitle) {
3443
            new_subtitle_stream(oc);
3444
        }
3445

    
3446
        oc->timestamp = rec_timestamp;
3447

    
3448
        for(; metadata_count>0; metadata_count--){
3449
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3450
                                           metadata[metadata_count-1].value);
3451
        }
3452
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3453
    }
3454

    
3455
    output_files[nb_output_files++] = oc;
3456

    
3457
    /* check filename in case of an image number is expected */
3458
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3459
        if (!av_filename_number_test(oc->filename)) {
3460
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3461
            av_exit(1);
3462
        }
3463
    }
3464

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

    
3487
        /* open the file */
3488
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3489
            fprintf(stderr, "Could not open '%s'\n", filename);
3490
            av_exit(1);
3491
        }
3492
    }
3493

    
3494
    memset(ap, 0, sizeof(*ap));
3495
    if (av_set_parameters(oc, ap) < 0) {
3496
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3497
                oc->filename);
3498
        av_exit(1);
3499
    }
3500

    
3501
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3502
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3503
    oc->loop_output = loop_output;
3504
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3505

    
3506
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3507
}
3508

    
3509
/* same option as mencoder */
3510
static void opt_pass(const char *pass_str)
3511
{
3512
    int pass;
3513
    pass = atoi(pass_str);
3514
    if (pass != 1 && pass != 2) {
3515
        fprintf(stderr, "pass number can be only 1 or 2\n");
3516
        av_exit(1);
3517
    }
3518
    do_pass = pass;
3519
}
3520

    
3521
static int64_t getutime(void)
3522
{
3523
#if HAVE_GETRUSAGE
3524
    struct rusage rusage;
3525

    
3526
    getrusage(RUSAGE_SELF, &rusage);
3527
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3528
#elif HAVE_GETPROCESSTIMES
3529
    HANDLE proc;
3530
    FILETIME c, e, k, u;
3531
    proc = GetCurrentProcess();
3532
    GetProcessTimes(proc, &c, &e, &k, &u);
3533
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3534
#else
3535
    return av_gettime();
3536
#endif
3537
}
3538

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

    
3556
static void opt_inter_matrix(const char *arg)
3557
{
3558
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3559
    parse_matrix_coeffs(inter_matrix, arg);
3560
}
3561

    
3562
static void opt_intra_matrix(const char *arg)
3563
{
3564
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3565
    parse_matrix_coeffs(intra_matrix, arg);
3566
}
3567

    
3568
/**
3569
 * Trivial log callback.
3570
 * Only suitable for show_help and similar since it lacks prefix handling.
3571
 */
3572
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3573
{
3574
    vfprintf(stdout, fmt, vl);
3575
}
3576

    
3577
static void show_usage(void)
3578
{
3579
    printf("Hyper fast Audio and Video encoder\n");
3580
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3581
    printf("\n");
3582
}
3583

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

    
3619
static void opt_target(const char *arg)
3620
{
3621
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3622
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3623

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

    
3668
    if(norm == UNKNOWN) {
3669
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3670
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3671
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3672
        av_exit(1);
3673
    }
3674

    
3675
    if(!strcmp(arg, "vcd")) {
3676

    
3677
        opt_video_codec("mpeg1video");
3678
        opt_audio_codec("mp2");
3679
        opt_format("vcd");
3680

    
3681
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3682
        opt_frame_rate(NULL, frame_rates[norm]);
3683
        opt_default("g", norm == PAL ? "15" : "18");
3684

    
3685
        opt_default("b", "1150000");
3686
        opt_default("maxrate", "1150000");
3687
        opt_default("minrate", "1150000");
3688
        opt_default("bufsize", "327680"); // 40*1024*8;
3689

    
3690
        opt_default("ab", "224000");
3691
        audio_sample_rate = 44100;
3692
        audio_channels = 2;
3693

    
3694
        opt_default("packetsize", "2324");
3695
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3696

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

    
3705
        opt_video_codec("mpeg2video");
3706
        opt_audio_codec("mp2");
3707
        opt_format("svcd");
3708

    
3709
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3710
        opt_frame_rate(NULL, frame_rates[norm]);
3711
        opt_default("g", norm == PAL ? "15" : "18");
3712

    
3713
        opt_default("b", "2040000");
3714
        opt_default("maxrate", "2516000");
3715
        opt_default("minrate", "0"); //1145000;
3716
        opt_default("bufsize", "1835008"); //224*1024*8;
3717
        opt_default("flags", "+scan_offset");
3718

    
3719

    
3720
        opt_default("ab", "224000");
3721
        audio_sample_rate = 44100;
3722

    
3723
        opt_default("packetsize", "2324");
3724

    
3725
    } else if(!strcmp(arg, "dvd")) {
3726

    
3727
        opt_video_codec("mpeg2video");
3728
        opt_audio_codec("ac3");
3729
        opt_format("dvd");
3730

    
3731
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3732
        opt_frame_rate(NULL, frame_rates[norm]);
3733
        opt_default("g", norm == PAL ? "15" : "18");
3734

    
3735
        opt_default("b", "6000000");
3736
        opt_default("maxrate", "9000000");
3737
        opt_default("minrate", "0"); //1500000;
3738
        opt_default("bufsize", "1835008"); //224*1024*8;
3739

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

    
3743
        opt_default("ab", "448000");
3744
        audio_sample_rate = 48000;
3745

    
3746
    } else if(!strncmp(arg, "dv", 2)) {
3747

    
3748
        opt_format("dv");
3749

    
3750
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3751
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3752
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3753
        opt_frame_rate(NULL, frame_rates[norm]);
3754

    
3755
        audio_sample_rate = 48000;
3756
        audio_channels = 2;
3757

    
3758
    } else {
3759
        fprintf(stderr, "Unknown target: %s\n", arg);
3760
        av_exit(1);
3761
    }
3762
}
3763

    
3764
static void opt_vstats_file (const char *arg)
3765
{
3766
    av_free (vstats_filename);
3767
    vstats_filename=av_strdup (arg);
3768
}
3769

    
3770
static void opt_vstats (void)
3771
{
3772
    char filename[40];
3773
    time_t today2 = time(NULL);
3774
    struct tm *today = localtime(&today2);
3775

    
3776
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3777
             today->tm_sec);
3778
    opt_vstats_file(filename);
3779
}
3780

    
3781
static int opt_bsf(const char *opt, const char *arg)
3782
{
3783
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3784
    AVBitStreamFilterContext **bsfp;
3785

    
3786
    if(!bsfc){
3787
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3788
        av_exit(1);
3789
    }
3790

    
3791
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3792
          *opt == 'a' ? &audio_bitstream_filters :
3793
                        &subtitle_bitstream_filters;
3794
    while(*bsfp)
3795
        bsfp= &(*bsfp)->next;
3796

    
3797
    *bsfp= bsfc;
3798

    
3799
    return 0;
3800
}
3801

    
3802
static int opt_preset(const char *opt, const char *arg)
3803
{
3804
    FILE *f=NULL;
3805
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3806
    int i;
3807
    const char *base[2]= { getenv("HOME"),
3808
                           FFMPEG_DATADIR,
3809
                         };
3810

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

    
3828
    if(!f){
3829
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3830
        av_exit(1);
3831
    }
3832

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

    
3854
    fclose(f);
3855

    
3856
    return 0;
3857
}
3858

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

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

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

    
3956
    /* subtitle options */
3957
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3958
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3959
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3960
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3961
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3962

    
3963
    /* grab options */
3964
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3965
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3966
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3967

    
3968
    /* muxer options */
3969
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3970
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3971

    
3972
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3973
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3974
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3975

    
3976
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3977
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3978
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3979
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3980

    
3981
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3982
    { NULL, },
3983
};
3984

    
3985
int main(int argc, char **argv)
3986
{
3987
    int i;
3988
    int64_t ti;
3989

    
3990
    avcodec_register_all();
3991
    avdevice_register_all();
3992
    av_register_all();
3993

    
3994
#if HAVE_ISATTY
3995
    if(isatty(STDIN_FILENO))
3996
        url_set_interrupt_cb(decode_interrupt_cb);
3997
#endif
3998

    
3999
    for(i=0; i<CODEC_TYPE_NB; i++){
4000
        avcodec_opts[i]= avcodec_alloc_context2(i);
4001
    }
4002
    avformat_opts = avformat_alloc_context();
4003
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4004

    
4005
    show_banner();
4006

    
4007
    /* parse options */
4008
    parse_options(argc, argv, options, opt_output_file);
4009

    
4010
    if(nb_output_files <= 0 && nb_input_files == 0) {
4011
        show_usage();
4012
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4013
        av_exit(1);
4014
    }
4015

    
4016
    /* file converter / grab */
4017
    if (nb_output_files <= 0) {
4018
        fprintf(stderr, "At least one output file must be specified\n");
4019
        av_exit(1);
4020
    }
4021

    
4022
    if (nb_input_files == 0) {
4023
        fprintf(stderr, "At least one input file must be specified\n");
4024
        av_exit(1);
4025
    }
4026

    
4027
    ti = getutime();
4028
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4029
                  stream_maps, nb_stream_maps) < 0)
4030
        av_exit(1);
4031
    ti = getutime() - ti;
4032
    if (do_benchmark) {
4033
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4034
    }
4035

    
4036
    return av_exit(0);
4037
}