Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 9d66ef18

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
        if (!st->codec) {
487
            print_error(filename, AVERROR(ENOMEM));
488
            av_exit(1);
489
        }
490
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
491
        s->streams[i] = st;
492

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

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

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

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

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

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

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

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

    
543
        bsfc= bsfc->next;
544
    }
545

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

    
553
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
554

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
885
    *frame_size = 0;
886

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

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

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

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

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

    
952
            fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
953
            /* keep bands proportional to the frame size */
954
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
955
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
956
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
957
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
958

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1148

    
1149
    oc = output_files[0];
1150

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

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

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

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

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

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

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

    
1229
        fflush(stderr);
1230
    }
1231

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1437
                        av_init_packet(&opkt);
1438

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1625
    return -1;
1626
}
1627

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2093

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

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

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

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

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

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

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

    
2154
    timer_start = av_gettime();
2155

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2294
    discard_packet:
2295
        av_free_packet(&pkt);
2296

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

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

    
2309
    term_exit();
2310

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2424
    opt_default(opt, arg);
2425

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

    
2429
    return 0;
2430
}
2431

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

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

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

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

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

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

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

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

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

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

    
2533

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

    
2543

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

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

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

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

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

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

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

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

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

    
2616
    return 0;
2617
}
2618

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2866
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2867

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

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

    
2886
    ic->loop_input = loop_input;
2887

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

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

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

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

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

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

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

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

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

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

    
2990
    video_channel = 0;
2991

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

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

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

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

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

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

    
3052
    video_enc = st->codec;
3053

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

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

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

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

    
3087
        video_enc->codec_id = codec_id;
3088

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3411
        oc->timestamp = rec_timestamp;
3412

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

    
3420
    output_files[nb_output_files++] = oc;
3421

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

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

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

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

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

    
3471
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3472

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3683

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

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

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

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

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

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

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

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

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

    
3712
        opt_format("dv");
3713

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

    
3719
        audio_sample_rate = 48000;
3720
        audio_channels = 2;
3721

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

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

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

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

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

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

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

    
3761
    *bsfp= bsfc;
3762

    
3763
    return 0;
3764
}
3765

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

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

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

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

    
3818
    fclose(f);
3819

    
3820
    return 0;
3821
}
3822

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3970
    show_banner();
3971

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

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

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

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

    
3995
    return av_exit(0);
3996
}