Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 43d160fd

History | View | Annotate | Download (144 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

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

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

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

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

    
66
#include "cmdutils.h"
67

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

    
71
#undef exit
72

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

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

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

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

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

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

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

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

    
112
static AVInputFormat *file_iformat;
113
static AVOutputFormat *file_oformat;
114
static int frame_width  = 0;
115
static int frame_height = 0;
116
static float frame_aspect_ratio = 0;
117
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
118
static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
119
static int frame_padtop  = 0;
120
static int frame_padbottom = 0;
121
static int frame_padleft  = 0;
122
static int frame_padright = 0;
123
static int padcolor[3] = {16,128,128}; /* default to black */
124
static int frame_topBand  = 0;
125
static int frame_bottomBand = 0;
126
static int frame_leftBand  = 0;
127
static int frame_rightBand = 0;
128
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
129
static AVRational frame_rate;
130
static float video_qscale = 0;
131
static uint16_t *intra_matrix = NULL;
132
static uint16_t *inter_matrix = NULL;
133
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 int same_quality = 0;
139
static int do_deinterlace = 0;
140
static int top_field_first = -1;
141
static int me_threshold = 0;
142
static int intra_dc_precision = 8;
143
static int loop_input = 0;
144
static int loop_output = AVFMT_NOOUTPUTLOOP;
145
static int qp_hist = 0;
146

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

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

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

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

    
193
static int rate_emu = 0;
194

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

    
198
static int audio_volume = 256;
199

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

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

    
217
static unsigned int sws_flags = SWS_BICUBIC;
218

    
219
static int64_t timer_start;
220

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

    
225
static short *samples;
226

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

    
232
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
233

    
234
struct AVInputStream;
235

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

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

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

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

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

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

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

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

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

    
311
#if HAVE_TERMIOS_H
312

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

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

    
324
static volatile int received_sigterm = 0;
325

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
435
    av_free(opt_names);
436

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

    
441
    av_free(video_standard);
442

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
543
        bsfc= bsfc->next;
544
    }
545

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

    
553
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
554

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
885
    *frame_size = 0;
886

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1148

    
1149
    oc = output_files[0];
1150

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

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

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

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

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

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

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

    
1229
        fflush(stderr);
1230
    }
1231

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1438
                        av_init_packet(&opkt);
1439

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1626
    return -1;
1627
}
1628

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2094

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

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

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

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

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

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

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

    
2155
    timer_start = av_gettime();
2156

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2295
    discard_packet:
2296
        av_free_packet(&pkt);
2297

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

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

    
2310
    term_exit();
2311

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

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

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

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

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

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

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

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

    
2387
    file_iformat = av_find_input_format(arg);
2388
    file_oformat = guess_format(arg, NULL, NULL);
2389
    if (!file_iformat && !file_oformat) {
2390
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2391
        av_exit(1);
2392
    }
2393
}
2394

    
2395
static void opt_video_rc_override_string(const char *arg)
2396
{
2397
    video_rc_override_string = arg;
2398
}
2399

    
2400
static int opt_me_threshold(const char *opt, const char *arg)
2401
{
2402
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2403
    return 0;
2404
}
2405

    
2406
static int opt_verbose(const char *opt, const char *arg)
2407
{
2408
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2409
    return 0;
2410
}
2411

    
2412
static int opt_frame_rate(const char *opt, const char *arg)
2413
{
2414
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2415
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2416
        av_exit(1);
2417
    }
2418
    return 0;
2419
}
2420

    
2421
static int opt_bitrate(const char *opt, const char *arg)
2422
{
2423
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2424

    
2425
    opt_default(opt, arg);
2426

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

    
2430
    return 0;
2431
}
2432

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

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

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

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

    
2489
static void opt_frame_size(const char *arg)
2490
{
2491
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2492
        fprintf(stderr, "Incorrect frame size\n");
2493
        av_exit(1);
2494
    }
2495
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2496
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2497
        av_exit(1);
2498
    }
2499
}
2500

    
2501
static void opt_pad_color(const char *arg) {
2502
    /* Input is expected to be six hex digits similar to
2503
       how colors are expressed in html tags (but without the #) */
2504
    int rgb = strtol(arg, NULL, 16);
2505
    int r,g,b;
2506

    
2507
    r = (rgb >> 16);
2508
    g = ((rgb >> 8) & 255);
2509
    b = (rgb & 255);
2510

    
2511
    padcolor[0] = RGB_TO_Y(r,g,b);
2512
    padcolor[1] = RGB_TO_U(r,g,b,0);
2513
    padcolor[2] = RGB_TO_V(r,g,b,0);
2514
}
2515

    
2516
static void opt_frame_pad_top(const char *arg)
2517
{
2518
    frame_padtop = atoi(arg);
2519
    if (frame_padtop < 0) {
2520
        fprintf(stderr, "Incorrect top pad size\n");
2521
        av_exit(1);
2522
    }
2523
}
2524

    
2525
static void opt_frame_pad_bottom(const char *arg)
2526
{
2527
    frame_padbottom = atoi(arg);
2528
    if (frame_padbottom < 0) {
2529
        fprintf(stderr, "Incorrect bottom pad size\n");
2530
        av_exit(1);
2531
    }
2532
}
2533

    
2534

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

    
2544

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

    
2554
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2555
{
2556
    int i;
2557
    char fmt_str[128];
2558
    for (i=-1; i < nb_fmts; i++) {
2559
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2560
        fprintf(stdout, "%s\n", fmt_str);
2561
    }
2562
}
2563

    
2564
static void opt_frame_pix_fmt(const char *arg)
2565
{
2566
    if (strcmp(arg, "list")) {
2567
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2568
        if (frame_pix_fmt == PIX_FMT_NONE) {
2569
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2570
            av_exit(1);
2571
        }
2572
    } else {
2573
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2574
        av_exit(0);
2575
    }
2576
}
2577

    
2578
static void opt_frame_aspect_ratio(const char *arg)
2579
{
2580
    int x = 0, y = 0;
2581
    double ar = 0;
2582
    const char *p;
2583
    char *end;
2584

    
2585
    p = strchr(arg, ':');
2586
    if (p) {
2587
        x = strtol(arg, &end, 10);
2588
        if (end == p)
2589
            y = strtol(end+1, &end, 10);
2590
        if (x > 0 && y > 0)
2591
            ar = (double)x / (double)y;
2592
    } else
2593
        ar = strtod(arg, NULL);
2594

    
2595
    if (!ar) {
2596
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2597
        av_exit(1);
2598
    }
2599
    frame_aspect_ratio = ar;
2600
}
2601

    
2602
static int opt_metadata(const char *opt, const char *arg)
2603
{
2604
    char *mid= strchr(arg, '=');
2605

    
2606
    if(!mid){
2607
        fprintf(stderr, "Missing =\n");
2608
        av_exit(1);
2609
    }
2610
    *mid++= 0;
2611

    
2612
    metadata_count++;
2613
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2614
    metadata[metadata_count-1].key  = av_strdup(arg);
2615
    metadata[metadata_count-1].value= av_strdup(mid);
2616

    
2617
    return 0;
2618
}
2619

    
2620
static void opt_qscale(const char *arg)
2621
{
2622
    video_qscale = atof(arg);
2623
    if (video_qscale <= 0 ||
2624
        video_qscale > 255) {
2625
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2626
        av_exit(1);
2627
    }
2628
}
2629

    
2630
static void opt_top_field_first(const char *arg)
2631
{
2632
    top_field_first= atoi(arg);
2633
}
2634

    
2635
static int opt_thread_count(const char *opt, const char *arg)
2636
{
2637
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2638
#if !HAVE_THREADS
2639
    if (verbose >= 0)
2640
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2641
#endif
2642
    return 0;
2643
}
2644

    
2645
static void opt_audio_sample_fmt(const char *arg)
2646
{
2647
    if (strcmp(arg, "list"))
2648
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2649
    else {
2650
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2651
        av_exit(0);
2652
    }
2653
}
2654

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

    
2661
static int opt_audio_channels(const char *opt, const char *arg)
2662
{
2663
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2664
    return 0;
2665
}
2666

    
2667
static void opt_video_channel(const char *arg)
2668
{
2669
    video_channel = strtol(arg, NULL, 0);
2670
}
2671

    
2672
static void opt_video_standard(const char *arg)
2673
{
2674
    video_standard = av_strdup(arg);
2675
}
2676

    
2677
static void opt_codec(int *pstream_copy, char **pcodec_name,
2678
                      int codec_type, const char *arg)
2679
{
2680
    av_freep(pcodec_name);
2681
    if (!strcmp(arg, "copy")) {
2682
        *pstream_copy = 1;
2683
    } else {
2684
        *pcodec_name = av_strdup(arg);
2685
    }
2686
}
2687

    
2688
static void opt_audio_codec(const char *arg)
2689
{
2690
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2691
}
2692

    
2693
static void opt_audio_tag(const char *arg)
2694
{
2695
    char *tail;
2696
    audio_codec_tag= strtol(arg, &tail, 0);
2697

    
2698
    if(!tail || *tail)
2699
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2700
}
2701

    
2702
static void opt_video_tag(const char *arg)
2703
{
2704
    char *tail;
2705
    video_codec_tag= strtol(arg, &tail, 0);
2706

    
2707
    if(!tail || *tail)
2708
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2709
}
2710

    
2711
static void opt_video_codec(const char *arg)
2712
{
2713
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2714
}
2715

    
2716
static void opt_subtitle_codec(const char *arg)
2717
{
2718
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2719
}
2720

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

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

    
2730
static void opt_map(const char *arg)
2731
{
2732
    AVStreamMap *m;
2733
    char *p;
2734

    
2735
    m = &stream_maps[nb_stream_maps++];
2736

    
2737
    m->file_index = strtol(arg, &p, 0);
2738
    if (*p)
2739
        p++;
2740

    
2741
    m->stream_index = strtol(p, &p, 0);
2742
    if (*p) {
2743
        p++;
2744
        m->sync_file_index = strtol(p, &p, 0);
2745
        if (*p)
2746
            p++;
2747
        m->sync_stream_index = strtol(p, &p, 0);
2748
    } else {
2749
        m->sync_file_index = m->file_index;
2750
        m->sync_stream_index = m->stream_index;
2751
    }
2752
}
2753

    
2754
static void opt_map_meta_data(const char *arg)
2755
{
2756
    AVMetaDataMap *m;
2757
    char *p;
2758

    
2759
    m = &meta_data_maps[nb_meta_data_maps++];
2760

    
2761
    m->out_file = strtol(arg, &p, 0);
2762
    if (*p)
2763
        p++;
2764

    
2765
    m->in_file = strtol(p, &p, 0);
2766
}
2767

    
2768
static void opt_input_ts_scale(const char *arg)
2769
{
2770
    unsigned int stream;
2771
    double scale;
2772
    char *p;
2773

    
2774
    stream = strtol(arg, &p, 0);
2775
    if (*p)
2776
        p++;
2777
    scale= strtod(p, &p);
2778

    
2779
    if(stream >= MAX_STREAMS)
2780
        av_exit(1);
2781

    
2782
    input_files_ts_scale[nb_input_files][stream]= scale;
2783
}
2784

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

    
2791
static int opt_start_time(const char *opt, const char *arg)
2792
{
2793
    start_time = parse_time_or_die(opt, arg, 1);
2794
    return 0;
2795
}
2796

    
2797
static int opt_rec_timestamp(const char *opt, const char *arg)
2798
{
2799
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2800
    return 0;
2801
}
2802

    
2803
static int opt_input_ts_offset(const char *opt, const char *arg)
2804
{
2805
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2806
    return 0;
2807
}
2808

    
2809
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2810
{
2811
    const char *codec_string = encoder ? "encoder" : "decoder";
2812
    AVCodec *codec;
2813

    
2814
    if(!name)
2815
        return CODEC_ID_NONE;
2816
    codec = encoder ?
2817
        avcodec_find_encoder_by_name(name) :
2818
        avcodec_find_decoder_by_name(name);
2819
    if(!codec) {
2820
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2821
        av_exit(1);
2822
    }
2823
    if(codec->type != type) {
2824
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2825
        av_exit(1);
2826
    }
2827
    return codec->id;
2828
}
2829

    
2830
static void opt_input_file(const char *filename)
2831
{
2832
    AVFormatContext *ic;
2833
    AVFormatParameters params, *ap = &params;
2834
    int err, i, ret, rfps, rfps_base;
2835
    int64_t timestamp;
2836

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

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

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

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

    
2867
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2868

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

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

    
2887
    ic->loop_input = loop_input;
2888

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

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

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

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

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

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

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

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

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

    
2987
    nb_input_files++;
2988
    file_iformat = NULL;
2989
    file_oformat = NULL;
2990

    
2991
    video_channel = 0;
2992

    
2993
    av_freep(&video_codec_name);
2994
    av_freep(&audio_codec_name);
2995
    av_freep(&subtitle_codec_name);
2996
}
2997

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

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

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

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

    
3050
    if(thread_count>1)
3051
        avcodec_thread_init(st->codec, thread_count);
3052

    
3053
    video_enc = st->codec;
3054

    
3055
    if(video_codec_tag)
3056
        video_enc->codec_tag= video_codec_tag;
3057

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

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

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

    
3088
        video_enc->codec_id = codec_id;
3089

    
3090
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3091

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

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

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

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

    
3121
        if(intra_matrix)
3122
            video_enc->intra_matrix = intra_matrix;
3123
        if(inter_matrix)
3124
            video_enc->inter_matrix = inter_matrix;
3125

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

    
3157
        if (do_psnr)
3158
            video_enc->flags|= CODEC_FLAG_PSNR;
3159

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

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

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

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

    
3190
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3191
    audio_bitstream_filters= NULL;
3192

    
3193
    if(thread_count>1)
3194
        avcodec_thread_init(st->codec, thread_count);
3195

    
3196
    audio_enc = st->codec;
3197
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3198

    
3199
    if(audio_codec_tag)
3200
        audio_enc->codec_tag= audio_codec_tag;
3201

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

    
3212
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3213

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

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

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

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

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

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

    
3272
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3273
    subtitle_bitstream_filters= NULL;
3274

    
3275
    subtitle_enc = st->codec;
3276
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3277

    
3278
    if(subtitle_codec_tag)
3279
        subtitle_enc->codec_tag= subtitle_codec_tag;
3280

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

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

    
3296
    subtitle_disable = 0;
3297
    av_freep(&subtitle_codec_name);
3298
    subtitle_stream_copy = 0;
3299
}
3300

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

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

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

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

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

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

    
3350
    if (!file_oformat) {
3351
        file_oformat = guess_format(NULL, filename, NULL);
3352
        if (!file_oformat) {
3353
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3354
                    filename);
3355
            av_exit(1);
3356
        }
3357
    }
3358

    
3359
    oc->oformat = file_oformat;
3360
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3361

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

    
3376
        /* disable if no corresponding type found and at least one
3377
           input file */
3378
        if (nb_input_files > 0) {
3379
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3380
                                         &input_has_subtitle);
3381
            if (!input_has_video)
3382
                use_video = 0;
3383
            if (!input_has_audio)
3384
                use_audio = 0;
3385
            if (!input_has_subtitle)
3386
                use_subtitle = 0;
3387
        }
3388

    
3389
        /* manual disable */
3390
        if (audio_disable) {
3391
            use_audio = 0;
3392
        }
3393
        if (video_disable) {
3394
            use_video = 0;
3395
        }
3396
        if (subtitle_disable) {
3397
            use_subtitle = 0;
3398
        }
3399

    
3400
        if (use_video) {
3401
            new_video_stream(oc);
3402
        }
3403

    
3404
        if (use_audio) {
3405
            new_audio_stream(oc);
3406
        }
3407

    
3408
        if (use_subtitle) {
3409
            new_subtitle_stream(oc);
3410
        }
3411

    
3412
        oc->timestamp = rec_timestamp;
3413

    
3414
        for(; metadata_count>0; metadata_count--){
3415
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3416
                                           metadata[metadata_count-1].value);
3417
        }
3418
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3419
    }
3420

    
3421
    output_files[nb_output_files++] = oc;
3422

    
3423
    /* check filename in case of an image number is expected */
3424
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3425
        if (!av_filename_number_test(oc->filename)) {
3426
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3427
            av_exit(1);
3428
        }
3429
    }
3430

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

    
3453
        /* open the file */
3454
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3455
            fprintf(stderr, "Could not open '%s'\n", filename);
3456
            av_exit(1);
3457
        }
3458
    }
3459

    
3460
    memset(ap, 0, sizeof(*ap));
3461
    if (av_set_parameters(oc, ap) < 0) {
3462
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3463
                oc->filename);
3464
        av_exit(1);
3465
    }
3466

    
3467
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3468
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3469
    oc->loop_output = loop_output;
3470
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3471

    
3472
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3473

    
3474
    /* reset some options */
3475
    file_oformat = NULL;
3476
    file_iformat = NULL;
3477
}
3478

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

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

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

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

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

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

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

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

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

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

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

    
3640
    if(!strcmp(arg, "vcd")) {
3641

    
3642
        opt_video_codec("mpeg1video");
3643
        opt_audio_codec("mp2");
3644
        opt_format("vcd");
3645

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

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

    
3655
        opt_default("ab", "224000");
3656
        audio_sample_rate = 44100;
3657
        audio_channels = 2;
3658

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

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

    
3670
        opt_video_codec("mpeg2video");
3671
        opt_audio_codec("mp2");
3672
        opt_format("svcd");
3673

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

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

    
3684

    
3685
        opt_default("ab", "224000");
3686
        audio_sample_rate = 44100;
3687

    
3688
        opt_default("packetsize", "2324");
3689

    
3690
    } else if(!strcmp(arg, "dvd")) {
3691

    
3692
        opt_video_codec("mpeg2video");
3693
        opt_audio_codec("ac3");
3694
        opt_format("dvd");
3695

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

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

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

    
3708
        opt_default("ab", "448000");
3709
        audio_sample_rate = 48000;
3710

    
3711
    } else if(!strncmp(arg, "dv", 2)) {
3712

    
3713
        opt_format("dv");
3714

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

    
3720
        audio_sample_rate = 48000;
3721
        audio_channels = 2;
3722

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

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

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

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

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

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

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

    
3762
    *bsfp= bsfc;
3763

    
3764
    return 0;
3765
}
3766

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

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

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

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

    
3819
    fclose(f);
3820

    
3821
    return 0;
3822
}
3823

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

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

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

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

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

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

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

    
3943
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3944
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3945
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3946

    
3947
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3948
    { NULL, },
3949
};
3950

    
3951
int main(int argc, char **argv)
3952
{
3953
    int i;
3954
    int64_t ti;
3955

    
3956
    avcodec_register_all();
3957
    avdevice_register_all();
3958
    av_register_all();
3959

    
3960
#if HAVE_ISATTY
3961
    if(isatty(STDIN_FILENO))
3962
        url_set_interrupt_cb(decode_interrupt_cb);
3963
#endif
3964

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

    
3971
    show_banner();
3972

    
3973
    /* parse options */
3974
    parse_options(argc, argv, options, opt_output_file);
3975

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

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

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

    
3996
    return av_exit(0);
3997
}