Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 33946533

History | View | Annotate | Download (144 KB)

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

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

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

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

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

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

    
66
#include "cmdutils.h"
67

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

    
71
#undef exit
72

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

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

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

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

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

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

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

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

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

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

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

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

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

    
192
static int rate_emu = 0;
193

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

    
197
static int audio_volume = 256;
198

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

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

    
216
static unsigned int sws_flags = SWS_BICUBIC;
217

    
218
static int64_t timer_start;
219

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

    
224
static short *samples;
225

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

    
231
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
232

    
233
struct AVInputStream;
234

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

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

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

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

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

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

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

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

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

    
310
#if HAVE_TERMIOS_H
311

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

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

    
323
static volatile int received_sigterm = 0;
324

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
434
    av_free(opt_names);
435

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

    
440
    av_free(video_standard);
441

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
542
        bsfc= bsfc->next;
543
    }
544

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

    
552
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
553

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
884
    *frame_size = 0;
885

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

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

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

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

    
944
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
945
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
946
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
947

    
948
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
949
        if(!ost->video_resample)
950
            av_exit(1);
951
    }
952

    
953
    if (ost->video_resample) {
954
        padding_src = NULL;
955
        final_picture = &ost->pict_tmp;
956
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
957
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
958
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
959

    
960
            /* keep bands proportional to the frame size */
961
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
962
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
963
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
964
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
965

    
966
            /* sanity check to ensure no bad band sizes sneak in */
967
            assert(topBand    <= INT_MAX && topBand    >= 0);
968
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
969
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
970
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
971

    
972
            ost->topBand    = topBand;
973
            ost->bottomBand = bottomBand;
974
            ost->leftBand   = leftBand;
975
            ost->rightBand  = rightBand;
976

    
977
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
978
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
979
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
980

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

    
1001
    if (ost->video_pad) {
1002
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1003
                enc->height, enc->width, enc->pix_fmt,
1004
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1005
    }
1006

    
1007
    /* duplicates frame if needed */
1008
    for(i=0;i<nb_frames;i++) {
1009
        AVPacket pkt;
1010
        av_init_packet(&pkt);
1011
        pkt.stream_index= ost->index;
1012

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

    
1024
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1025
            enc->coded_frame = old_frame;
1026
        } else {
1027
            AVFrame big_picture;
1028

    
1029
            big_picture= *final_picture;
1030
            /* better than nothing: use input picture interlaced
1031
               settings */
1032
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1033
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1034
                if(top_field_first == -1)
1035
                    big_picture.top_field_first = in_picture->top_field_first;
1036
                else
1037
                    big_picture.top_field_first = top_field_first;
1038
            }
1039

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

    
1060
            if(ret>0){
1061
                pkt.data= bit_buffer;
1062
                pkt.size= ret;
1063
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1064
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1065
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1066
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1067
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1068

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

    
1087
static double psnr(double d){
1088
    return -10.0*log(d)/log(10.0);
1089
}
1090

    
1091
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1092
                           int frame_size)
1093
{
1094
    AVCodecContext *enc;
1095
    int frame_number;
1096
    double ti1, bitrate, avg_bitrate;
1097

    
1098
    /* this is executed just the first time do_video_stats is called */
1099
    if (!vstats_file) {
1100
        vstats_file = fopen(vstats_filename, "w");
1101
        if (!vstats_file) {
1102
            perror("fopen");
1103
            av_exit(1);
1104
        }
1105
    }
1106

    
1107
    enc = ost->st->codec;
1108
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1109
        frame_number = ost->frame_number;
1110
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1111
        if (enc->flags&CODEC_FLAG_PSNR)
1112
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1113

    
1114
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1115
        /* compute pts value */
1116
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1117
        if (ti1 < 0.01)
1118
            ti1 = 0.01;
1119

    
1120
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1121
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1122
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1123
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1124
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1125
    }
1126
}
1127

    
1128
static void print_report(AVFormatContext **output_files,
1129
                         AVOutputStream **ost_table, int nb_ostreams,
1130
                         int is_last_report)
1131
{
1132
    char buf[1024];
1133
    AVOutputStream *ost;
1134
    AVFormatContext *oc;
1135
    int64_t total_size;
1136
    AVCodecContext *enc;
1137
    int frame_number, vid, i;
1138
    double bitrate, ti1, pts;
1139
    static int64_t last_time = -1;
1140
    static int qp_histogram[52];
1141

    
1142
    if (!is_last_report) {
1143
        int64_t cur_time;
1144
        /* display the report every 0.5 seconds */
1145
        cur_time = av_gettime();
1146
        if (last_time == -1) {
1147
            last_time = cur_time;
1148
            return;
1149
        }
1150
        if ((cur_time - last_time) < 500000)
1151
            return;
1152
        last_time = cur_time;
1153
    }
1154

    
1155

    
1156
    oc = output_files[0];
1157

    
1158
    total_size = url_fsize(oc->pb);
1159
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1160
        total_size= url_ftell(oc->pb);
1161

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

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

    
1222
    if (verbose || is_last_report) {
1223
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1224

    
1225
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1226
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1227
            (double)total_size / 1024, ti1, bitrate);
1228

    
1229
        if (verbose > 1)
1230
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1231
                  nb_frames_dup, nb_frames_drop);
1232

    
1233
        if (verbose >= 0)
1234
            fprintf(stderr, "%s    \r", buf);
1235

    
1236
        fflush(stderr);
1237
    }
1238

    
1239
    if (is_last_report && verbose >= 0){
1240
        int64_t raw= audio_size + video_size + extra_size;
1241
        fprintf(stderr, "\n");
1242
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1243
                video_size/1024.0,
1244
                audio_size/1024.0,
1245
                extra_size/1024.0,
1246
                100.0*(total_size - raw)/raw
1247
        );
1248
    }
1249
}
1250

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

    
1269
    if(ist->next_pts == AV_NOPTS_VALUE)
1270
        ist->next_pts= ist->pts;
1271

    
1272
    if (pkt == NULL) {
1273
        /* EOF handling */
1274
        av_init_packet(&avpkt);
1275
        avpkt.data = NULL;
1276
        avpkt.size = 0;
1277
        goto handle_eof;
1278
    } else {
1279
        avpkt = *pkt;
1280
    }
1281

    
1282
    if(pkt->dts != AV_NOPTS_VALUE)
1283
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1284

    
1285
    //while we have more to decode or while the decoder did output something on EOF
1286
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1287
    handle_eof:
1288
        ist->pts= ist->next_pts;
1289

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

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

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

    
1382
        buffer_to_free = NULL;
1383
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1384
            pre_process_video_frame(ist, (AVPicture *)&picture,
1385
                                    &buffer_to_free);
1386
        }
1387

    
1388
        // preprocess audio (volume)
1389
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1390
            if (audio_volume != 256) {
1391
                short *volp;
1392
                volp = samples;
1393
                for(i=0;i<(data_size / sizeof(short));i++) {
1394
                    int v = ((*volp) * audio_volume + 128) >> 8;
1395
                    if (v < -32768) v = -32768;
1396
                    if (v >  32767) v = 32767;
1397
                    *volp++ = v;
1398
                }
1399
            }
1400
        }
1401

    
1402
        /* frame rate emulation */
1403
        if (rate_emu) {
1404
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1405
            int64_t now = av_gettime() - ist->start;
1406
            if (pts > now)
1407
                usleep(pts - now);
1408
        }
1409

    
1410
        /* if output time reached then transcode raw format,
1411
           encode packets and output them */
1412
        if (start_time == 0 || ist->pts >= start_time)
1413
            for(i=0;i<nb_ostreams;i++) {
1414
                int frame_size;
1415

    
1416
                ost = ost_table[i];
1417
                if (ost->source_index == ist_index) {
1418
                    os = output_files[ost->file_index];
1419

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

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

    
1445
                        av_init_packet(&opkt);
1446

    
1447
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1448
                            continue;
1449

    
1450
                        /* no reencoding needed : output the packet directly */
1451
                        /* force the input stream PTS */
1452

    
1453
                        avcodec_get_frame_defaults(&avframe);
1454
                        ost->st->codec->coded_frame= &avframe;
1455
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1456

    
1457
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1458
                            audio_size += data_size;
1459
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1460
                            video_size += data_size;
1461
                            ost->sync_opts++;
1462
                        }
1463

    
1464
                        opkt.stream_index= ost->index;
1465
                        if(pkt->pts != AV_NOPTS_VALUE)
1466
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1467
                        else
1468
                            opkt.pts= AV_NOPTS_VALUE;
1469

    
1470
                        if (pkt->dts == AV_NOPTS_VALUE)
1471
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1472
                        else
1473
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1474
                        opkt.dts -= ost_tb_start_time;
1475

    
1476
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1477
                        opkt.flags= pkt->flags;
1478

    
1479
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1480
                        if(ost->st->codec->codec_id != CODEC_ID_H264) {
1481
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1482
                            opkt.destruct= av_destruct_packet;
1483
                        } else {
1484
                            opkt.data = data_buf;
1485
                            opkt.size = data_size;
1486
                        }
1487

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

    
1514
        for(i=0;i<nb_ostreams;i++) {
1515
            ost = ost_table[i];
1516
            if (ost->source_index == ist_index) {
1517
                AVCodecContext *enc= ost->st->codec;
1518
                os = output_files[ost->file_index];
1519

    
1520
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1521
                    continue;
1522
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1523
                    continue;
1524

    
1525
                if (ost->encoding_needed) {
1526
                    for(;;) {
1527
                        AVPacket pkt;
1528
                        int fifo_bytes;
1529
                        av_init_packet(&pkt);
1530
                        pkt.stream_index= ost->index;
1531

    
1532
                        switch(ost->st->codec->codec_type) {
1533
                        case CODEC_TYPE_AUDIO:
1534
                            fifo_bytes = av_fifo_size(ost->fifo);
1535
                            ret = 0;
1536
                            /* encode any samples remaining in fifo */
1537
                            if (fifo_bytes > 0) {
1538
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1539
                                int fs_tmp = enc->frame_size;
1540

    
1541
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1542
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1543
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1544
                                } else { /* pad */
1545
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1546
                                    if (samples_size < frame_bytes)
1547
                                        av_exit(1);
1548
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1549
                                }
1550

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

    
1583
                        if(ret<=0)
1584
                            break;
1585
                        pkt.data= bit_buffer;
1586
                        pkt.size= ret;
1587
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1588
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1589
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1590
                    }
1591
                }
1592
            }
1593
        }
1594
    }
1595

    
1596
    return 0;
1597
 fail_decode:
1598
    return -1;
1599
}
1600

    
1601
static void print_sdp(AVFormatContext **avc, int n)
1602
{
1603
    char sdp[2048];
1604

    
1605
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1606
    printf("SDP:\n%s\n", sdp);
1607
    fflush(stdout);
1608
}
1609

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

    
1633
    return -1;
1634
}
1635

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

    
1657
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1658
    if (!file_table)
1659
        goto fail;
1660

    
1661
    /* input stream init */
1662
    j = 0;
1663
    for(i=0;i<nb_input_files;i++) {
1664
        is = input_files[i];
1665
        file_table[i].ist_index = j;
1666
        file_table[i].nb_streams = is->nb_streams;
1667
        j += is->nb_streams;
1668
    }
1669
    nb_istreams = j;
1670

    
1671
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1672
    if (!ist_table)
1673
        goto fail;
1674

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

    
1692
            if (rate_emu) {
1693
                ist->start = av_gettime();
1694
            }
1695
        }
1696
    }
1697

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

    
1714
    /* Sanity check the mapping args -- do the input files & streams exist? */
1715
    for(i=0;i<nb_stream_maps;i++) {
1716
        int fi = stream_maps[i].file_index;
1717
        int si = stream_maps[i].stream_index;
1718

    
1719
        if (fi < 0 || fi > nb_input_files - 1 ||
1720
            si < 0 || si > file_table[fi].nb_streams - 1) {
1721
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1722
            av_exit(1);
1723
        }
1724
        fi = stream_maps[i].sync_file_index;
1725
        si = stream_maps[i].sync_stream_index;
1726
        if (fi < 0 || fi > nb_input_files - 1 ||
1727
            si < 0 || si > file_table[fi].nb_streams - 1) {
1728
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1729
            av_exit(1);
1730
        }
1731
    }
1732

    
1733
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1734
    if (!ost_table)
1735
        goto fail;
1736
    for(i=0;i<nb_ostreams;i++) {
1737
        ost = av_mallocz(sizeof(AVOutputStream));
1738
        if (!ost)
1739
            goto fail;
1740
        ost_table[i] = ost;
1741
    }
1742

    
1743
    n = 0;
1744
    for(k=0;k<nb_output_files;k++) {
1745
        os = output_files[k];
1746
        for(i=0;i<os->nb_streams;i++,n++) {
1747
            int found;
1748
            ost = ost_table[n];
1749
            ost->file_index = k;
1750
            ost->index = i;
1751
            ost->st = os->streams[i];
1752
            if (nb_stream_maps > 0) {
1753
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1754
                    stream_maps[n].stream_index;
1755

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

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

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

    
1816
    /* for each output stream, we compute the right encoding parameters */
1817
    for(i=0;i<nb_ostreams;i++) {
1818
        AVMetadataTag *lang;
1819
        ost = ost_table[i];
1820
        os = output_files[ost->file_index];
1821
        ist = ist_table[ost->source_index];
1822

    
1823
        codec = ost->st->codec;
1824
        icodec = ist->st->codec;
1825

    
1826
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1827
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1828
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1829

    
1830
        ost->st->disposition = ist->st->disposition;
1831
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1832
        codec->chroma_sample_location = icodec->chroma_sample_location;
1833

    
1834
        if (ost->st->stream_copy) {
1835
            /* if stream_copy is selected, no need to decode or encode */
1836
            codec->codec_id = icodec->codec_id;
1837
            codec->codec_type = icodec->codec_type;
1838

    
1839
            if(!codec->codec_tag){
1840
                if(   !os->oformat->codec_tag
1841
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1842
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1843
                    codec->codec_tag = icodec->codec_tag;
1844
            }
1845

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

    
1948
                    ost->original_height = icodec->height;
1949
                    ost->original_width  = icodec->width;
1950

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

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

    
2013
    if (!bit_buffer)
2014
        bit_buffer = av_malloc(bit_buffer_size);
2015
    if (!bit_buffer) {
2016
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2017
                bit_buffer_size);
2018
        ret = AVERROR(ENOMEM);
2019
        goto fail;
2020
    }
2021

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

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

    
2069
    /* init pts */
2070
    for(i=0;i<nb_istreams;i++) {
2071
        ist = ist_table[i];
2072
        ist->pts = 0;
2073
        ist->next_pts = AV_NOPTS_VALUE;
2074
        ist->is_start = 1;
2075
    }
2076

    
2077
    /* set meta data information from input file if required */
2078
    for (i=0;i<nb_meta_data_maps;i++) {
2079
        AVFormatContext *out_file;
2080
        AVFormatContext *in_file;
2081
        AVMetadataTag *mtag;
2082

    
2083
        int out_file_index = meta_data_maps[i].out_file;
2084
        int in_file_index = meta_data_maps[i].in_file;
2085
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2086
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2087
                     out_file_index, out_file_index, in_file_index);
2088
            ret = AVERROR(EINVAL);
2089
            goto dump_format;
2090
        }
2091
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2092
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2093
                     in_file_index, out_file_index, in_file_index);
2094
            ret = AVERROR(EINVAL);
2095
            goto dump_format;
2096
        }
2097

    
2098
        out_file = output_files[out_file_index];
2099
        in_file = input_files[in_file_index];
2100

    
2101

    
2102
        mtag=NULL;
2103
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2104
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2105
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2106
                                    in_file->iformat->metadata_conv);
2107
    }
2108

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

    
2122
 dump_format:
2123
    /* dump the file output parameters - cannot be done before in case
2124
       of stream copy */
2125
    for(i=0;i<nb_output_files;i++) {
2126
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2127
    }
2128

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

    
2147
    if (ret) {
2148
        fprintf(stderr, "%s\n", error);
2149
        goto fail;
2150
    }
2151

    
2152
    if (want_sdp) {
2153
        print_sdp(output_files, nb_output_files);
2154
    }
2155

    
2156
    if (!using_stdin && verbose >= 0) {
2157
        fprintf(stderr, "Press [q] to stop encoding\n");
2158
        url_set_interrupt_cb(decode_interrupt_cb);
2159
    }
2160
    term_init();
2161

    
2162
    timer_start = av_gettime();
2163

    
2164
    for(; received_sigterm == 0;) {
2165
        int file_index, ist_index;
2166
        AVPacket pkt;
2167
        double ipts_min;
2168
        double opts_min;
2169

    
2170
    redo:
2171
        ipts_min= 1e100;
2172
        opts_min= 1e100;
2173
        /* if 'q' pressed, exits */
2174
        if (!using_stdin) {
2175
            if (q_pressed)
2176
                break;
2177
            /* read_key() returns 0 on EOF */
2178
            key = read_key();
2179
            if (key == 'q')
2180
                break;
2181
        }
2182

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

    
2224
        /* finish if recording time exhausted */
2225
        if (opts_min >= (recording_time / 1000000.0))
2226
            break;
2227

    
2228
        /* finish if limit size exhausted */
2229
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2230
            break;
2231

    
2232
        /* read a frame from it and output it in the fifo */
2233
        is = input_files[file_index];
2234
        ret= av_read_frame(is, &pkt);
2235
        if(ret == AVERROR(EAGAIN)){
2236
            no_packet[file_index]=1;
2237
            no_packet_count++;
2238
            continue;
2239
        }
2240
        if (ret < 0) {
2241
            file_table[file_index].eof_reached = 1;
2242
            if (opt_shortest)
2243
                break;
2244
            else
2245
                continue;
2246
        }
2247

    
2248
        no_packet_count=0;
2249
        memset(no_packet, 0, sizeof(no_packet));
2250

    
2251
        if (do_pkt_dump) {
2252
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2253
        }
2254
        /* the following test is needed in case new streams appear
2255
           dynamically in stream : we ignore them */
2256
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2257
            goto discard_packet;
2258
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2259
        ist = ist_table[ist_index];
2260
        if (ist->discard)
2261
            goto discard_packet;
2262

    
2263
        if (pkt.dts != AV_NOPTS_VALUE)
2264
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2265
        if (pkt.pts != AV_NOPTS_VALUE)
2266
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2267

    
2268
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2269
            if(pkt.pts != AV_NOPTS_VALUE)
2270
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2271
            if(pkt.dts != AV_NOPTS_VALUE)
2272
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2273
        }
2274

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

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

    
2293
            if (verbose >= 0)
2294
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2295
                        ist->file_index, ist->index);
2296
            if (exit_on_error)
2297
                av_exit(1);
2298
            av_free_packet(&pkt);
2299
            goto redo;
2300
        }
2301

    
2302
    discard_packet:
2303
        av_free_packet(&pkt);
2304

    
2305
        /* dump report by using the output first video and audio streams */
2306
        print_report(output_files, ost_table, nb_ostreams, 0);
2307
    }
2308

    
2309
    /* at the end of stream, we must flush the decoder buffers */
2310
    for(i=0;i<nb_istreams;i++) {
2311
        ist = ist_table[i];
2312
        if (ist->decoding_needed) {
2313
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2314
        }
2315
    }
2316

    
2317
    term_exit();
2318

    
2319
    /* write the trailer if needed and close file */
2320
    for(i=0;i<nb_output_files;i++) {
2321
        os = output_files[i];
2322
        av_write_trailer(os);
2323
    }
2324

    
2325
    /* dump report by using the first video and audio streams */
2326
    print_report(output_files, ost_table, nb_ostreams, 1);
2327

    
2328
    /* close each encoder */
2329
    for(i=0;i<nb_ostreams;i++) {
2330
        ost = ost_table[i];
2331
        if (ost->encoding_needed) {
2332
            av_freep(&ost->st->codec->stats_in);
2333
            avcodec_close(ost->st->codec);
2334
        }
2335
    }
2336

    
2337
    /* close each decoder */
2338
    for(i=0;i<nb_istreams;i++) {
2339
        ist = ist_table[i];
2340
        if (ist->decoding_needed) {
2341
            avcodec_close(ist->st->codec);
2342
        }
2343
    }
2344

    
2345
    /* finished ! */
2346
    ret = 0;
2347

    
2348
 fail:
2349
    av_freep(&bit_buffer);
2350
    av_free(file_table);
2351

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

    
2384
static void opt_format(const char *arg)
2385
{
2386
    /* compatibility stuff for pgmyuv */
2387
    if (!strcmp(arg, "pgmyuv")) {
2388
        pgmyuv_compatibility_hack=1;
2389
//        opt_image_format(arg);
2390
        arg = "image2";
2391
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2392
    }
2393

    
2394
    last_asked_format = arg;
2395
}
2396

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

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

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

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

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

    
2427
    opt_default(opt, arg);
2428

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

    
2432
    return 0;
2433
}
2434

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

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

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

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

    
2491
static void opt_frame_size(const char *arg)
2492
{
2493
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2494
        fprintf(stderr, "Incorrect frame size\n");
2495
        av_exit(1);
2496
    }
2497
}
2498

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

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

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

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

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

    
2532

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

    
2542

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

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

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

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

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

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

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

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

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

    
2615
    return 0;
2616
}
2617

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2836
    if (last_asked_format) {
2837
        file_iformat = av_find_input_format(last_asked_format);
2838
        last_asked_format = NULL;
2839
    }
2840

    
2841
    if (!strcmp(filename, "-"))
2842
        filename = "pipe:";
2843

    
2844
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2845
                    !strcmp(filename, "/dev/stdin");
2846

    
2847
    /* get default parameters from command line */
2848
    ic = avformat_alloc_context();
2849
    if (!ic) {
2850
        print_error(filename, AVERROR(ENOMEM));
2851
        av_exit(1);
2852
    }
2853

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

    
2871
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2872

    
2873
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2874
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2875
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2876
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2877

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

    
2891
    ic->loop_input = loop_input;
2892

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

    
2901
    timestamp = start_time;
2902
    /* add the stream start time */
2903
    if (ic->start_time != AV_NOPTS_VALUE)
2904
        timestamp += ic->start_time;
2905

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

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

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

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

    
2961
                    (float)rfps / rfps_base, rfps, rfps_base);
2962
            }
2963
            /* update the current frame rate to match the stream frame rate */
2964
            frame_rate.num = rfps;
2965
            frame_rate.den = rfps_base;
2966

    
2967
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2968
            if(video_disable)
2969
                ic->streams[i]->discard= AVDISCARD_ALL;
2970
            else if(video_discard)
2971
                ic->streams[i]->discard= video_discard;
2972
            break;
2973
        case CODEC_TYPE_DATA:
2974
            break;
2975
        case CODEC_TYPE_SUBTITLE:
2976
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2977
            if(subtitle_disable)
2978
                ic->streams[i]->discard = AVDISCARD_ALL;
2979
            break;
2980
        case CODEC_TYPE_ATTACHMENT:
2981
        case CODEC_TYPE_UNKNOWN:
2982
            nb_icodecs++;
2983
            break;
2984
        default:
2985
            abort();
2986
        }
2987
    }
2988

    
2989
    input_files[nb_input_files] = ic;
2990
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2991
    /* dump the file content */
2992
    if (verbose >= 0)
2993
        dump_format(ic, nb_input_files, filename, 0);
2994

    
2995
    nb_input_files++;
2996

    
2997
    video_channel = 0;
2998

    
2999
    av_freep(&video_codec_name);
3000
    av_freep(&audio_codec_name);
3001
    av_freep(&subtitle_codec_name);
3002
}
3003

    
3004
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3005
                                         int *has_subtitle_ptr)
3006
{
3007
    int has_video, has_audio, has_subtitle, i, j;
3008
    AVFormatContext *ic;
3009

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

    
3041
static void new_video_stream(AVFormatContext *oc)
3042
{
3043
    AVStream *st;
3044
    AVCodecContext *video_enc;
3045
    enum CodecID codec_id;
3046

    
3047
    st = av_new_stream(oc, oc->nb_streams);
3048
    if (!st) {
3049
        fprintf(stderr, "Could not alloc stream\n");
3050
        av_exit(1);
3051
    }
3052
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3053
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3054
    video_bitstream_filters= NULL;
3055

    
3056
    if(thread_count>1)
3057
        avcodec_thread_init(st->codec, thread_count);
3058

    
3059
    video_enc = st->codec;
3060

    
3061
    if(video_codec_tag)
3062
        video_enc->codec_tag= video_codec_tag;
3063

    
3064
    if(   (video_global_header&1)
3065
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3066
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3067
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3068
    }
3069
    if(video_global_header&2){
3070
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3071
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3072
    }
3073

    
3074
    if (video_stream_copy) {
3075
        st->stream_copy = 1;
3076
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3077
        video_enc->sample_aspect_ratio =
3078
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3079
    } else {
3080
        const char *p;
3081
        int i;
3082
        AVCodec *codec;
3083
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3084

    
3085
        if (video_codec_name) {
3086
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3087
            codec = avcodec_find_encoder_by_name(video_codec_name);
3088
            output_codecs[nb_ocodecs] = codec;
3089
        } else {
3090
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3091
            codec = avcodec_find_encoder(codec_id);
3092
        }
3093

    
3094
        video_enc->codec_id = codec_id;
3095

    
3096
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3097

    
3098
        if (codec && codec->supported_framerates && !force_fps)
3099
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3100
        video_enc->time_base.den = fps.num;
3101
        video_enc->time_base.num = fps.den;
3102

    
3103
        video_enc->width = frame_width + frame_padright + frame_padleft;
3104
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3105
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3106
        video_enc->pix_fmt = frame_pix_fmt;
3107
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3108

    
3109
        if(codec && codec->pix_fmts){
3110
            const enum PixelFormat *p= codec->pix_fmts;
3111
            for(; *p!=-1; p++){
3112
                if(*p == video_enc->pix_fmt)
3113
                    break;
3114
            }
3115
            if(*p == -1)
3116
                video_enc->pix_fmt = codec->pix_fmts[0];
3117
        }
3118

    
3119
        if (intra_only)
3120
            video_enc->gop_size = 0;
3121
        if (video_qscale || same_quality) {
3122
            video_enc->flags |= CODEC_FLAG_QSCALE;
3123
            video_enc->global_quality=
3124
                st->quality = FF_QP2LAMBDA * video_qscale;
3125
        }
3126

    
3127
        if(intra_matrix)
3128
            video_enc->intra_matrix = intra_matrix;
3129
        if(inter_matrix)
3130
            video_enc->inter_matrix = inter_matrix;
3131

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

    
3163
        if (do_psnr)
3164
            video_enc->flags|= CODEC_FLAG_PSNR;
3165

    
3166
        /* two pass mode */
3167
        if (do_pass) {
3168
            if (do_pass == 1) {
3169
                video_enc->flags |= CODEC_FLAG_PASS1;
3170
            } else {
3171
                video_enc->flags |= CODEC_FLAG_PASS2;
3172
            }
3173
        }
3174
    }
3175
    nb_ocodecs++;
3176

    
3177
    /* reset some key parameters */
3178
    video_disable = 0;
3179
    av_freep(&video_codec_name);
3180
    video_stream_copy = 0;
3181
}
3182

    
3183
static void new_audio_stream(AVFormatContext *oc)
3184
{
3185
    AVStream *st;
3186
    AVCodecContext *audio_enc;
3187
    enum CodecID codec_id;
3188

    
3189
    st = av_new_stream(oc, oc->nb_streams);
3190
    if (!st) {
3191
        fprintf(stderr, "Could not alloc stream\n");
3192
        av_exit(1);
3193
    }
3194
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3195

    
3196
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3197
    audio_bitstream_filters= NULL;
3198

    
3199
    if(thread_count>1)
3200
        avcodec_thread_init(st->codec, thread_count);
3201

    
3202
    audio_enc = st->codec;
3203
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3204

    
3205
    if(audio_codec_tag)
3206
        audio_enc->codec_tag= audio_codec_tag;
3207

    
3208
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3209
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3210
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3211
    }
3212
    if (audio_stream_copy) {
3213
        st->stream_copy = 1;
3214
        audio_enc->channels = audio_channels;
3215
    } else {
3216
        AVCodec *codec;
3217

    
3218
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3219

    
3220
        if (audio_codec_name) {
3221
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3222
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3223
            output_codecs[nb_ocodecs] = codec;
3224
        } else {
3225
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3226
            codec = avcodec_find_encoder(codec_id);
3227
        }
3228
        audio_enc->codec_id = codec_id;
3229

    
3230
        if (audio_qscale > QSCALE_NONE) {
3231
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3232
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3233
        }
3234
        audio_enc->thread_count = thread_count;
3235
        audio_enc->channels = audio_channels;
3236
        audio_enc->sample_fmt = audio_sample_fmt;
3237
        audio_enc->channel_layout = channel_layout;
3238
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3239
            audio_enc->channel_layout = 0;
3240

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

    
3260
    /* reset some key parameters */
3261
    audio_disable = 0;
3262
    av_freep(&audio_codec_name);
3263
    audio_stream_copy = 0;
3264
}
3265

    
3266
static void new_subtitle_stream(AVFormatContext *oc)
3267
{
3268
    AVStream *st;
3269
    AVCodecContext *subtitle_enc;
3270

    
3271
    st = av_new_stream(oc, oc->nb_streams);
3272
    if (!st) {
3273
        fprintf(stderr, "Could not alloc stream\n");
3274
        av_exit(1);
3275
    }
3276
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3277

    
3278
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3279
    subtitle_bitstream_filters= NULL;
3280

    
3281
    subtitle_enc = st->codec;
3282
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3283

    
3284
    if(subtitle_codec_tag)
3285
        subtitle_enc->codec_tag= subtitle_codec_tag;
3286

    
3287
    if (subtitle_stream_copy) {
3288
        st->stream_copy = 1;
3289
    } else {
3290
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3291
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3292
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3293
    }
3294
    nb_ocodecs++;
3295

    
3296
    if (subtitle_language) {
3297
        av_metadata_set(&st->metadata, "language", subtitle_language);
3298
        av_free(subtitle_language);
3299
        subtitle_language = NULL;
3300
    }
3301

    
3302
    subtitle_disable = 0;
3303
    av_freep(&subtitle_codec_name);
3304
    subtitle_stream_copy = 0;
3305
}
3306

    
3307
static void opt_new_audio_stream(void)
3308
{
3309
    AVFormatContext *oc;
3310
    if (nb_output_files <= 0) {
3311
        fprintf(stderr, "At least one output file must be specified\n");
3312
        av_exit(1);
3313
    }
3314
    oc = output_files[nb_output_files - 1];
3315
    new_audio_stream(oc);
3316
}
3317

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

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

    
3340
static void opt_output_file(const char *filename)
3341
{
3342
    AVFormatContext *oc;
3343
    int use_video, use_audio, use_subtitle;
3344
    int input_has_video, input_has_audio, input_has_subtitle;
3345
    AVFormatParameters params, *ap = &params;
3346
    AVOutputFormat *file_oformat;
3347

    
3348
    if (!strcmp(filename, "-"))
3349
        filename = "pipe:";
3350

    
3351
    oc = avformat_alloc_context();
3352
    if (!oc) {
3353
        print_error(filename, AVERROR(ENOMEM));
3354
        av_exit(1);
3355
    }
3356

    
3357
    if (last_asked_format) {
3358
        file_oformat = guess_format(last_asked_format, NULL, NULL);
3359
        if (!file_oformat) {
3360
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3361
            av_exit(1);
3362
        }
3363
        last_asked_format = NULL;
3364
    } else {
3365
        file_oformat = guess_format(NULL, filename, NULL);
3366
        if (!file_oformat) {
3367
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3368
                    filename);
3369
            av_exit(1);
3370
        }
3371
    }
3372

    
3373
    oc->oformat = file_oformat;
3374
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3375

    
3376
    if (!strcmp(file_oformat->name, "ffm") &&
3377
        av_strstart(filename, "http:", NULL)) {
3378
        /* special case for files sent to ffserver: we get the stream
3379
           parameters from ffserver */
3380
        int err = read_ffserver_streams(oc, filename);
3381
        if (err < 0) {
3382
            print_error(filename, err);
3383
            av_exit(1);
3384
        }
3385
    } else {
3386
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3387
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3388
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3389

    
3390
        /* disable if no corresponding type found and at least one
3391
           input file */
3392
        if (nb_input_files > 0) {
3393
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3394
                                         &input_has_subtitle);
3395
            if (!input_has_video)
3396
                use_video = 0;
3397
            if (!input_has_audio)
3398
                use_audio = 0;
3399
            if (!input_has_subtitle)
3400
                use_subtitle = 0;
3401
        }
3402

    
3403
        /* manual disable */
3404
        if (audio_disable) {
3405
            use_audio = 0;
3406
        }
3407
        if (video_disable) {
3408
            use_video = 0;
3409
        }
3410
        if (subtitle_disable) {
3411
            use_subtitle = 0;
3412
        }
3413

    
3414
        if (use_video) {
3415
            new_video_stream(oc);
3416
        }
3417

    
3418
        if (use_audio) {
3419
            new_audio_stream(oc);
3420
        }
3421

    
3422
        if (use_subtitle) {
3423
            new_subtitle_stream(oc);
3424
        }
3425

    
3426
        oc->timestamp = rec_timestamp;
3427

    
3428
        for(; metadata_count>0; metadata_count--){
3429
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3430
                                           metadata[metadata_count-1].value);
3431
        }
3432
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3433
    }
3434

    
3435
    output_files[nb_output_files++] = oc;
3436

    
3437
    /* check filename in case of an image number is expected */
3438
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3439
        if (!av_filename_number_test(oc->filename)) {
3440
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3441
            av_exit(1);
3442
        }
3443
    }
3444

    
3445
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3446
        /* test if it already exists to avoid loosing precious files */
3447
        if (!file_overwrite &&
3448
            (strchr(filename, ':') == NULL ||
3449
             filename[1] == ':' ||
3450
             av_strstart(filename, "file:", NULL))) {
3451
            if (url_exist(filename)) {
3452
                if (!using_stdin) {
3453
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3454
                    fflush(stderr);
3455
                    if (!read_yesno()) {
3456
                        fprintf(stderr, "Not overwriting - exiting\n");
3457
                        av_exit(1);
3458
                    }
3459
                }
3460
                else {
3461
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3462
                    av_exit(1);
3463
                }
3464
            }
3465
        }
3466

    
3467
        /* open the file */
3468
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3469
            fprintf(stderr, "Could not open '%s'\n", filename);
3470
            av_exit(1);
3471
        }
3472
    }
3473

    
3474
    memset(ap, 0, sizeof(*ap));
3475
    if (av_set_parameters(oc, ap) < 0) {
3476
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3477
                oc->filename);
3478
        av_exit(1);
3479
    }
3480

    
3481
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3482
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3483
    oc->loop_output = loop_output;
3484
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3485

    
3486
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3487
}
3488

    
3489
/* same option as mencoder */
3490
static void opt_pass(const char *pass_str)
3491
{
3492
    int pass;
3493
    pass = atoi(pass_str);
3494
    if (pass != 1 && pass != 2) {
3495
        fprintf(stderr, "pass number can be only 1 or 2\n");
3496
        av_exit(1);
3497
    }
3498
    do_pass = pass;
3499
}
3500

    
3501
static int64_t getutime(void)
3502
{
3503
#if HAVE_GETRUSAGE
3504
    struct rusage rusage;
3505

    
3506
    getrusage(RUSAGE_SELF, &rusage);
3507
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3508
#elif HAVE_GETPROCESSTIMES
3509
    HANDLE proc;
3510
    FILETIME c, e, k, u;
3511
    proc = GetCurrentProcess();
3512
    GetProcessTimes(proc, &c, &e, &k, &u);
3513
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3514
#else
3515
    return av_gettime();
3516
#endif
3517
}
3518

    
3519
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3520
{
3521
    int i;
3522
    const char *p = str;
3523
    for(i = 0;; i++) {
3524
        dest[i] = atoi(p);
3525
        if(i == 63)
3526
            break;
3527
        p = strchr(p, ',');
3528
        if(!p) {
3529
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3530
            av_exit(1);
3531
        }
3532
        p++;
3533
    }
3534
}
3535

    
3536
static void opt_inter_matrix(const char *arg)
3537
{
3538
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3539
    parse_matrix_coeffs(inter_matrix, arg);
3540
}
3541

    
3542
static void opt_intra_matrix(const char *arg)
3543
{
3544
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3545
    parse_matrix_coeffs(intra_matrix, arg);
3546
}
3547

    
3548
/**
3549
 * Trivial log callback.
3550
 * Only suitable for show_help and similar since it lacks prefix handling.
3551
 */
3552
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3553
{
3554
    vfprintf(stdout, fmt, vl);
3555
}
3556

    
3557
static void show_help(void)
3558
{
3559
    av_log_set_callback(log_callback_help);
3560
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3561
           "Hyper fast Audio and Video encoder\n");
3562
    printf("\n");
3563
    show_help_options(options, "Main options:\n",
3564
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3565
    show_help_options(options, "\nAdvanced options:\n",
3566
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3567
                      OPT_EXPERT);
3568
    show_help_options(options, "\nVideo options:\n",
3569
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3570
                      OPT_VIDEO);
3571
    show_help_options(options, "\nAdvanced Video options:\n",
3572
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3573
                      OPT_VIDEO | OPT_EXPERT);
3574
    show_help_options(options, "\nAudio options:\n",
3575
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3576
                      OPT_AUDIO);
3577
    show_help_options(options, "\nAdvanced Audio options:\n",
3578
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3579
                      OPT_AUDIO | OPT_EXPERT);
3580
    show_help_options(options, "\nSubtitle options:\n",
3581
                      OPT_SUBTITLE | OPT_GRAB,
3582
                      OPT_SUBTITLE);
3583
    show_help_options(options, "\nAudio/Video grab options:\n",
3584
                      OPT_GRAB,
3585
                      OPT_GRAB);
3586
    printf("\n");
3587
    av_opt_show(avcodec_opts[0], NULL);
3588
    printf("\n");
3589
    av_opt_show(avformat_opts, NULL);
3590
    printf("\n");
3591
    av_opt_show(sws_opts, NULL);
3592
}
3593

    
3594
static void opt_target(const char *arg)
3595
{
3596
    int norm = -1;
3597
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3598

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

    
3643
    if(norm < 0) {
3644
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3645
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3646
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3647
        av_exit(1);
3648
    }
3649

    
3650
    if(!strcmp(arg, "vcd")) {
3651

    
3652
        opt_video_codec("mpeg1video");
3653
        opt_audio_codec("mp2");
3654
        opt_format("vcd");
3655

    
3656
        opt_frame_size(norm ? "352x240" : "352x288");
3657
        opt_frame_rate(NULL, frame_rates[norm]);
3658
        opt_default("g", norm ? "18" : "15");
3659

    
3660
        opt_default("b", "1150000");
3661
        opt_default("maxrate", "1150000");
3662
        opt_default("minrate", "1150000");
3663
        opt_default("bufsize", "327680"); // 40*1024*8;
3664

    
3665
        opt_default("ab", "224000");
3666
        audio_sample_rate = 44100;
3667
        audio_channels = 2;
3668

    
3669
        opt_default("packetsize", "2324");
3670
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3671

    
3672
        /* We have to offset the PTS, so that it is consistent with the SCR.
3673
           SCR starts at 36000, but the first two packs contain only padding
3674
           and the first pack from the other stream, respectively, may also have
3675
           been written before.
3676
           So the real data starts at SCR 36000+3*1200. */
3677
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3678
    } else if(!strcmp(arg, "svcd")) {
3679

    
3680
        opt_video_codec("mpeg2video");
3681
        opt_audio_codec("mp2");
3682
        opt_format("svcd");
3683

    
3684
        opt_frame_size(norm ? "480x480" : "480x576");
3685
        opt_frame_rate(NULL, frame_rates[norm]);
3686
        opt_default("g", norm ? "18" : "15");
3687

    
3688
        opt_default("b", "2040000");
3689
        opt_default("maxrate", "2516000");
3690
        opt_default("minrate", "0"); //1145000;
3691
        opt_default("bufsize", "1835008"); //224*1024*8;
3692
        opt_default("flags", "+scan_offset");
3693

    
3694

    
3695
        opt_default("ab", "224000");
3696
        audio_sample_rate = 44100;
3697

    
3698
        opt_default("packetsize", "2324");
3699

    
3700
    } else if(!strcmp(arg, "dvd")) {
3701

    
3702
        opt_video_codec("mpeg2video");
3703
        opt_audio_codec("ac3");
3704
        opt_format("dvd");
3705

    
3706
        opt_frame_size(norm ? "720x480" : "720x576");
3707
        opt_frame_rate(NULL, frame_rates[norm]);
3708
        opt_default("g", norm ? "18" : "15");
3709

    
3710
        opt_default("b", "6000000");
3711
        opt_default("maxrate", "9000000");
3712
        opt_default("minrate", "0"); //1500000;
3713
        opt_default("bufsize", "1835008"); //224*1024*8;
3714

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

    
3718
        opt_default("ab", "448000");
3719
        audio_sample_rate = 48000;
3720

    
3721
    } else if(!strncmp(arg, "dv", 2)) {
3722

    
3723
        opt_format("dv");
3724

    
3725
        opt_frame_size(norm ? "720x480" : "720x576");
3726
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3727
                                             (norm ? "yuv411p" : "yuv420p"));
3728
        opt_frame_rate(NULL, frame_rates[norm]);
3729

    
3730
        audio_sample_rate = 48000;
3731
        audio_channels = 2;
3732

    
3733
    } else {
3734
        fprintf(stderr, "Unknown target: %s\n", arg);
3735
        av_exit(1);
3736
    }
3737
}
3738

    
3739
static void opt_vstats_file (const char *arg)
3740
{
3741
    av_free (vstats_filename);
3742
    vstats_filename=av_strdup (arg);
3743
}
3744

    
3745
static void opt_vstats (void)
3746
{
3747
    char filename[40];
3748
    time_t today2 = time(NULL);
3749
    struct tm *today = localtime(&today2);
3750

    
3751
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3752
             today->tm_sec);
3753
    opt_vstats_file(filename);
3754
}
3755

    
3756
static int opt_bsf(const char *opt, const char *arg)
3757
{
3758
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3759
    AVBitStreamFilterContext **bsfp;
3760

    
3761
    if(!bsfc){
3762
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3763
        av_exit(1);
3764
    }
3765

    
3766
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3767
          *opt == 'a' ? &audio_bitstream_filters :
3768
                        &subtitle_bitstream_filters;
3769
    while(*bsfp)
3770
        bsfp= &(*bsfp)->next;
3771

    
3772
    *bsfp= bsfc;
3773

    
3774
    return 0;
3775
}
3776

    
3777
static int opt_preset(const char *opt, const char *arg)
3778
{
3779
    FILE *f=NULL;
3780
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3781
    int i;
3782
    const char *base[2]= { getenv("HOME"),
3783
                           FFMPEG_DATADIR,
3784
                         };
3785

    
3786
    if (*opt != 'f') {
3787
        for(i=!base[0]; i<2 && !f; i++){
3788
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3789
            f= fopen(filename, "r");
3790
            if(!f){
3791
                char *codec_name= *opt == 'v' ? video_codec_name :
3792
                                  *opt == 'a' ? audio_codec_name :
3793
                                                subtitle_codec_name;
3794
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3795
                f= fopen(filename, "r");
3796
            }
3797
        }
3798
    } else {
3799
        av_strlcpy(filename, arg, sizeof(filename));
3800
        f= fopen(filename, "r");
3801
    }
3802

    
3803
    if(!f){
3804
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3805
        av_exit(1);
3806
    }
3807

    
3808
    while(!feof(f)){
3809
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3810
        if(line[0] == '#' && !e)
3811
            continue;
3812
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3813
        if(e){
3814
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3815
            av_exit(1);
3816
        }
3817
        if(!strcmp(tmp, "acodec")){
3818
            opt_audio_codec(tmp2);
3819
        }else if(!strcmp(tmp, "vcodec")){
3820
            opt_video_codec(tmp2);
3821
        }else if(!strcmp(tmp, "scodec")){
3822
            opt_subtitle_codec(tmp2);
3823
        }else if(opt_default(tmp, tmp2) < 0){
3824
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3825
            av_exit(1);
3826
        }
3827
    }
3828

    
3829
    fclose(f);
3830

    
3831
    return 0;
3832
}
3833

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

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

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

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

    
3936
    /* grab options */
3937
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3938
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3939
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3940

    
3941
    /* muxer options */
3942
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3943
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3944

    
3945
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3946
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3947
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3948

    
3949
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3950
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3951
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3952
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3953

    
3954
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3955
    { NULL, },
3956
};
3957

    
3958
int main(int argc, char **argv)
3959
{
3960
    int i;
3961
    int64_t ti;
3962

    
3963
    avcodec_register_all();
3964
    avdevice_register_all();
3965
    av_register_all();
3966

    
3967
#if HAVE_ISATTY
3968
    if(isatty(STDIN_FILENO))
3969
        url_set_interrupt_cb(decode_interrupt_cb);
3970
#endif
3971

    
3972
    for(i=0; i<CODEC_TYPE_NB; i++){
3973
        avcodec_opts[i]= avcodec_alloc_context2(i);
3974
    }
3975
    avformat_opts = avformat_alloc_context();
3976
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3977

    
3978
    show_banner();
3979

    
3980
    /* parse options */
3981
    parse_options(argc, argv, options, opt_output_file);
3982

    
3983
    /* file converter / grab */
3984
    if (nb_output_files <= 0) {
3985
        fprintf(stderr, "At least one output file must be specified\n");
3986
        av_exit(1);
3987
    }
3988

    
3989
    if (nb_input_files == 0) {
3990
        fprintf(stderr, "At least one input file must be specified\n");
3991
        av_exit(1);
3992
    }
3993

    
3994
    ti = getutime();
3995
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3996
                  stream_maps, nb_stream_maps) < 0)
3997
        av_exit(1);
3998
    ti = getutime() - ti;
3999
    if (do_benchmark) {
4000
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4001
    }
4002

    
4003
    return av_exit(0);
4004
}