Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 7f4fca03

History | View | Annotate | Download (143 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
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
487
        s->streams[i] = st;
488

    
489
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
490
            st->stream_copy = 1;
491
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
492
            st->stream_copy = 1;
493

    
494
        if(!st->codec->thread_count)
495
            st->codec->thread_count = 1;
496
        if(st->codec->thread_count>1)
497
            avcodec_thread_init(st->codec, st->codec->thread_count);
498

    
499
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
500
            nopts = 1;
501
    }
502

    
503
    if (!nopts)
504
        s->timestamp = av_gettime();
505

    
506
    av_close_input_file(ic);
507
    return 0;
508
}
509

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

    
517
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
518
    int ret;
519

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

    
539
        bsfc= bsfc->next;
540
    }
541

    
542
    ret= av_interleaved_write_frame(s, pkt);
543
    if(ret < 0){
544
        print_error("av_interleaved_write_frame()", ret);
545
        av_exit(1);
546
    }
547
}
548

    
549
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
550

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

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

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

    
573
    if (enc->channels != dec->channels)
574
        ost->audio_resample = 1;
575

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

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

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

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

    
633
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
634
                        ist->is_start=0;
635
                    else
636
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
637

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

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

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

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

    
694
        frame_bytes = enc->frame_size * osize * enc->channels;
695

    
696
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
697
            AVPacket pkt;
698
            av_init_packet(&pkt);
699

    
700
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
701

    
702
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
703

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

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

    
726
        ost->sync_opts += size_out / (osize * enc->channels);
727

    
728
        /* output a pcm frame */
729
        /* determine the size of the coded buffer */
730
        size_out /= osize;
731
        if (coded_bps)
732
            size_out *= coded_bps;
733

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

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

    
759
    dec = ist->st->codec;
760

    
761
    /* deinterlace : must be done before any resize */
762
    if (do_deinterlace) {
763
        int size;
764

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

    
771
        picture2 = &picture_tmp;
772
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
773

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

    
786
    if (picture != picture2)
787
        *picture = *picture2;
788
    *bufp = buf;
789
}
790

    
791
/* we begin to correct av delay at this threshold */
792
#define AV_DELAY_MAX 0.100
793

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

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

    
813
    enc = ost->st->codec;
814

    
815
    if (!subtitle_out) {
816
        subtitle_out = av_malloc(subtitle_out_max_size);
817
    }
818

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

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

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

    
857
static int bit_buffer_size= 1024*256;
858
static uint8_t *bit_buffer= NULL;
859

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

    
872
    avcodec_get_frame_defaults(&picture_crop_temp);
873
    avcodec_get_frame_defaults(&picture_pad_temp);
874

    
875
    enc = ost->st->codec;
876
    dec = ist->st->codec;
877

    
878
    /* by default, we output a single frame */
879
    nb_frames = 1;
880

    
881
    *frame_size = 0;
882

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

    
909
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
910
    if (nb_frames <= 0)
911
        return;
912

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

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

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

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

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

    
961
            ost->topBand    = topBand;
962
            ost->bottomBand = bottomBand;
963
            ost->leftBand   = leftBand;
964
            ost->rightBand  = rightBand;
965

    
966
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
967
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
968
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
969

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

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

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

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

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

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

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

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

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

    
1076
static double psnr(double d){
1077
    return -10.0*log(d)/log(10.0);
1078
}
1079

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

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

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

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

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

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

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

    
1144

    
1145
    oc = output_files[0];
1146

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

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

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

    
1211
    if (verbose || is_last_report) {
1212
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1213

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

    
1218
        if (verbose > 1)
1219
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1220
                  nb_frames_dup, nb_frames_drop);
1221

    
1222
        if (verbose >= 0)
1223
            fprintf(stderr, "%s    \r", buf);
1224

    
1225
        fflush(stderr);
1226
    }
1227

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

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

    
1257
    if(ist->next_pts == AV_NOPTS_VALUE)
1258
        ist->next_pts= ist->pts;
1259

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

    
1270
    if(pkt->dts != AV_NOPTS_VALUE)
1271
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1272

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

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

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

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

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

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

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

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

    
1403
                ost = ost_table[i];
1404
                if (ost->source_index == ist_index) {
1405
                    os = output_files[ost->file_index];
1406

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

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

    
1432
                        av_init_packet(&opkt);
1433

    
1434
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1435
                            continue;
1436

    
1437
                        /* no reencoding needed : output the packet directly */
1438
                        /* force the input stream PTS */
1439

    
1440
                        avcodec_get_frame_defaults(&avframe);
1441
                        ost->st->codec->coded_frame= &avframe;
1442
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1443

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

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

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

    
1463
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1464
                        opkt.flags= pkt->flags;
1465

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

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

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

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

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

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

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

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

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

    
1583
    return 0;
1584
 fail_decode:
1585
    return -1;
1586
}
1587

    
1588
static void print_sdp(AVFormatContext **avc, int n)
1589
{
1590
    char sdp[2048];
1591

    
1592
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1593
    printf("SDP:\n%s\n", sdp);
1594
    fflush(stdout);
1595
}
1596

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

    
1620
    return -1;
1621
}
1622

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

    
1644
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1645
    if (!file_table)
1646
        goto fail;
1647

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

    
1658
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1659
    if (!ist_table)
1660
        goto fail;
1661

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

    
1679
            if (rate_emu) {
1680
                ist->start = av_gettime();
1681
            }
1682
        }
1683
    }
1684

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

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

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

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

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

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

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

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

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

    
1810
        codec = ost->st->codec;
1811
        icodec = ist->st->codec;
1812

    
1813
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1814
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1815
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1816

    
1817
        ost->st->disposition = ist->st->disposition;
1818
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1819
        codec->chroma_sample_location = icodec->chroma_sample_location;
1820

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

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

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

    
1935
                    ost->original_height = icodec->height;
1936
                    ost->original_width  = icodec->width;
1937

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

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

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

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

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

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

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

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

    
2085
        out_file = output_files[out_file_index];
2086
        in_file = input_files[in_file_index];
2087

    
2088

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

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

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

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

    
2134
    if (ret) {
2135
        fprintf(stderr, "%s\n", error);
2136
        goto fail;
2137
    }
2138

    
2139
    if (want_sdp) {
2140
        print_sdp(output_files, nb_output_files);
2141
    }
2142

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

    
2149
    timer_start = av_gettime();
2150

    
2151
    for(; received_sigterm == 0;) {
2152
        int file_index, ist_index;
2153
        AVPacket pkt;
2154
        double ipts_min;
2155
        double opts_min;
2156

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

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

    
2211
        /* finish if recording time exhausted */
2212
        if (opts_min >= (recording_time / 1000000.0))
2213
            break;
2214

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

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

    
2235
        no_packet_count=0;
2236
        memset(no_packet, 0, sizeof(no_packet));
2237

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

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

    
2255
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2256
            if(pkt.pts != AV_NOPTS_VALUE)
2257
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2258
            if(pkt.dts != AV_NOPTS_VALUE)
2259
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2260
        }
2261

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

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

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

    
2289
    discard_packet:
2290
        av_free_packet(&pkt);
2291

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

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

    
2304
    term_exit();
2305

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

    
2312
    /* dump report by using the first video and audio streams */
2313
    print_report(output_files, ost_table, nb_ostreams, 1);
2314

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

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

    
2332
    /* finished ! */
2333
    ret = 0;
2334

    
2335
 fail:
2336
    av_freep(&bit_buffer);
2337
    av_free(file_table);
2338

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

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

    
2381
    file_iformat = av_find_input_format(arg);
2382
    file_oformat = guess_format(arg, NULL, NULL);
2383
    if (!file_iformat && !file_oformat) {
2384
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2385
        av_exit(1);
2386
    }
2387
}
2388

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

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

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

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

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

    
2419
    opt_default(opt, arg);
2420

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

    
2424
    return 0;
2425
}
2426

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

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

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

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

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

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

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

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

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

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

    
2528

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

    
2538

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

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

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

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

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

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

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

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

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

    
2611
    return 0;
2612
}
2613

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2831
    if (!strcmp(filename, "-"))
2832
        filename = "pipe:";
2833

    
2834
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2835
                    !strcmp(filename, "/dev/stdin");
2836

    
2837
    /* get default parameters from command line */
2838
    ic = avformat_alloc_context();
2839

    
2840
    memset(ap, 0, sizeof(*ap));
2841
    ap->prealloced_context = 1;
2842
    ap->sample_rate = audio_sample_rate;
2843
    ap->channels = audio_channels;
2844
    ap->time_base.den = frame_rate.num;
2845
    ap->time_base.num = frame_rate.den;
2846
    ap->width = frame_width + frame_padleft + frame_padright;
2847
    ap->height = frame_height + frame_padtop + frame_padbottom;
2848
    ap->pix_fmt = frame_pix_fmt;
2849
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2850
    ap->channel = video_channel;
2851
    ap->standard = video_standard;
2852
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2853
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2854
    if(pgmyuv_compatibility_hack)
2855
        ap->video_codec_id= CODEC_ID_PGMYUV;
2856

    
2857
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2858

    
2859
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2860
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2861
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2862
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2863

    
2864
    /* open the input file with generic libav function */
2865
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2866
    if (err < 0) {
2867
        print_error(filename, err);
2868
        av_exit(1);
2869
    }
2870
    if(opt_programid) {
2871
        int i;
2872
        for(i=0; i<ic->nb_programs; i++)
2873
            if(ic->programs[i]->id != opt_programid)
2874
                ic->programs[i]->discard = AVDISCARD_ALL;
2875
    }
2876

    
2877
    ic->loop_input = loop_input;
2878

    
2879
    /* If not enough info to get the stream parameters, we decode the
2880
       first frames to get it. (used in mpeg case for example) */
2881
    ret = av_find_stream_info(ic);
2882
    if (ret < 0 && verbose >= 0) {
2883
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2884
        av_exit(1);
2885
    }
2886

    
2887
    timestamp = start_time;
2888
    /* add the stream start time */
2889
    if (ic->start_time != AV_NOPTS_VALUE)
2890
        timestamp += ic->start_time;
2891

    
2892
    /* if seeking requested, we execute it */
2893
    if (start_time != 0) {
2894
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2895
        if (ret < 0) {
2896
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2897
                    filename, (double)timestamp / AV_TIME_BASE);
2898
        }
2899
        /* reset seek info */
2900
        start_time = 0;
2901
    }
2902

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

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

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

    
2943
                    (float)rfps / rfps_base, rfps, rfps_base);
2944
            }
2945
            /* update the current frame rate to match the stream frame rate */
2946
            frame_rate.num = rfps;
2947
            frame_rate.den = rfps_base;
2948

    
2949
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2950
            if(video_disable)
2951
                ic->streams[i]->discard= AVDISCARD_ALL;
2952
            else if(video_discard)
2953
                ic->streams[i]->discard= video_discard;
2954
            break;
2955
        case CODEC_TYPE_DATA:
2956
            break;
2957
        case CODEC_TYPE_SUBTITLE:
2958
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2959
            if(subtitle_disable)
2960
                ic->streams[i]->discard = AVDISCARD_ALL;
2961
            break;
2962
        case CODEC_TYPE_ATTACHMENT:
2963
        case CODEC_TYPE_UNKNOWN:
2964
            nb_icodecs++;
2965
            break;
2966
        default:
2967
            abort();
2968
        }
2969
    }
2970

    
2971
    input_files[nb_input_files] = ic;
2972
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2973
    /* dump the file content */
2974
    if (verbose >= 0)
2975
        dump_format(ic, nb_input_files, filename, 0);
2976

    
2977
    nb_input_files++;
2978
    file_iformat = NULL;
2979
    file_oformat = NULL;
2980

    
2981
    video_channel = 0;
2982

    
2983
    av_freep(&video_codec_name);
2984
    av_freep(&audio_codec_name);
2985
    av_freep(&subtitle_codec_name);
2986
}
2987

    
2988
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2989
                                         int *has_subtitle_ptr)
2990
{
2991
    int has_video, has_audio, has_subtitle, i, j;
2992
    AVFormatContext *ic;
2993

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

    
3025
static void new_video_stream(AVFormatContext *oc)
3026
{
3027
    AVStream *st;
3028
    AVCodecContext *video_enc;
3029
    enum CodecID codec_id;
3030

    
3031
    st = av_new_stream(oc, oc->nb_streams);
3032
    if (!st) {
3033
        fprintf(stderr, "Could not alloc stream\n");
3034
        av_exit(1);
3035
    }
3036
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3037
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3038
    video_bitstream_filters= NULL;
3039

    
3040
    if(thread_count>1)
3041
        avcodec_thread_init(st->codec, thread_count);
3042

    
3043
    video_enc = st->codec;
3044

    
3045
    if(video_codec_tag)
3046
        video_enc->codec_tag= video_codec_tag;
3047

    
3048
    if(   (video_global_header&1)
3049
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3050
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3051
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3052
    }
3053
    if(video_global_header&2){
3054
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3055
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3056
    }
3057

    
3058
    if (video_stream_copy) {
3059
        st->stream_copy = 1;
3060
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3061
        video_enc->sample_aspect_ratio =
3062
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3063
    } else {
3064
        const char *p;
3065
        int i;
3066
        AVCodec *codec;
3067
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3068

    
3069
        if (video_codec_name) {
3070
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3071
            codec = avcodec_find_encoder_by_name(video_codec_name);
3072
            output_codecs[nb_ocodecs] = codec;
3073
        } else {
3074
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3075
            codec = avcodec_find_encoder(codec_id);
3076
        }
3077

    
3078
        video_enc->codec_id = codec_id;
3079

    
3080
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3081

    
3082
        if (codec && codec->supported_framerates && !force_fps)
3083
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3084
        video_enc->time_base.den = fps.num;
3085
        video_enc->time_base.num = fps.den;
3086

    
3087
        video_enc->width = frame_width + frame_padright + frame_padleft;
3088
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3089
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3090
        video_enc->pix_fmt = frame_pix_fmt;
3091
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3092

    
3093
        if(codec && codec->pix_fmts){
3094
            const enum PixelFormat *p= codec->pix_fmts;
3095
            for(; *p!=-1; p++){
3096
                if(*p == video_enc->pix_fmt)
3097
                    break;
3098
            }
3099
            if(*p == -1)
3100
                video_enc->pix_fmt = codec->pix_fmts[0];
3101
        }
3102

    
3103
        if (intra_only)
3104
            video_enc->gop_size = 0;
3105
        if (video_qscale || same_quality) {
3106
            video_enc->flags |= CODEC_FLAG_QSCALE;
3107
            video_enc->global_quality=
3108
                st->quality = FF_QP2LAMBDA * video_qscale;
3109
        }
3110

    
3111
        if(intra_matrix)
3112
            video_enc->intra_matrix = intra_matrix;
3113
        if(inter_matrix)
3114
            video_enc->inter_matrix = inter_matrix;
3115

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

    
3147
        if (do_psnr)
3148
            video_enc->flags|= CODEC_FLAG_PSNR;
3149

    
3150
        /* two pass mode */
3151
        if (do_pass) {
3152
            if (do_pass == 1) {
3153
                video_enc->flags |= CODEC_FLAG_PASS1;
3154
            } else {
3155
                video_enc->flags |= CODEC_FLAG_PASS2;
3156
            }
3157
        }
3158
    }
3159
    nb_ocodecs++;
3160

    
3161
    /* reset some key parameters */
3162
    video_disable = 0;
3163
    av_freep(&video_codec_name);
3164
    video_stream_copy = 0;
3165
}
3166

    
3167
static void new_audio_stream(AVFormatContext *oc)
3168
{
3169
    AVStream *st;
3170
    AVCodecContext *audio_enc;
3171
    enum CodecID codec_id;
3172

    
3173
    st = av_new_stream(oc, oc->nb_streams);
3174
    if (!st) {
3175
        fprintf(stderr, "Could not alloc stream\n");
3176
        av_exit(1);
3177
    }
3178
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3179

    
3180
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3181
    audio_bitstream_filters= NULL;
3182

    
3183
    if(thread_count>1)
3184
        avcodec_thread_init(st->codec, thread_count);
3185

    
3186
    audio_enc = st->codec;
3187
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3188

    
3189
    if(audio_codec_tag)
3190
        audio_enc->codec_tag= audio_codec_tag;
3191

    
3192
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3193
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3194
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3195
    }
3196
    if (audio_stream_copy) {
3197
        st->stream_copy = 1;
3198
        audio_enc->channels = audio_channels;
3199
    } else {
3200
        AVCodec *codec;
3201

    
3202
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3203

    
3204
        if (audio_codec_name) {
3205
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3206
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3207
            output_codecs[nb_ocodecs] = codec;
3208
        } else {
3209
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3210
            codec = avcodec_find_encoder(codec_id);
3211
        }
3212
        audio_enc->codec_id = codec_id;
3213

    
3214
        if (audio_qscale > QSCALE_NONE) {
3215
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3216
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3217
        }
3218
        audio_enc->thread_count = thread_count;
3219
        audio_enc->channels = audio_channels;
3220
        audio_enc->sample_fmt = audio_sample_fmt;
3221
        audio_enc->channel_layout = channel_layout;
3222
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3223
            audio_enc->channel_layout = 0;
3224

    
3225
        if(codec && codec->sample_fmts){
3226
            const enum SampleFormat *p= codec->sample_fmts;
3227
            for(; *p!=-1; p++){
3228
                if(*p == audio_enc->sample_fmt)
3229
                    break;
3230
            }
3231
            if(*p == -1)
3232
                audio_enc->sample_fmt = codec->sample_fmts[0];
3233
        }
3234
    }
3235
    nb_ocodecs++;
3236
    audio_enc->sample_rate = audio_sample_rate;
3237
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3238
    if (audio_language) {
3239
        av_metadata_set(&st->metadata, "language", audio_language);
3240
        av_free(audio_language);
3241
        audio_language = NULL;
3242
    }
3243

    
3244
    /* reset some key parameters */
3245
    audio_disable = 0;
3246
    av_freep(&audio_codec_name);
3247
    audio_stream_copy = 0;
3248
}
3249

    
3250
static void new_subtitle_stream(AVFormatContext *oc)
3251
{
3252
    AVStream *st;
3253
    AVCodecContext *subtitle_enc;
3254

    
3255
    st = av_new_stream(oc, oc->nb_streams);
3256
    if (!st) {
3257
        fprintf(stderr, "Could not alloc stream\n");
3258
        av_exit(1);
3259
    }
3260
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3261

    
3262
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3263
    subtitle_bitstream_filters= NULL;
3264

    
3265
    subtitle_enc = st->codec;
3266
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3267

    
3268
    if(subtitle_codec_tag)
3269
        subtitle_enc->codec_tag= subtitle_codec_tag;
3270

    
3271
    if (subtitle_stream_copy) {
3272
        st->stream_copy = 1;
3273
    } else {
3274
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3275
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3276
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3277
    }
3278
    nb_ocodecs++;
3279

    
3280
    if (subtitle_language) {
3281
        av_metadata_set(&st->metadata, "language", subtitle_language);
3282
        av_free(subtitle_language);
3283
        subtitle_language = NULL;
3284
    }
3285

    
3286
    subtitle_disable = 0;
3287
    av_freep(&subtitle_codec_name);
3288
    subtitle_stream_copy = 0;
3289
}
3290

    
3291
static void opt_new_audio_stream(void)
3292
{
3293
    AVFormatContext *oc;
3294
    if (nb_output_files <= 0) {
3295
        fprintf(stderr, "At least one output file must be specified\n");
3296
        av_exit(1);
3297
    }
3298
    oc = output_files[nb_output_files - 1];
3299
    new_audio_stream(oc);
3300
}
3301

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

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

    
3324
static void opt_output_file(const char *filename)
3325
{
3326
    AVFormatContext *oc;
3327
    int use_video, use_audio, use_subtitle;
3328
    int input_has_video, input_has_audio, input_has_subtitle;
3329
    AVFormatParameters params, *ap = &params;
3330

    
3331
    if (!strcmp(filename, "-"))
3332
        filename = "pipe:";
3333

    
3334
    oc = avformat_alloc_context();
3335

    
3336
    if (!file_oformat) {
3337
        file_oformat = guess_format(NULL, filename, NULL);
3338
        if (!file_oformat) {
3339
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3340
                    filename);
3341
            av_exit(1);
3342
        }
3343
    }
3344

    
3345
    oc->oformat = file_oformat;
3346
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3347

    
3348
    if (!strcmp(file_oformat->name, "ffm") &&
3349
        av_strstart(filename, "http:", NULL)) {
3350
        /* special case for files sent to ffserver: we get the stream
3351
           parameters from ffserver */
3352
        int err = read_ffserver_streams(oc, filename);
3353
        if (err < 0) {
3354
            print_error(filename, err);
3355
            av_exit(1);
3356
        }
3357
    } else {
3358
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3359
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3360
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3361

    
3362
        /* disable if no corresponding type found and at least one
3363
           input file */
3364
        if (nb_input_files > 0) {
3365
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3366
                                         &input_has_subtitle);
3367
            if (!input_has_video)
3368
                use_video = 0;
3369
            if (!input_has_audio)
3370
                use_audio = 0;
3371
            if (!input_has_subtitle)
3372
                use_subtitle = 0;
3373
        }
3374

    
3375
        /* manual disable */
3376
        if (audio_disable) {
3377
            use_audio = 0;
3378
        }
3379
        if (video_disable) {
3380
            use_video = 0;
3381
        }
3382
        if (subtitle_disable) {
3383
            use_subtitle = 0;
3384
        }
3385

    
3386
        if (use_video) {
3387
            new_video_stream(oc);
3388
        }
3389

    
3390
        if (use_audio) {
3391
            new_audio_stream(oc);
3392
        }
3393

    
3394
        if (use_subtitle) {
3395
            new_subtitle_stream(oc);
3396
        }
3397

    
3398
        oc->timestamp = rec_timestamp;
3399

    
3400
        for(; metadata_count>0; metadata_count--){
3401
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3402
                                           metadata[metadata_count-1].value);
3403
        }
3404
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3405
    }
3406

    
3407
    output_files[nb_output_files++] = oc;
3408

    
3409
    /* check filename in case of an image number is expected */
3410
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3411
        if (!av_filename_number_test(oc->filename)) {
3412
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3413
            av_exit(1);
3414
        }
3415
    }
3416

    
3417
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3418
        /* test if it already exists to avoid loosing precious files */
3419
        if (!file_overwrite &&
3420
            (strchr(filename, ':') == NULL ||
3421
             filename[1] == ':' ||
3422
             av_strstart(filename, "file:", NULL))) {
3423
            if (url_exist(filename)) {
3424
                if (!using_stdin) {
3425
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3426
                    fflush(stderr);
3427
                    if (!read_yesno()) {
3428
                        fprintf(stderr, "Not overwriting - exiting\n");
3429
                        av_exit(1);
3430
                    }
3431
                }
3432
                else {
3433
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3434
                    av_exit(1);
3435
                }
3436
            }
3437
        }
3438

    
3439
        /* open the file */
3440
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3441
            fprintf(stderr, "Could not open '%s'\n", filename);
3442
            av_exit(1);
3443
        }
3444
    }
3445

    
3446
    memset(ap, 0, sizeof(*ap));
3447
    if (av_set_parameters(oc, ap) < 0) {
3448
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3449
                oc->filename);
3450
        av_exit(1);
3451
    }
3452

    
3453
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3454
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3455
    oc->loop_output = loop_output;
3456
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3457

    
3458
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3459

    
3460
    /* reset some options */
3461
    file_oformat = NULL;
3462
    file_iformat = NULL;
3463
}
3464

    
3465
/* same option as mencoder */
3466
static void opt_pass(const char *pass_str)
3467
{
3468
    int pass;
3469
    pass = atoi(pass_str);
3470
    if (pass != 1 && pass != 2) {
3471
        fprintf(stderr, "pass number can be only 1 or 2\n");
3472
        av_exit(1);
3473
    }
3474
    do_pass = pass;
3475
}
3476

    
3477
static int64_t getutime(void)
3478
{
3479
#if HAVE_GETRUSAGE
3480
    struct rusage rusage;
3481

    
3482
    getrusage(RUSAGE_SELF, &rusage);
3483
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3484
#elif HAVE_GETPROCESSTIMES
3485
    HANDLE proc;
3486
    FILETIME c, e, k, u;
3487
    proc = GetCurrentProcess();
3488
    GetProcessTimes(proc, &c, &e, &k, &u);
3489
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3490
#else
3491
    return av_gettime();
3492
#endif
3493
}
3494

    
3495
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3496
{
3497
    int i;
3498
    const char *p = str;
3499
    for(i = 0;; i++) {
3500
        dest[i] = atoi(p);
3501
        if(i == 63)
3502
            break;
3503
        p = strchr(p, ',');
3504
        if(!p) {
3505
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3506
            av_exit(1);
3507
        }
3508
        p++;
3509
    }
3510
}
3511

    
3512
static void opt_inter_matrix(const char *arg)
3513
{
3514
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3515
    parse_matrix_coeffs(inter_matrix, arg);
3516
}
3517

    
3518
static void opt_intra_matrix(const char *arg)
3519
{
3520
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3521
    parse_matrix_coeffs(intra_matrix, arg);
3522
}
3523

    
3524
/**
3525
 * Trivial log callback.
3526
 * Only suitable for show_help and similar since it lacks prefix handling.
3527
 */
3528
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3529
{
3530
    vfprintf(stdout, fmt, vl);
3531
}
3532

    
3533
static void show_help(void)
3534
{
3535
    av_log_set_callback(log_callback_help);
3536
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3537
           "Hyper fast Audio and Video encoder\n");
3538
    printf("\n");
3539
    show_help_options(options, "Main options:\n",
3540
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3541
    show_help_options(options, "\nAdvanced options:\n",
3542
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3543
                      OPT_EXPERT);
3544
    show_help_options(options, "\nVideo options:\n",
3545
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3546
                      OPT_VIDEO);
3547
    show_help_options(options, "\nAdvanced Video options:\n",
3548
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3549
                      OPT_VIDEO | OPT_EXPERT);
3550
    show_help_options(options, "\nAudio options:\n",
3551
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3552
                      OPT_AUDIO);
3553
    show_help_options(options, "\nAdvanced Audio options:\n",
3554
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3555
                      OPT_AUDIO | OPT_EXPERT);
3556
    show_help_options(options, "\nSubtitle options:\n",
3557
                      OPT_SUBTITLE | OPT_GRAB,
3558
                      OPT_SUBTITLE);
3559
    show_help_options(options, "\nAudio/Video grab options:\n",
3560
                      OPT_GRAB,
3561
                      OPT_GRAB);
3562
    printf("\n");
3563
    av_opt_show(avcodec_opts[0], NULL);
3564
    printf("\n");
3565
    av_opt_show(avformat_opts, NULL);
3566
    printf("\n");
3567
    av_opt_show(sws_opts, NULL);
3568
}
3569

    
3570
static void opt_target(const char *arg)
3571
{
3572
    int norm = -1;
3573
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3574

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

    
3619
    if(norm < 0) {
3620
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3621
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3622
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3623
        av_exit(1);
3624
    }
3625

    
3626
    if(!strcmp(arg, "vcd")) {
3627

    
3628
        opt_video_codec("mpeg1video");
3629
        opt_audio_codec("mp2");
3630
        opt_format("vcd");
3631

    
3632
        opt_frame_size(norm ? "352x240" : "352x288");
3633
        opt_frame_rate(NULL, frame_rates[norm]);
3634
        opt_default("g", norm ? "18" : "15");
3635

    
3636
        opt_default("b", "1150000");
3637
        opt_default("maxrate", "1150000");
3638
        opt_default("minrate", "1150000");
3639
        opt_default("bufsize", "327680"); // 40*1024*8;
3640

    
3641
        opt_default("ab", "224000");
3642
        audio_sample_rate = 44100;
3643
        audio_channels = 2;
3644

    
3645
        opt_default("packetsize", "2324");
3646
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3647

    
3648
        /* We have to offset the PTS, so that it is consistent with the SCR.
3649
           SCR starts at 36000, but the first two packs contain only padding
3650
           and the first pack from the other stream, respectively, may also have
3651
           been written before.
3652
           So the real data starts at SCR 36000+3*1200. */
3653
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3654
    } else if(!strcmp(arg, "svcd")) {
3655

    
3656
        opt_video_codec("mpeg2video");
3657
        opt_audio_codec("mp2");
3658
        opt_format("svcd");
3659

    
3660
        opt_frame_size(norm ? "480x480" : "480x576");
3661
        opt_frame_rate(NULL, frame_rates[norm]);
3662
        opt_default("g", norm ? "18" : "15");
3663

    
3664
        opt_default("b", "2040000");
3665
        opt_default("maxrate", "2516000");
3666
        opt_default("minrate", "0"); //1145000;
3667
        opt_default("bufsize", "1835008"); //224*1024*8;
3668
        opt_default("flags", "+scan_offset");
3669

    
3670

    
3671
        opt_default("ab", "224000");
3672
        audio_sample_rate = 44100;
3673

    
3674
        opt_default("packetsize", "2324");
3675

    
3676
    } else if(!strcmp(arg, "dvd")) {
3677

    
3678
        opt_video_codec("mpeg2video");
3679
        opt_audio_codec("ac3");
3680
        opt_format("dvd");
3681

    
3682
        opt_frame_size(norm ? "720x480" : "720x576");
3683
        opt_frame_rate(NULL, frame_rates[norm]);
3684
        opt_default("g", norm ? "18" : "15");
3685

    
3686
        opt_default("b", "6000000");
3687
        opt_default("maxrate", "9000000");
3688
        opt_default("minrate", "0"); //1500000;
3689
        opt_default("bufsize", "1835008"); //224*1024*8;
3690

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

    
3694
        opt_default("ab", "448000");
3695
        audio_sample_rate = 48000;
3696

    
3697
    } else if(!strncmp(arg, "dv", 2)) {
3698

    
3699
        opt_format("dv");
3700

    
3701
        opt_frame_size(norm ? "720x480" : "720x576");
3702
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3703
                                             (norm ? "yuv411p" : "yuv420p"));
3704
        opt_frame_rate(NULL, frame_rates[norm]);
3705

    
3706
        audio_sample_rate = 48000;
3707
        audio_channels = 2;
3708

    
3709
    } else {
3710
        fprintf(stderr, "Unknown target: %s\n", arg);
3711
        av_exit(1);
3712
    }
3713
}
3714

    
3715
static void opt_vstats_file (const char *arg)
3716
{
3717
    av_free (vstats_filename);
3718
    vstats_filename=av_strdup (arg);
3719
}
3720

    
3721
static void opt_vstats (void)
3722
{
3723
    char filename[40];
3724
    time_t today2 = time(NULL);
3725
    struct tm *today = localtime(&today2);
3726

    
3727
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3728
             today->tm_sec);
3729
    opt_vstats_file(filename);
3730
}
3731

    
3732
static int opt_bsf(const char *opt, const char *arg)
3733
{
3734
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3735
    AVBitStreamFilterContext **bsfp;
3736

    
3737
    if(!bsfc){
3738
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3739
        av_exit(1);
3740
    }
3741

    
3742
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3743
          *opt == 'a' ? &audio_bitstream_filters :
3744
                        &subtitle_bitstream_filters;
3745
    while(*bsfp)
3746
        bsfp= &(*bsfp)->next;
3747

    
3748
    *bsfp= bsfc;
3749

    
3750
    return 0;
3751
}
3752

    
3753
static int opt_preset(const char *opt, const char *arg)
3754
{
3755
    FILE *f=NULL;
3756
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3757
    int i;
3758
    const char *base[2]= { getenv("HOME"),
3759
                           FFMPEG_DATADIR,
3760
                         };
3761

    
3762
    for(i=!base[0]; i<2 && !f; i++){
3763
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3764
        f= fopen(filename, "r");
3765
        if(!f){
3766
            char *codec_name= *opt == 'v' ? video_codec_name :
3767
                              *opt == 'a' ? audio_codec_name :
3768
                                            subtitle_codec_name;
3769
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3770
            f= fopen(filename, "r");
3771
        }
3772
    }
3773
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3774
              is_dos_path(arg))){
3775
        av_strlcpy(filename, arg, sizeof(filename));
3776
        f= fopen(filename, "r");
3777
    }
3778

    
3779
    if(!f){
3780
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3781
        av_exit(1);
3782
    }
3783

    
3784
    while(!feof(f)){
3785
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3786
        if(line[0] == '#' && !e)
3787
            continue;
3788
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3789
        if(e){
3790
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3791
            av_exit(1);
3792
        }
3793
        if(!strcmp(tmp, "acodec")){
3794
            opt_audio_codec(tmp2);
3795
        }else if(!strcmp(tmp, "vcodec")){
3796
            opt_video_codec(tmp2);
3797
        }else if(!strcmp(tmp, "scodec")){
3798
            opt_subtitle_codec(tmp2);
3799
        }else if(opt_default(tmp, tmp2) < 0){
3800
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3801
            av_exit(1);
3802
        }
3803
    }
3804

    
3805
    fclose(f);
3806

    
3807
    return 0;
3808
}
3809

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

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

    
3895
    /* audio options */
3896
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3897
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3898
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3899
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3900
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3901
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3902
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3903
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3904
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3905
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3906
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3907
    { "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" },
3908

    
3909
    /* subtitle options */
3910
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3911
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3912
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3913
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3914
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3915

    
3916
    /* grab options */
3917
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3918
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3919
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3920

    
3921
    /* muxer options */
3922
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3923
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3924

    
3925
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3926
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3927
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3928

    
3929
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3930
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3931
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3932

    
3933
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3934
    { NULL, },
3935
};
3936

    
3937
int main(int argc, char **argv)
3938
{
3939
    int i;
3940
    int64_t ti;
3941

    
3942
    avcodec_register_all();
3943
    avdevice_register_all();
3944
    av_register_all();
3945

    
3946
#if HAVE_ISATTY
3947
    if(isatty(STDIN_FILENO))
3948
        url_set_interrupt_cb(decode_interrupt_cb);
3949
#endif
3950

    
3951
    for(i=0; i<CODEC_TYPE_NB; i++){
3952
        avcodec_opts[i]= avcodec_alloc_context2(i);
3953
    }
3954
    avformat_opts = avformat_alloc_context();
3955
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3956

    
3957
    show_banner();
3958

    
3959
    /* parse options */
3960
    parse_options(argc, argv, options, opt_output_file);
3961

    
3962
    /* file converter / grab */
3963
    if (nb_output_files <= 0) {
3964
        fprintf(stderr, "At least one output file must be specified\n");
3965
        av_exit(1);
3966
    }
3967

    
3968
    if (nb_input_files == 0) {
3969
        fprintf(stderr, "At least one input file must be specified\n");
3970
        av_exit(1);
3971
    }
3972

    
3973
    ti = getutime();
3974
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3975
                  stream_maps, nb_stream_maps) < 0)
3976
        av_exit(1);
3977
    ti = getutime() - ti;
3978
    if (do_benchmark) {
3979
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3980
    }
3981

    
3982
    return av_exit(0);
3983
}