Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ e4637d6a

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
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
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
    allocated_audio_buf_size= allocated_audio_out_size= 0;
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
    int64_t audio_out_size, audio_buf_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
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
568

    
569
    audio_buf_size= (size + isize*dec->channels - 1) / (isize*dec->channels);
570
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
571
    audio_buf_size= audio_buf_size*2 + 10000; //saftey factors for the deprecated resampling API
572
    audio_buf_size*= osize*enc->channels;
573

    
574
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
575
    if(coded_bps > 8*osize)
576
        audio_out_size= audio_out_size * coded_bps / (8*osize);
577
    audio_out_size += FF_MIN_BUFFER_SIZE;
578

    
579
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
580
        fprintf(stderr, "Buffer sizes too large\n");
581
        av_exit(1);
582
    }
583

    
584
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
585
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
586
    if (!audio_buf || !audio_out){
587
        fprintf(stderr, "Out of memory in do_audio_out\n");
588
        av_exit(1);
589
    }
590

    
591
    if (enc->channels != dec->channels)
592
        ost->audio_resample = 1;
593

    
594
    if (ost->audio_resample && !ost->resample) {
595
        if (dec->sample_fmt != SAMPLE_FMT_S16)
596
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
597
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
598
                                               enc->sample_rate, dec->sample_rate,
599
                                               enc->sample_fmt,  dec->sample_fmt,
600
                                               16, 10, 0, 0.8);
601
        if (!ost->resample) {
602
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
603
                    dec->channels, dec->sample_rate,
604
                    enc->channels, enc->sample_rate);
605
            av_exit(1);
606
        }
607
    }
608

    
609
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
610
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
611
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
612
        if (ost->reformat_ctx)
613
            av_audio_convert_free(ost->reformat_ctx);
614
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
615
                                                   dec->sample_fmt, 1, NULL, 0);
616
        if (!ost->reformat_ctx) {
617
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
618
                avcodec_get_sample_fmt_name(dec->sample_fmt),
619
                avcodec_get_sample_fmt_name(enc->sample_fmt));
620
            av_exit(1);
621
        }
622
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
623
    }
624

    
625
    if(audio_sync_method){
626
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
627
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
628
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
629
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
630

    
631
        //FIXME resample delay
632
        if(fabs(delta) > 50){
633
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
634
                if(byte_delta < 0){
635
                    byte_delta= FFMAX(byte_delta, -size);
636
                    size += byte_delta;
637
                    buf  -= byte_delta;
638
                    if(verbose > 2)
639
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
640
                    if(!size)
641
                        return;
642
                    ist->is_start=0;
643
                }else{
644
                    static uint8_t *input_tmp= NULL;
645
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
646

    
647
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
648
                        ist->is_start=0;
649
                    else
650
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
651

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

    
672
    if (ost->audio_resample) {
673
        buftmp = audio_buf;
674
        size_out = audio_resample(ost->resample,
675
                                  (short *)buftmp, (short *)buf,
676
                                  size / (ist->st->codec->channels * isize));
677
        size_out = size_out * enc->channels * osize;
678
    } else {
679
        buftmp = buf;
680
        size_out = size;
681
    }
682

    
683
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
684
        const void *ibuf[6]= {buftmp};
685
        void *obuf[6]= {audio_buf};
686
        int istride[6]= {isize};
687
        int ostride[6]= {osize};
688
        int len= size_out/istride[0];
689
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
690
            printf("av_audio_convert() failed\n");
691
            if (exit_on_error)
692
                av_exit(1);
693
            return;
694
        }
695
        buftmp = audio_buf;
696
        size_out = len*osize;
697
    }
698

    
699
    /* now encode as many frames as possible */
700
    if (enc->frame_size > 1) {
701
        /* output resampled raw samples */
702
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
703
            fprintf(stderr, "av_fifo_realloc2() failed\n");
704
            av_exit(1);
705
        }
706
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
707

    
708
        frame_bytes = enc->frame_size * osize * enc->channels;
709

    
710
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
711
            AVPacket pkt;
712
            av_init_packet(&pkt);
713

    
714
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
715

    
716
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
717

    
718
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
719
                                       (short *)audio_buf);
720
            if (ret < 0) {
721
                fprintf(stderr, "Audio encoding failed\n");
722
                av_exit(1);
723
            }
724
            audio_size += ret;
725
            pkt.stream_index= ost->index;
726
            pkt.data= audio_out;
727
            pkt.size= ret;
728
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
729
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
730
            pkt.flags |= PKT_FLAG_KEY;
731
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
732

    
733
            ost->sync_opts += enc->frame_size;
734
        }
735
    } else {
736
        AVPacket pkt;
737
        av_init_packet(&pkt);
738

    
739
        ost->sync_opts += size_out / (osize * enc->channels);
740

    
741
        /* output a pcm frame */
742
        /* determine the size of the coded buffer */
743
        size_out /= osize;
744
        if (coded_bps)
745
            size_out = size_out*coded_bps/8;
746

    
747
        if(size_out > audio_out_size){
748
            fprintf(stderr, "Internal error, buffer size too small\n");
749
            av_exit(1);
750
        }
751

    
752
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
753
        ret = avcodec_encode_audio(enc, audio_out, size_out,
754
                                   (short *)buftmp);
755
        if (ret < 0) {
756
            fprintf(stderr, "Audio encoding failed\n");
757
            av_exit(1);
758
        }
759
        audio_size += ret;
760
        pkt.stream_index= ost->index;
761
        pkt.data= audio_out;
762
        pkt.size= ret;
763
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
764
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
765
        pkt.flags |= PKT_FLAG_KEY;
766
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
767
    }
768
}
769

    
770
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
771
{
772
    AVCodecContext *dec;
773
    AVPicture *picture2;
774
    AVPicture picture_tmp;
775
    uint8_t *buf = 0;
776

    
777
    dec = ist->st->codec;
778

    
779
    /* deinterlace : must be done before any resize */
780
    if (do_deinterlace) {
781
        int size;
782

    
783
        /* create temporary picture */
784
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
785
        buf = av_malloc(size);
786
        if (!buf)
787
            return;
788

    
789
        picture2 = &picture_tmp;
790
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
791

    
792
        if(avpicture_deinterlace(picture2, picture,
793
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
794
            /* if error, do not deinterlace */
795
            fprintf(stderr, "Deinterlacing failed\n");
796
            av_free(buf);
797
            buf = NULL;
798
            picture2 = picture;
799
        }
800
    } else {
801
        picture2 = picture;
802
    }
803

    
804
    if (picture != picture2)
805
        *picture = *picture2;
806
    *bufp = buf;
807
}
808

    
809
/* we begin to correct av delay at this threshold */
810
#define AV_DELAY_MAX 0.100
811

    
812
static void do_subtitle_out(AVFormatContext *s,
813
                            AVOutputStream *ost,
814
                            AVInputStream *ist,
815
                            AVSubtitle *sub,
816
                            int64_t pts)
817
{
818
    static uint8_t *subtitle_out = NULL;
819
    int subtitle_out_max_size = 1024 * 1024;
820
    int subtitle_out_size, nb, i;
821
    AVCodecContext *enc;
822
    AVPacket pkt;
823

    
824
    if (pts == AV_NOPTS_VALUE) {
825
        fprintf(stderr, "Subtitle packets must have a pts\n");
826
        if (exit_on_error)
827
            av_exit(1);
828
        return;
829
    }
830

    
831
    enc = ost->st->codec;
832

    
833
    if (!subtitle_out) {
834
        subtitle_out = av_malloc(subtitle_out_max_size);
835
    }
836

    
837
    /* Note: DVB subtitle need one packet to draw them and one other
838
       packet to clear them */
839
    /* XXX: signal it in the codec context ? */
840
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
841
        nb = 2;
842
    else
843
        nb = 1;
844

    
845
    for(i = 0; i < nb; i++) {
846
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
847
        // start_display_time is required to be 0
848
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
849
        sub->end_display_time -= sub->start_display_time;
850
        sub->start_display_time = 0;
851
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
852
                                                    subtitle_out_max_size, sub);
853
        if (subtitle_out_size < 0) {
854
            fprintf(stderr, "Subtitle encoding failed\n");
855
            av_exit(1);
856
        }
857

    
858
        av_init_packet(&pkt);
859
        pkt.stream_index = ost->index;
860
        pkt.data = subtitle_out;
861
        pkt.size = subtitle_out_size;
862
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
863
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
864
            /* XXX: the pts correction is handled here. Maybe handling
865
               it in the codec would be better */
866
            if (i == 0)
867
                pkt.pts += 90 * sub->start_display_time;
868
            else
869
                pkt.pts += 90 * sub->end_display_time;
870
        }
871
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
872
    }
873
}
874

    
875
static int bit_buffer_size= 1024*256;
876
static uint8_t *bit_buffer= NULL;
877

    
878
static void do_video_out(AVFormatContext *s,
879
                         AVOutputStream *ost,
880
                         AVInputStream *ist,
881
                         AVFrame *in_picture,
882
                         int *frame_size)
883
{
884
    int nb_frames, i, ret;
885
    int64_t topBand, bottomBand, leftBand, rightBand;
886
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
887
    AVFrame picture_crop_temp, picture_pad_temp;
888
    AVCodecContext *enc, *dec;
889

    
890
    avcodec_get_frame_defaults(&picture_crop_temp);
891
    avcodec_get_frame_defaults(&picture_pad_temp);
892

    
893
    enc = ost->st->codec;
894
    dec = ist->st->codec;
895

    
896
    /* by default, we output a single frame */
897
    nb_frames = 1;
898

    
899
    *frame_size = 0;
900

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

    
927
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
928
    if (nb_frames <= 0)
929
        return;
930

    
931
    if (ost->video_crop) {
932
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
933
            fprintf(stderr, "error cropping picture\n");
934
            if (exit_on_error)
935
                av_exit(1);
936
            return;
937
        }
938
        formatted_picture = &picture_crop_temp;
939
    } else {
940
        formatted_picture = in_picture;
941
    }
942

    
943
    final_picture = formatted_picture;
944
    padding_src = formatted_picture;
945
    resampling_dst = &ost->pict_tmp;
946
    if (ost->video_pad) {
947
        final_picture = &ost->pict_tmp;
948
        if (ost->video_resample) {
949
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
950
                fprintf(stderr, "error padding picture\n");
951
                if (exit_on_error)
952
                    av_exit(1);
953
                return;
954
            }
955
            resampling_dst = &picture_pad_temp;
956
        }
957
    }
958

    
959
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
960
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
961
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
962

    
963
        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));
964
        if(!ost->video_resample)
965
            av_exit(1);
966
    }
967

    
968
    if (ost->video_resample) {
969
        padding_src = NULL;
970
        final_picture = &ost->pict_tmp;
971
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
972
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
973
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
974

    
975
            /* keep bands proportional to the frame size */
976
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
977
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
978
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
979
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
980

    
981
            /* sanity check to ensure no bad band sizes sneak in */
982
            assert(topBand    <= INT_MAX && topBand    >= 0);
983
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
984
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
985
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
986

    
987
            ost->topBand    = topBand;
988
            ost->bottomBand = bottomBand;
989
            ost->leftBand   = leftBand;
990
            ost->rightBand  = rightBand;
991

    
992
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
993
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
994
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
995

    
996
            /* initialize a new scaler context */
997
            sws_freeContext(ost->img_resample_ctx);
998
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
999
            ost->img_resample_ctx = sws_getContext(
1000
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1001
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1002
                ist->st->codec->pix_fmt,
1003
                ost->st->codec->width  - (ost->padleft  + ost->padright),
1004
                ost->st->codec->height - (ost->padtop   + ost->padbottom),
1005
                ost->st->codec->pix_fmt,
1006
                sws_flags, NULL, NULL, NULL);
1007
            if (ost->img_resample_ctx == NULL) {
1008
                fprintf(stderr, "Cannot get resampling context\n");
1009
                av_exit(1);
1010
            }
1011
        }
1012
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1013
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1014
    }
1015

    
1016
    if (ost->video_pad) {
1017
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1018
                enc->height, enc->width, enc->pix_fmt,
1019
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1020
    }
1021

    
1022
    /* duplicates frame if needed */
1023
    for(i=0;i<nb_frames;i++) {
1024
        AVPacket pkt;
1025
        av_init_packet(&pkt);
1026
        pkt.stream_index= ost->index;
1027

    
1028
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1029
            /* raw pictures are written as AVPicture structure to
1030
               avoid any copies. We support temorarily the older
1031
               method. */
1032
            AVFrame* old_frame = enc->coded_frame;
1033
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1034
            pkt.data= (uint8_t *)final_picture;
1035
            pkt.size=  sizeof(AVPicture);
1036
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1037
            pkt.flags |= PKT_FLAG_KEY;
1038

    
1039
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1040
            enc->coded_frame = old_frame;
1041
        } else {
1042
            AVFrame big_picture;
1043

    
1044
            big_picture= *final_picture;
1045
            /* better than nothing: use input picture interlaced
1046
               settings */
1047
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1048
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1049
                if(top_field_first == -1)
1050
                    big_picture.top_field_first = in_picture->top_field_first;
1051
                else
1052
                    big_picture.top_field_first = top_field_first;
1053
            }
1054

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

    
1075
            if(ret>0){
1076
                pkt.data= bit_buffer;
1077
                pkt.size= ret;
1078
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1079
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1080
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1081
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1082
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1083

    
1084
                if(enc->coded_frame->key_frame)
1085
                    pkt.flags |= PKT_FLAG_KEY;
1086
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1087
                *frame_size = ret;
1088
                video_size += ret;
1089
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1090
                //        enc->frame_number-1, ret, enc->pict_type);
1091
                /* if two pass, output log */
1092
                if (ost->logfile && enc->stats_out) {
1093
                    fprintf(ost->logfile, "%s", enc->stats_out);
1094
                }
1095
            }
1096
        }
1097
        ost->sync_opts++;
1098
        ost->frame_number++;
1099
    }
1100
}
1101

    
1102
static double psnr(double d){
1103
    return -10.0*log(d)/log(10.0);
1104
}
1105

    
1106
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1107
                           int frame_size)
1108
{
1109
    AVCodecContext *enc;
1110
    int frame_number;
1111
    double ti1, bitrate, avg_bitrate;
1112

    
1113
    /* this is executed just the first time do_video_stats is called */
1114
    if (!vstats_file) {
1115
        vstats_file = fopen(vstats_filename, "w");
1116
        if (!vstats_file) {
1117
            perror("fopen");
1118
            av_exit(1);
1119
        }
1120
    }
1121

    
1122
    enc = ost->st->codec;
1123
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1124
        frame_number = ost->frame_number;
1125
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1126
        if (enc->flags&CODEC_FLAG_PSNR)
1127
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1128

    
1129
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1130
        /* compute pts value */
1131
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1132
        if (ti1 < 0.01)
1133
            ti1 = 0.01;
1134

    
1135
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1136
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1137
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1138
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1139
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1140
    }
1141
}
1142

    
1143
static void print_report(AVFormatContext **output_files,
1144
                         AVOutputStream **ost_table, int nb_ostreams,
1145
                         int is_last_report)
1146
{
1147
    char buf[1024];
1148
    AVOutputStream *ost;
1149
    AVFormatContext *oc;
1150
    int64_t total_size;
1151
    AVCodecContext *enc;
1152
    int frame_number, vid, i;
1153
    double bitrate, ti1, pts;
1154
    static int64_t last_time = -1;
1155
    static int qp_histogram[52];
1156

    
1157
    if (!is_last_report) {
1158
        int64_t cur_time;
1159
        /* display the report every 0.5 seconds */
1160
        cur_time = av_gettime();
1161
        if (last_time == -1) {
1162
            last_time = cur_time;
1163
            return;
1164
        }
1165
        if ((cur_time - last_time) < 500000)
1166
            return;
1167
        last_time = cur_time;
1168
    }
1169

    
1170

    
1171
    oc = output_files[0];
1172

    
1173
    total_size = url_fsize(oc->pb);
1174
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1175
        total_size= url_ftell(oc->pb);
1176

    
1177
    buf[0] = '\0';
1178
    ti1 = 1e10;
1179
    vid = 0;
1180
    for(i=0;i<nb_ostreams;i++) {
1181
        ost = ost_table[i];
1182
        enc = ost->st->codec;
1183
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1184
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1185
                     !ost->st->stream_copy ?
1186
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1187
        }
1188
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1189
            float t = (av_gettime()-timer_start) / 1000000.0;
1190

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

    
1237
    if (verbose || is_last_report) {
1238
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1239

    
1240
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1241
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1242
            (double)total_size / 1024, ti1, bitrate);
1243

    
1244
        if (verbose > 1)
1245
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1246
                  nb_frames_dup, nb_frames_drop);
1247

    
1248
        if (verbose >= 0)
1249
            fprintf(stderr, "%s    \r", buf);
1250

    
1251
        fflush(stderr);
1252
    }
1253

    
1254
    if (is_last_report && verbose >= 0){
1255
        int64_t raw= audio_size + video_size + extra_size;
1256
        fprintf(stderr, "\n");
1257
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1258
                video_size/1024.0,
1259
                audio_size/1024.0,
1260
                extra_size/1024.0,
1261
                100.0*(total_size - raw)/raw
1262
        );
1263
    }
1264
}
1265

    
1266
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1267
static int output_packet(AVInputStream *ist, int ist_index,
1268
                         AVOutputStream **ost_table, int nb_ostreams,
1269
                         const AVPacket *pkt)
1270
{
1271
    AVFormatContext *os;
1272
    AVOutputStream *ost;
1273
    int ret, i;
1274
    uint8_t *data_buf;
1275
    int data_size, got_picture;
1276
    AVFrame picture;
1277
    void *buffer_to_free;
1278
    static unsigned int samples_size= 0;
1279
    AVSubtitle subtitle, *subtitle_to_free;
1280
    int got_subtitle;
1281
    AVPacket avpkt;
1282
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1283

    
1284
    if(ist->next_pts == AV_NOPTS_VALUE)
1285
        ist->next_pts= ist->pts;
1286

    
1287
    if (pkt == NULL) {
1288
        /* EOF handling */
1289
        av_init_packet(&avpkt);
1290
        avpkt.data = NULL;
1291
        avpkt.size = 0;
1292
        goto handle_eof;
1293
    } else {
1294
        avpkt = *pkt;
1295
    }
1296

    
1297
    if(pkt->dts != AV_NOPTS_VALUE)
1298
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1299

    
1300
    //while we have more to decode or while the decoder did output something on EOF
1301
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1302
    handle_eof:
1303
        ist->pts= ist->next_pts;
1304

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

    
1309
        /* decode the packet if needed */
1310
        data_buf = NULL; /* fail safe */
1311
        data_size = 0;
1312
        subtitle_to_free = NULL;
1313
        if (ist->decoding_needed) {
1314
            switch(ist->st->codec->codec_type) {
1315
            case CODEC_TYPE_AUDIO:{
1316
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1317
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1318
                    av_free(samples);
1319
                    samples= av_malloc(samples_size);
1320
                }
1321
                data_size= samples_size;
1322
                    /* XXX: could avoid copy if PCM 16 bits with same
1323
                       endianness as CPU */
1324
                ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1325
                                            &avpkt);
1326
                if (ret < 0)
1327
                    goto fail_decode;
1328
                avpkt.data += ret;
1329
                avpkt.size -= ret;
1330
                /* Some bug in mpeg audio decoder gives */
1331
                /* data_size < 0, it seems they are overflows */
1332
                if (data_size <= 0) {
1333
                    /* no audio frame */
1334
                    continue;
1335
                }
1336
                data_buf = (uint8_t *)samples;
1337
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * data_size) /
1338
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1339
                break;}
1340
            case CODEC_TYPE_VIDEO:
1341
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1342
                    /* XXX: allocate picture correctly */
1343
                    avcodec_get_frame_defaults(&picture);
1344

    
1345
                    ret = avcodec_decode_video2(ist->st->codec,
1346
                                                &picture, &got_picture, &avpkt);
1347
                    ist->st->quality= picture.quality;
1348
                    if (ret < 0)
1349
                        goto fail_decode;
1350
                    if (!got_picture) {
1351
                        /* no picture yet */
1352
                        goto discard_packet;
1353
                    }
1354
                    if (ist->st->codec->time_base.num != 0) {
1355
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1356
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1357
                                          ist->st->codec->time_base.num * ticks) /
1358
                            ist->st->codec->time_base.den;
1359
                    }
1360
                    avpkt.size = 0;
1361
                    break;
1362
            case CODEC_TYPE_SUBTITLE:
1363
                ret = avcodec_decode_subtitle2(ist->st->codec,
1364
                                               &subtitle, &got_subtitle, &avpkt);
1365
                if (ret < 0)
1366
                    goto fail_decode;
1367
                if (!got_subtitle) {
1368
                    goto discard_packet;
1369
                }
1370
                subtitle_to_free = &subtitle;
1371
                avpkt.size = 0;
1372
                break;
1373
            default:
1374
                goto fail_decode;
1375
            }
1376
        } else {
1377
            switch(ist->st->codec->codec_type) {
1378
            case CODEC_TYPE_AUDIO:
1379
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1380
                    ist->st->codec->sample_rate;
1381
                break;
1382
            case CODEC_TYPE_VIDEO:
1383
                if (ist->st->codec->time_base.num != 0) {
1384
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1385
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1386
                                      ist->st->codec->time_base.num * ticks) /
1387
                        ist->st->codec->time_base.den;
1388
                }
1389
                break;
1390
            }
1391
            data_buf = avpkt.data;
1392
            data_size = avpkt.size;
1393
            ret = avpkt.size;
1394
            avpkt.size = 0;
1395
        }
1396

    
1397
        buffer_to_free = NULL;
1398
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1399
            pre_process_video_frame(ist, (AVPicture *)&picture,
1400
                                    &buffer_to_free);
1401
        }
1402

    
1403
        // preprocess audio (volume)
1404
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1405
            if (audio_volume != 256) {
1406
                short *volp;
1407
                volp = samples;
1408
                for(i=0;i<(data_size / sizeof(short));i++) {
1409
                    int v = ((*volp) * audio_volume + 128) >> 8;
1410
                    if (v < -32768) v = -32768;
1411
                    if (v >  32767) v = 32767;
1412
                    *volp++ = v;
1413
                }
1414
            }
1415
        }
1416

    
1417
        /* frame rate emulation */
1418
        if (rate_emu) {
1419
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1420
            int64_t now = av_gettime() - ist->start;
1421
            if (pts > now)
1422
                usleep(pts - now);
1423
        }
1424

    
1425
        /* if output time reached then transcode raw format,
1426
           encode packets and output them */
1427
        if (start_time == 0 || ist->pts >= start_time)
1428
            for(i=0;i<nb_ostreams;i++) {
1429
                int frame_size;
1430

    
1431
                ost = ost_table[i];
1432
                if (ost->source_index == ist_index) {
1433
                    os = output_files[ost->file_index];
1434

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

    
1438
                    if (ost->encoding_needed) {
1439
                        switch(ost->st->codec->codec_type) {
1440
                        case CODEC_TYPE_AUDIO:
1441
                            do_audio_out(os, ost, ist, data_buf, data_size);
1442
                            break;
1443
                        case CODEC_TYPE_VIDEO:
1444
                            do_video_out(os, ost, ist, &picture, &frame_size);
1445
                            if (vstats_filename && frame_size)
1446
                                do_video_stats(os, ost, frame_size);
1447
                            break;
1448
                        case CODEC_TYPE_SUBTITLE:
1449
                            do_subtitle_out(os, ost, ist, &subtitle,
1450
                                            pkt->pts);
1451
                            break;
1452
                        default:
1453
                            abort();
1454
                        }
1455
                    } else {
1456
                        AVFrame avframe; //FIXME/XXX remove this
1457
                        AVPacket opkt;
1458
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1459

    
1460
                        av_init_packet(&opkt);
1461

    
1462
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1463
                            continue;
1464

    
1465
                        /* no reencoding needed : output the packet directly */
1466
                        /* force the input stream PTS */
1467

    
1468
                        avcodec_get_frame_defaults(&avframe);
1469
                        ost->st->codec->coded_frame= &avframe;
1470
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1471

    
1472
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1473
                            audio_size += data_size;
1474
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1475
                            video_size += data_size;
1476
                            ost->sync_opts++;
1477
                        }
1478

    
1479
                        opkt.stream_index= ost->index;
1480
                        if(pkt->pts != AV_NOPTS_VALUE)
1481
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1482
                        else
1483
                            opkt.pts= AV_NOPTS_VALUE;
1484

    
1485
                        if (pkt->dts == AV_NOPTS_VALUE)
1486
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1487
                        else
1488
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1489
                        opkt.dts -= ost_tb_start_time;
1490

    
1491
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1492
                        opkt.flags= pkt->flags;
1493

    
1494
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1495
                        if(ost->st->codec->codec_id != CODEC_ID_H264) {
1496
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1497
                            opkt.destruct= av_destruct_packet;
1498
                        } else {
1499
                            opkt.data = data_buf;
1500
                            opkt.size = data_size;
1501
                        }
1502

    
1503
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1504
                        ost->st->codec->frame_number++;
1505
                        ost->frame_number++;
1506
                        av_free_packet(&opkt);
1507
                    }
1508
                }
1509
            }
1510
        av_free(buffer_to_free);
1511
        /* XXX: allocate the subtitles in the codec ? */
1512
        if (subtitle_to_free) {
1513
            if (subtitle_to_free->rects != NULL) {
1514
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1515
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1516
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1517
                    av_freep(&subtitle_to_free->rects[i]);
1518
                }
1519
                av_freep(&subtitle_to_free->rects);
1520
            }
1521
            subtitle_to_free->num_rects = 0;
1522
            subtitle_to_free = NULL;
1523
        }
1524
    }
1525
 discard_packet:
1526
    if (pkt == NULL) {
1527
        /* EOF handling */
1528

    
1529
        for(i=0;i<nb_ostreams;i++) {
1530
            ost = ost_table[i];
1531
            if (ost->source_index == ist_index) {
1532
                AVCodecContext *enc= ost->st->codec;
1533
                os = output_files[ost->file_index];
1534

    
1535
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1536
                    continue;
1537
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1538
                    continue;
1539

    
1540
                if (ost->encoding_needed) {
1541
                    for(;;) {
1542
                        AVPacket pkt;
1543
                        int fifo_bytes;
1544
                        av_init_packet(&pkt);
1545
                        pkt.stream_index= ost->index;
1546

    
1547
                        switch(ost->st->codec->codec_type) {
1548
                        case CODEC_TYPE_AUDIO:
1549
                            fifo_bytes = av_fifo_size(ost->fifo);
1550
                            ret = 0;
1551
                            /* encode any samples remaining in fifo */
1552
                            if (fifo_bytes > 0) {
1553
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1554
                                int fs_tmp = enc->frame_size;
1555

    
1556
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1557
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1558
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1559
                                } else { /* pad */
1560
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1561
                                    if (samples_size < frame_bytes)
1562
                                        av_exit(1);
1563
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1564
                                }
1565

    
1566
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1567
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1568
                                                          ost->st->time_base.num, enc->sample_rate);
1569
                                enc->frame_size = fs_tmp;
1570
                            }
1571
                            if(ret <= 0) {
1572
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1573
                            }
1574
                            if (ret < 0) {
1575
                                fprintf(stderr, "Audio encoding failed\n");
1576
                                av_exit(1);
1577
                            }
1578
                            audio_size += ret;
1579
                            pkt.flags |= PKT_FLAG_KEY;
1580
                            break;
1581
                        case CODEC_TYPE_VIDEO:
1582
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1583
                            if (ret < 0) {
1584
                                fprintf(stderr, "Video encoding failed\n");
1585
                                av_exit(1);
1586
                            }
1587
                            video_size += ret;
1588
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1589
                                pkt.flags |= PKT_FLAG_KEY;
1590
                            if (ost->logfile && enc->stats_out) {
1591
                                fprintf(ost->logfile, "%s", enc->stats_out);
1592
                            }
1593
                            break;
1594
                        default:
1595
                            ret=-1;
1596
                        }
1597

    
1598
                        if(ret<=0)
1599
                            break;
1600
                        pkt.data= bit_buffer;
1601
                        pkt.size= ret;
1602
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1603
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1604
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1605
                    }
1606
                }
1607
            }
1608
        }
1609
    }
1610

    
1611
    return 0;
1612
 fail_decode:
1613
    return -1;
1614
}
1615

    
1616
static void print_sdp(AVFormatContext **avc, int n)
1617
{
1618
    char sdp[2048];
1619

    
1620
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1621
    printf("SDP:\n%s\n", sdp);
1622
    fflush(stdout);
1623
}
1624

    
1625
static int stream_index_from_inputs(AVFormatContext **input_files,
1626
                                    int nb_input_files,
1627
                                    AVInputFile *file_table,
1628
                                    AVInputStream **ist_table,
1629
                                    enum CodecType type,
1630
                                    int programid)
1631
{
1632
    int p, q, z;
1633
    for(z=0; z<nb_input_files; z++) {
1634
        AVFormatContext *ic = input_files[z];
1635
        for(p=0; p<ic->nb_programs; p++) {
1636
            AVProgram *program = ic->programs[p];
1637
            if(program->id != programid)
1638
                continue;
1639
            for(q=0; q<program->nb_stream_indexes; q++) {
1640
                int sidx = program->stream_index[q];
1641
                int ris = file_table[z].ist_index + sidx;
1642
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1643
                    return ris;
1644
            }
1645
        }
1646
    }
1647

    
1648
    return -1;
1649
}
1650

    
1651
/*
1652
 * The following code is the main loop of the file converter
1653
 */
1654
static int av_encode(AVFormatContext **output_files,
1655
                     int nb_output_files,
1656
                     AVFormatContext **input_files,
1657
                     int nb_input_files,
1658
                     AVStreamMap *stream_maps, int nb_stream_maps)
1659
{
1660
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1661
    AVFormatContext *is, *os;
1662
    AVCodecContext *codec, *icodec;
1663
    AVOutputStream *ost, **ost_table = NULL;
1664
    AVInputStream *ist, **ist_table = NULL;
1665
    AVInputFile *file_table;
1666
    char error[1024];
1667
    int key;
1668
    int want_sdp = 1;
1669
    uint8_t no_packet[MAX_FILES]={0};
1670
    int no_packet_count=0;
1671

    
1672
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1673
    if (!file_table)
1674
        goto fail;
1675

    
1676
    /* input stream init */
1677
    j = 0;
1678
    for(i=0;i<nb_input_files;i++) {
1679
        is = input_files[i];
1680
        file_table[i].ist_index = j;
1681
        file_table[i].nb_streams = is->nb_streams;
1682
        j += is->nb_streams;
1683
    }
1684
    nb_istreams = j;
1685

    
1686
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1687
    if (!ist_table)
1688
        goto fail;
1689

    
1690
    for(i=0;i<nb_istreams;i++) {
1691
        ist = av_mallocz(sizeof(AVInputStream));
1692
        if (!ist)
1693
            goto fail;
1694
        ist_table[i] = ist;
1695
    }
1696
    j = 0;
1697
    for(i=0;i<nb_input_files;i++) {
1698
        is = input_files[i];
1699
        for(k=0;k<is->nb_streams;k++) {
1700
            ist = ist_table[j++];
1701
            ist->st = is->streams[k];
1702
            ist->file_index = i;
1703
            ist->index = k;
1704
            ist->discard = 1; /* the stream is discarded by default
1705
                                 (changed later) */
1706

    
1707
            if (rate_emu) {
1708
                ist->start = av_gettime();
1709
            }
1710
        }
1711
    }
1712

    
1713
    /* output stream init */
1714
    nb_ostreams = 0;
1715
    for(i=0;i<nb_output_files;i++) {
1716
        os = output_files[i];
1717
        if (!os->nb_streams) {
1718
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1719
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1720
            av_exit(1);
1721
        }
1722
        nb_ostreams += os->nb_streams;
1723
    }
1724
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1725
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1726
        av_exit(1);
1727
    }
1728

    
1729
    /* Sanity check the mapping args -- do the input files & streams exist? */
1730
    for(i=0;i<nb_stream_maps;i++) {
1731
        int fi = stream_maps[i].file_index;
1732
        int si = stream_maps[i].stream_index;
1733

    
1734
        if (fi < 0 || fi > nb_input_files - 1 ||
1735
            si < 0 || si > file_table[fi].nb_streams - 1) {
1736
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1737
            av_exit(1);
1738
        }
1739
        fi = stream_maps[i].sync_file_index;
1740
        si = stream_maps[i].sync_stream_index;
1741
        if (fi < 0 || fi > nb_input_files - 1 ||
1742
            si < 0 || si > file_table[fi].nb_streams - 1) {
1743
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1744
            av_exit(1);
1745
        }
1746
    }
1747

    
1748
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1749
    if (!ost_table)
1750
        goto fail;
1751
    for(i=0;i<nb_ostreams;i++) {
1752
        ost = av_mallocz(sizeof(AVOutputStream));
1753
        if (!ost)
1754
            goto fail;
1755
        ost_table[i] = ost;
1756
    }
1757

    
1758
    n = 0;
1759
    for(k=0;k<nb_output_files;k++) {
1760
        os = output_files[k];
1761
        for(i=0;i<os->nb_streams;i++,n++) {
1762
            int found;
1763
            ost = ost_table[n];
1764
            ost->file_index = k;
1765
            ost->index = i;
1766
            ost->st = os->streams[i];
1767
            if (nb_stream_maps > 0) {
1768
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1769
                    stream_maps[n].stream_index;
1770

    
1771
                /* Sanity check that the stream types match */
1772
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1773
                    int i= ost->file_index;
1774
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1775
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1776
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1777
                        ost->file_index, ost->index);
1778
                    av_exit(1);
1779
                }
1780

    
1781
            } else {
1782
                if(opt_programid) {
1783
                    found = 0;
1784
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1785
                    if(j != -1) {
1786
                        ost->source_index = j;
1787
                        found = 1;
1788
                    }
1789
                } else {
1790
                    /* get corresponding input stream index : we select the first one with the right type */
1791
                    found = 0;
1792
                    for(j=0;j<nb_istreams;j++) {
1793
                        ist = ist_table[j];
1794
                        if (ist->discard &&
1795
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1796
                            ost->source_index = j;
1797
                            found = 1;
1798
                            break;
1799
                        }
1800
                    }
1801
                }
1802

    
1803
                if (!found) {
1804
                    if(! opt_programid) {
1805
                        /* try again and reuse existing stream */
1806
                        for(j=0;j<nb_istreams;j++) {
1807
                            ist = ist_table[j];
1808
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1809
                                ost->source_index = j;
1810
                                found = 1;
1811
                            }
1812
                        }
1813
                    }
1814
                    if (!found) {
1815
                        int i= ost->file_index;
1816
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1817
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1818
                                ost->file_index, ost->index);
1819
                        av_exit(1);
1820
                    }
1821
                }
1822
            }
1823
            ist = ist_table[ost->source_index];
1824
            ist->discard = 0;
1825
            ost->sync_ist = (nb_stream_maps > 0) ?
1826
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1827
                         stream_maps[n].sync_stream_index] : ist;
1828
        }
1829
    }
1830

    
1831
    /* for each output stream, we compute the right encoding parameters */
1832
    for(i=0;i<nb_ostreams;i++) {
1833
        AVMetadataTag *lang;
1834
        ost = ost_table[i];
1835
        os = output_files[ost->file_index];
1836
        ist = ist_table[ost->source_index];
1837

    
1838
        codec = ost->st->codec;
1839
        icodec = ist->st->codec;
1840

    
1841
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1842
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1843
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1844

    
1845
        ost->st->disposition = ist->st->disposition;
1846
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1847
        codec->chroma_sample_location = icodec->chroma_sample_location;
1848

    
1849
        if (ost->st->stream_copy) {
1850
            /* if stream_copy is selected, no need to decode or encode */
1851
            codec->codec_id = icodec->codec_id;
1852
            codec->codec_type = icodec->codec_type;
1853

    
1854
            if(!codec->codec_tag){
1855
                if(   !os->oformat->codec_tag
1856
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1857
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1858
                    codec->codec_tag = icodec->codec_tag;
1859
            }
1860

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

    
1963
                    ost->original_height = icodec->height;
1964
                    ost->original_width  = icodec->width;
1965

    
1966
                    codec->bits_per_raw_sample= 0;
1967
                }
1968
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
1969
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
1970
                ost->resample_pix_fmt= icodec->pix_fmt;
1971
                ost->encoding_needed = 1;
1972
                ist->decoding_needed = 1;
1973
                break;
1974
            case CODEC_TYPE_SUBTITLE:
1975
                ost->encoding_needed = 1;
1976
                ist->decoding_needed = 1;
1977
                break;
1978
            default:
1979
                abort();
1980
                break;
1981
            }
1982
            /* two pass mode */
1983
            if (ost->encoding_needed &&
1984
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1985
                char logfilename[1024];
1986
                FILE *f;
1987
                int size;
1988
                char *logbuffer;
1989

    
1990
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1991
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1992
                         i);
1993
                if (codec->flags & CODEC_FLAG_PASS1) {
1994
                    f = fopen(logfilename, "w");
1995
                    if (!f) {
1996
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1997
                        av_exit(1);
1998
                    }
1999
                    ost->logfile = f;
2000
                } else {
2001
                    /* read the log file */
2002
                    f = fopen(logfilename, "r");
2003
                    if (!f) {
2004
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2005
                        av_exit(1);
2006
                    }
2007
                    fseek(f, 0, SEEK_END);
2008
                    size = ftell(f);
2009
                    fseek(f, 0, SEEK_SET);
2010
                    logbuffer = av_malloc(size + 1);
2011
                    if (!logbuffer) {
2012
                        fprintf(stderr, "Could not allocate log buffer\n");
2013
                        av_exit(1);
2014
                    }
2015
                    size = fread(logbuffer, 1, size, f);
2016
                    fclose(f);
2017
                    logbuffer[size] = '\0';
2018
                    codec->stats_in = logbuffer;
2019
                }
2020
            }
2021
        }
2022
        if(codec->codec_type == CODEC_TYPE_VIDEO){
2023
            int size= codec->width * codec->height;
2024
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2025
        }
2026
    }
2027

    
2028
    if (!bit_buffer)
2029
        bit_buffer = av_malloc(bit_buffer_size);
2030
    if (!bit_buffer) {
2031
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2032
                bit_buffer_size);
2033
        ret = AVERROR(ENOMEM);
2034
        goto fail;
2035
    }
2036

    
2037
    /* open each encoder */
2038
    for(i=0;i<nb_ostreams;i++) {
2039
        ost = ost_table[i];
2040
        if (ost->encoding_needed) {
2041
            AVCodec *codec = output_codecs[i];
2042
            if (!codec)
2043
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2044
            if (!codec) {
2045
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2046
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2047
                ret = AVERROR(EINVAL);
2048
                goto dump_format;
2049
            }
2050
            if (avcodec_open(ost->st->codec, codec) < 0) {
2051
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2052
                        ost->file_index, ost->index);
2053
                ret = AVERROR(EINVAL);
2054
                goto dump_format;
2055
            }
2056
            extra_size += ost->st->codec->extradata_size;
2057
        }
2058
    }
2059

    
2060
    /* open each decoder */
2061
    for(i=0;i<nb_istreams;i++) {
2062
        ist = ist_table[i];
2063
        if (ist->decoding_needed) {
2064
            AVCodec *codec = input_codecs[i];
2065
            if (!codec)
2066
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2067
            if (!codec) {
2068
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2069
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2070
                ret = AVERROR(EINVAL);
2071
                goto dump_format;
2072
            }
2073
            if (avcodec_open(ist->st->codec, codec) < 0) {
2074
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2075
                        ist->file_index, ist->index);
2076
                ret = AVERROR(EINVAL);
2077
                goto dump_format;
2078
            }
2079
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2080
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2081
        }
2082
    }
2083

    
2084
    /* init pts */
2085
    for(i=0;i<nb_istreams;i++) {
2086
        ist = ist_table[i];
2087
        ist->pts = 0;
2088
        ist->next_pts = AV_NOPTS_VALUE;
2089
        ist->is_start = 1;
2090
    }
2091

    
2092
    /* set meta data information from input file if required */
2093
    for (i=0;i<nb_meta_data_maps;i++) {
2094
        AVFormatContext *out_file;
2095
        AVFormatContext *in_file;
2096
        AVMetadataTag *mtag;
2097

    
2098
        int out_file_index = meta_data_maps[i].out_file;
2099
        int in_file_index = meta_data_maps[i].in_file;
2100
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2101
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2102
                     out_file_index, out_file_index, in_file_index);
2103
            ret = AVERROR(EINVAL);
2104
            goto dump_format;
2105
        }
2106
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2107
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2108
                     in_file_index, out_file_index, in_file_index);
2109
            ret = AVERROR(EINVAL);
2110
            goto dump_format;
2111
        }
2112

    
2113
        out_file = output_files[out_file_index];
2114
        in_file = input_files[in_file_index];
2115

    
2116

    
2117
        mtag=NULL;
2118
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2119
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2120
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2121
                                    in_file->iformat->metadata_conv);
2122
    }
2123

    
2124
    /* open files and write file headers */
2125
    for(i=0;i<nb_output_files;i++) {
2126
        os = output_files[i];
2127
        if (av_write_header(os) < 0) {
2128
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2129
            ret = AVERROR(EINVAL);
2130
            goto dump_format;
2131
        }
2132
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2133
            want_sdp = 0;
2134
        }
2135
    }
2136

    
2137
 dump_format:
2138
    /* dump the file output parameters - cannot be done before in case
2139
       of stream copy */
2140
    for(i=0;i<nb_output_files;i++) {
2141
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2142
    }
2143

    
2144
    /* dump the stream mapping */
2145
    if (verbose >= 0) {
2146
        fprintf(stderr, "Stream mapping:\n");
2147
        for(i=0;i<nb_ostreams;i++) {
2148
            ost = ost_table[i];
2149
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2150
                    ist_table[ost->source_index]->file_index,
2151
                    ist_table[ost->source_index]->index,
2152
                    ost->file_index,
2153
                    ost->index);
2154
            if (ost->sync_ist != ist_table[ost->source_index])
2155
                fprintf(stderr, " [sync #%d.%d]",
2156
                        ost->sync_ist->file_index,
2157
                        ost->sync_ist->index);
2158
            fprintf(stderr, "\n");
2159
        }
2160
    }
2161

    
2162
    if (ret) {
2163
        fprintf(stderr, "%s\n", error);
2164
        goto fail;
2165
    }
2166

    
2167
    if (want_sdp) {
2168
        print_sdp(output_files, nb_output_files);
2169
    }
2170

    
2171
    if (!using_stdin && verbose >= 0) {
2172
        fprintf(stderr, "Press [q] to stop encoding\n");
2173
        url_set_interrupt_cb(decode_interrupt_cb);
2174
    }
2175
    term_init();
2176

    
2177
    timer_start = av_gettime();
2178

    
2179
    for(; received_sigterm == 0;) {
2180
        int file_index, ist_index;
2181
        AVPacket pkt;
2182
        double ipts_min;
2183
        double opts_min;
2184

    
2185
    redo:
2186
        ipts_min= 1e100;
2187
        opts_min= 1e100;
2188
        /* if 'q' pressed, exits */
2189
        if (!using_stdin) {
2190
            if (q_pressed)
2191
                break;
2192
            /* read_key() returns 0 on EOF */
2193
            key = read_key();
2194
            if (key == 'q')
2195
                break;
2196
        }
2197

    
2198
        /* select the stream that we must read now by looking at the
2199
           smallest output pts */
2200
        file_index = -1;
2201
        for(i=0;i<nb_ostreams;i++) {
2202
            double ipts, opts;
2203
            ost = ost_table[i];
2204
            os = output_files[ost->file_index];
2205
            ist = ist_table[ost->source_index];
2206
            if(no_packet[ist->file_index])
2207
                continue;
2208
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2209
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2210
            else
2211
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2212
            ipts = (double)ist->pts;
2213
            if (!file_table[ist->file_index].eof_reached){
2214
                if(ipts < ipts_min) {
2215
                    ipts_min = ipts;
2216
                    if(input_sync ) file_index = ist->file_index;
2217
                }
2218
                if(opts < opts_min) {
2219
                    opts_min = opts;
2220
                    if(!input_sync) file_index = ist->file_index;
2221
                }
2222
            }
2223
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2224
                file_index= -1;
2225
                break;
2226
            }
2227
        }
2228
        /* if none, if is finished */
2229
        if (file_index < 0) {
2230
            if(no_packet_count){
2231
                no_packet_count=0;
2232
                memset(no_packet, 0, sizeof(no_packet));
2233
                usleep(10000);
2234
                continue;
2235
            }
2236
            break;
2237
        }
2238

    
2239
        /* finish if recording time exhausted */
2240
        if (opts_min >= (recording_time / 1000000.0))
2241
            break;
2242

    
2243
        /* finish if limit size exhausted */
2244
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2245
            break;
2246

    
2247
        /* read a frame from it and output it in the fifo */
2248
        is = input_files[file_index];
2249
        ret= av_read_frame(is, &pkt);
2250
        if(ret == AVERROR(EAGAIN)){
2251
            no_packet[file_index]=1;
2252
            no_packet_count++;
2253
            continue;
2254
        }
2255
        if (ret < 0) {
2256
            file_table[file_index].eof_reached = 1;
2257
            if (opt_shortest)
2258
                break;
2259
            else
2260
                continue;
2261
        }
2262

    
2263
        no_packet_count=0;
2264
        memset(no_packet, 0, sizeof(no_packet));
2265

    
2266
        if (do_pkt_dump) {
2267
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2268
        }
2269
        /* the following test is needed in case new streams appear
2270
           dynamically in stream : we ignore them */
2271
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2272
            goto discard_packet;
2273
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2274
        ist = ist_table[ist_index];
2275
        if (ist->discard)
2276
            goto discard_packet;
2277

    
2278
        if (pkt.dts != AV_NOPTS_VALUE)
2279
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2280
        if (pkt.pts != AV_NOPTS_VALUE)
2281
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2282

    
2283
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2284
            if(pkt.pts != AV_NOPTS_VALUE)
2285
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2286
            if(pkt.dts != AV_NOPTS_VALUE)
2287
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2288
        }
2289

    
2290
//        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);
2291
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2292
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2293
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2294
            int64_t delta= pkt_dts - ist->next_pts;
2295
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2296
                input_files_ts_offset[ist->file_index]-= delta;
2297
                if (verbose > 2)
2298
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2299
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2300
                if(pkt.pts != AV_NOPTS_VALUE)
2301
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2302
            }
2303
        }
2304

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

    
2308
            if (verbose >= 0)
2309
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2310
                        ist->file_index, ist->index);
2311
            if (exit_on_error)
2312
                av_exit(1);
2313
            av_free_packet(&pkt);
2314
            goto redo;
2315
        }
2316

    
2317
    discard_packet:
2318
        av_free_packet(&pkt);
2319

    
2320
        /* dump report by using the output first video and audio streams */
2321
        print_report(output_files, ost_table, nb_ostreams, 0);
2322
    }
2323

    
2324
    /* at the end of stream, we must flush the decoder buffers */
2325
    for(i=0;i<nb_istreams;i++) {
2326
        ist = ist_table[i];
2327
        if (ist->decoding_needed) {
2328
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2329
        }
2330
    }
2331

    
2332
    term_exit();
2333

    
2334
    /* write the trailer if needed and close file */
2335
    for(i=0;i<nb_output_files;i++) {
2336
        os = output_files[i];
2337
        av_write_trailer(os);
2338
    }
2339

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

    
2343
    /* close each encoder */
2344
    for(i=0;i<nb_ostreams;i++) {
2345
        ost = ost_table[i];
2346
        if (ost->encoding_needed) {
2347
            av_freep(&ost->st->codec->stats_in);
2348
            avcodec_close(ost->st->codec);
2349
        }
2350
    }
2351

    
2352
    /* close each decoder */
2353
    for(i=0;i<nb_istreams;i++) {
2354
        ist = ist_table[i];
2355
        if (ist->decoding_needed) {
2356
            avcodec_close(ist->st->codec);
2357
        }
2358
    }
2359

    
2360
    /* finished ! */
2361
    ret = 0;
2362

    
2363
 fail:
2364
    av_freep(&bit_buffer);
2365
    av_free(file_table);
2366

    
2367
    if (ist_table) {
2368
        for(i=0;i<nb_istreams;i++) {
2369
            ist = ist_table[i];
2370
            av_free(ist);
2371
        }
2372
        av_free(ist_table);
2373
    }
2374
    if (ost_table) {
2375
        for(i=0;i<nb_ostreams;i++) {
2376
            ost = ost_table[i];
2377
            if (ost) {
2378
                if (ost->logfile) {
2379
                    fclose(ost->logfile);
2380
                    ost->logfile = NULL;
2381
                }
2382
                av_fifo_free(ost->fifo); /* works even if fifo is not
2383
                                             initialized but set to zero */
2384
                av_free(ost->pict_tmp.data[0]);
2385
                if (ost->video_resample)
2386
                    sws_freeContext(ost->img_resample_ctx);
2387
                if (ost->resample)
2388
                    audio_resample_close(ost->resample);
2389
                if (ost->reformat_ctx)
2390
                    av_audio_convert_free(ost->reformat_ctx);
2391
                av_free(ost);
2392
            }
2393
        }
2394
        av_free(ost_table);
2395
    }
2396
    return ret;
2397
}
2398

    
2399
static void opt_format(const char *arg)
2400
{
2401
    /* compatibility stuff for pgmyuv */
2402
    if (!strcmp(arg, "pgmyuv")) {
2403
        pgmyuv_compatibility_hack=1;
2404
//        opt_image_format(arg);
2405
        arg = "image2";
2406
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2407
    }
2408

    
2409
    last_asked_format = arg;
2410
}
2411

    
2412
static void opt_video_rc_override_string(const char *arg)
2413
{
2414
    video_rc_override_string = arg;
2415
}
2416

    
2417
static int opt_me_threshold(const char *opt, const char *arg)
2418
{
2419
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2420
    return 0;
2421
}
2422

    
2423
static int opt_verbose(const char *opt, const char *arg)
2424
{
2425
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2426
    return 0;
2427
}
2428

    
2429
static int opt_frame_rate(const char *opt, const char *arg)
2430
{
2431
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2432
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2433
        av_exit(1);
2434
    }
2435
    return 0;
2436
}
2437

    
2438
static int opt_bitrate(const char *opt, const char *arg)
2439
{
2440
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2441

    
2442
    opt_default(opt, arg);
2443

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

    
2447
    return 0;
2448
}
2449

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

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

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

    
2492
static void opt_frame_crop_right(const char *arg)
2493
{
2494
    frame_rightBand = atoi(arg);
2495
    if (frame_rightBand < 0) {
2496
        fprintf(stderr, "Incorrect right crop size\n");
2497
        av_exit(1);
2498
    }
2499
    if ((frame_rightBand) >= frame_width){
2500
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2501
        av_exit(1);
2502
    }
2503
    frame_width -= frame_rightBand;
2504
}
2505

    
2506
static void opt_frame_size(const char *arg)
2507
{
2508
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2509
        fprintf(stderr, "Incorrect frame size\n");
2510
        av_exit(1);
2511
    }
2512
}
2513

    
2514
static void opt_pad_color(const char *arg) {
2515
    /* Input is expected to be six hex digits similar to
2516
       how colors are expressed in html tags (but without the #) */
2517
    int rgb = strtol(arg, NULL, 16);
2518
    int r,g,b;
2519

    
2520
    r = (rgb >> 16);
2521
    g = ((rgb >> 8) & 255);
2522
    b = (rgb & 255);
2523

    
2524
    padcolor[0] = RGB_TO_Y(r,g,b);
2525
    padcolor[1] = RGB_TO_U(r,g,b,0);
2526
    padcolor[2] = RGB_TO_V(r,g,b,0);
2527
}
2528

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

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

    
2547

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

    
2557

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

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

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

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

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

    
2605
static int opt_metadata(const char *opt, const char *arg)
2606
{
2607
    char *mid= strchr(arg, '=');
2608

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

    
2615
    metadata_count++;
2616
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2617
    metadata[metadata_count-1].key  = av_strdup(arg);
2618
    metadata[metadata_count-1].value= av_strdup(mid);
2619

    
2620
    return 0;
2621
}
2622

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

    
2633
static void opt_top_field_first(const char *arg)
2634
{
2635
    top_field_first= atoi(arg);
2636
}
2637

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

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

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

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

    
2670
static void opt_video_channel(const char *arg)
2671
{
2672
    video_channel = strtol(arg, NULL, 0);
2673
}
2674

    
2675
static void opt_video_standard(const char *arg)
2676
{
2677
    video_standard = av_strdup(arg);
2678
}
2679

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

    
2691
static void opt_audio_codec(const char *arg)
2692
{
2693
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2694
}
2695

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

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

    
2705
static void opt_video_tag(const char *arg)
2706
{
2707
    char *tail;
2708
    video_codec_tag= strtol(arg, &tail, 0);
2709

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

    
2714
static void opt_video_codec(const char *arg)
2715
{
2716
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2717
}
2718

    
2719
static void opt_subtitle_codec(const char *arg)
2720
{
2721
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2722
}
2723

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

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

    
2733
static void opt_map(const char *arg)
2734
{
2735
    AVStreamMap *m;
2736
    char *p;
2737

    
2738
    m = &stream_maps[nb_stream_maps++];
2739

    
2740
    m->file_index = strtol(arg, &p, 0);
2741
    if (*p)
2742
        p++;
2743

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

    
2757
static void opt_map_meta_data(const char *arg)
2758
{
2759
    AVMetaDataMap *m;
2760
    char *p;
2761

    
2762
    m = &meta_data_maps[nb_meta_data_maps++];
2763

    
2764
    m->out_file = strtol(arg, &p, 0);
2765
    if (*p)
2766
        p++;
2767

    
2768
    m->in_file = strtol(p, &p, 0);
2769
}
2770

    
2771
static void opt_input_ts_scale(const char *arg)
2772
{
2773
    unsigned int stream;
2774
    double scale;
2775
    char *p;
2776

    
2777
    stream = strtol(arg, &p, 0);
2778
    if (*p)
2779
        p++;
2780
    scale= strtod(p, &p);
2781

    
2782
    if(stream >= MAX_STREAMS)
2783
        av_exit(1);
2784

    
2785
    input_files_ts_scale[nb_input_files][stream]= scale;
2786
}
2787

    
2788
static int opt_recording_time(const char *opt, const char *arg)
2789
{
2790
    recording_time = parse_time_or_die(opt, arg, 1);
2791
    return 0;
2792
}
2793

    
2794
static int opt_start_time(const char *opt, const char *arg)
2795
{
2796
    start_time = parse_time_or_die(opt, arg, 1);
2797
    return 0;
2798
}
2799

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

    
2806
static int opt_input_ts_offset(const char *opt, const char *arg)
2807
{
2808
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2809
    return 0;
2810
}
2811

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

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

    
2833
static void opt_input_file(const char *filename)
2834
{
2835
    AVFormatContext *ic;
2836
    AVFormatParameters params, *ap = &params;
2837
    AVInputFormat *file_iformat = NULL;
2838
    int err, i, ret, rfps, rfps_base;
2839
    int64_t timestamp;
2840

    
2841
    if (last_asked_format) {
2842
        file_iformat = av_find_input_format(last_asked_format);
2843
        last_asked_format = NULL;
2844
    }
2845

    
2846
    if (!strcmp(filename, "-"))
2847
        filename = "pipe:";
2848

    
2849
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2850
                    !strcmp(filename, "/dev/stdin");
2851

    
2852
    /* get default parameters from command line */
2853
    ic = avformat_alloc_context();
2854
    if (!ic) {
2855
        print_error(filename, AVERROR(ENOMEM));
2856
        av_exit(1);
2857
    }
2858

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

    
2876
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2877

    
2878
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2879
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2880
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2881
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2882

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

    
2896
    ic->loop_input = loop_input;
2897

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

    
2906
    timestamp = start_time;
2907
    /* add the stream start time */
2908
    if (ic->start_time != AV_NOPTS_VALUE)
2909
        timestamp += ic->start_time;
2910

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

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

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

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

    
2966
                    (float)rfps / rfps_base, rfps, rfps_base);
2967
            }
2968
            /* update the current frame rate to match the stream frame rate */
2969
            frame_rate.num = rfps;
2970
            frame_rate.den = rfps_base;
2971

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

    
2994
    input_files[nb_input_files] = ic;
2995
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2996
    /* dump the file content */
2997
    if (verbose >= 0)
2998
        dump_format(ic, nb_input_files, filename, 0);
2999

    
3000
    nb_input_files++;
3001

    
3002
    video_channel = 0;
3003

    
3004
    av_freep(&video_codec_name);
3005
    av_freep(&audio_codec_name);
3006
    av_freep(&subtitle_codec_name);
3007
}
3008

    
3009
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3010
                                         int *has_subtitle_ptr)
3011
{
3012
    int has_video, has_audio, has_subtitle, i, j;
3013
    AVFormatContext *ic;
3014

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

    
3046
static void new_video_stream(AVFormatContext *oc)
3047
{
3048
    AVStream *st;
3049
    AVCodecContext *video_enc;
3050
    enum CodecID codec_id;
3051

    
3052
    st = av_new_stream(oc, oc->nb_streams);
3053
    if (!st) {
3054
        fprintf(stderr, "Could not alloc stream\n");
3055
        av_exit(1);
3056
    }
3057
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3058
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3059
    video_bitstream_filters= NULL;
3060

    
3061
    if(thread_count>1)
3062
        avcodec_thread_init(st->codec, thread_count);
3063

    
3064
    video_enc = st->codec;
3065

    
3066
    if(video_codec_tag)
3067
        video_enc->codec_tag= video_codec_tag;
3068

    
3069
    if(   (video_global_header&1)
3070
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3071
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3072
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3073
    }
3074
    if(video_global_header&2){
3075
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3076
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3077
    }
3078

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

    
3090
        if (video_codec_name) {
3091
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3092
            codec = avcodec_find_encoder_by_name(video_codec_name);
3093
            output_codecs[nb_ocodecs] = codec;
3094
        } else {
3095
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3096
            codec = avcodec_find_encoder(codec_id);
3097
        }
3098

    
3099
        video_enc->codec_id = codec_id;
3100

    
3101
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3102

    
3103
        if (codec && codec->supported_framerates && !force_fps)
3104
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3105
        video_enc->time_base.den = fps.num;
3106
        video_enc->time_base.num = fps.den;
3107

    
3108
        video_enc->width = frame_width + frame_padright + frame_padleft;
3109
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3110
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3111
        video_enc->pix_fmt = frame_pix_fmt;
3112
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3113

    
3114
        if(codec && codec->pix_fmts){
3115
            const enum PixelFormat *p= codec->pix_fmts;
3116
            for(; *p!=-1; p++){
3117
                if(*p == video_enc->pix_fmt)
3118
                    break;
3119
            }
3120
            if(*p == -1)
3121
                video_enc->pix_fmt = codec->pix_fmts[0];
3122
        }
3123

    
3124
        if (intra_only)
3125
            video_enc->gop_size = 0;
3126
        if (video_qscale || same_quality) {
3127
            video_enc->flags |= CODEC_FLAG_QSCALE;
3128
            video_enc->global_quality=
3129
                st->quality = FF_QP2LAMBDA * video_qscale;
3130
        }
3131

    
3132
        if(intra_matrix)
3133
            video_enc->intra_matrix = intra_matrix;
3134
        if(inter_matrix)
3135
            video_enc->inter_matrix = inter_matrix;
3136

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

    
3168
        if (do_psnr)
3169
            video_enc->flags|= CODEC_FLAG_PSNR;
3170

    
3171
        /* two pass mode */
3172
        if (do_pass) {
3173
            if (do_pass == 1) {
3174
                video_enc->flags |= CODEC_FLAG_PASS1;
3175
            } else {
3176
                video_enc->flags |= CODEC_FLAG_PASS2;
3177
            }
3178
        }
3179
    }
3180
    nb_ocodecs++;
3181

    
3182
    /* reset some key parameters */
3183
    video_disable = 0;
3184
    av_freep(&video_codec_name);
3185
    video_stream_copy = 0;
3186
}
3187

    
3188
static void new_audio_stream(AVFormatContext *oc)
3189
{
3190
    AVStream *st;
3191
    AVCodecContext *audio_enc;
3192
    enum CodecID codec_id;
3193

    
3194
    st = av_new_stream(oc, oc->nb_streams);
3195
    if (!st) {
3196
        fprintf(stderr, "Could not alloc stream\n");
3197
        av_exit(1);
3198
    }
3199
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3200

    
3201
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3202
    audio_bitstream_filters= NULL;
3203

    
3204
    if(thread_count>1)
3205
        avcodec_thread_init(st->codec, thread_count);
3206

    
3207
    audio_enc = st->codec;
3208
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3209

    
3210
    if(audio_codec_tag)
3211
        audio_enc->codec_tag= audio_codec_tag;
3212

    
3213
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3214
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3215
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3216
    }
3217
    if (audio_stream_copy) {
3218
        st->stream_copy = 1;
3219
        audio_enc->channels = audio_channels;
3220
    } else {
3221
        AVCodec *codec;
3222

    
3223
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3224

    
3225
        if (audio_codec_name) {
3226
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3227
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3228
            output_codecs[nb_ocodecs] = codec;
3229
        } else {
3230
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3231
            codec = avcodec_find_encoder(codec_id);
3232
        }
3233
        audio_enc->codec_id = codec_id;
3234

    
3235
        if (audio_qscale > QSCALE_NONE) {
3236
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3237
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3238
        }
3239
        audio_enc->thread_count = thread_count;
3240
        audio_enc->channels = audio_channels;
3241
        audio_enc->sample_fmt = audio_sample_fmt;
3242
        audio_enc->channel_layout = channel_layout;
3243
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3244
            audio_enc->channel_layout = 0;
3245

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

    
3265
    /* reset some key parameters */
3266
    audio_disable = 0;
3267
    av_freep(&audio_codec_name);
3268
    audio_stream_copy = 0;
3269
}
3270

    
3271
static void new_subtitle_stream(AVFormatContext *oc)
3272
{
3273
    AVStream *st;
3274
    AVCodecContext *subtitle_enc;
3275

    
3276
    st = av_new_stream(oc, oc->nb_streams);
3277
    if (!st) {
3278
        fprintf(stderr, "Could not alloc stream\n");
3279
        av_exit(1);
3280
    }
3281
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3282

    
3283
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3284
    subtitle_bitstream_filters= NULL;
3285

    
3286
    subtitle_enc = st->codec;
3287
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3288

    
3289
    if(subtitle_codec_tag)
3290
        subtitle_enc->codec_tag= subtitle_codec_tag;
3291

    
3292
    if (subtitle_stream_copy) {
3293
        st->stream_copy = 1;
3294
    } else {
3295
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3296
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3297
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3298
    }
3299
    nb_ocodecs++;
3300

    
3301
    if (subtitle_language) {
3302
        av_metadata_set(&st->metadata, "language", subtitle_language);
3303
        av_free(subtitle_language);
3304
        subtitle_language = NULL;
3305
    }
3306

    
3307
    subtitle_disable = 0;
3308
    av_freep(&subtitle_codec_name);
3309
    subtitle_stream_copy = 0;
3310
}
3311

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

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

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

    
3345
static void opt_output_file(const char *filename)
3346
{
3347
    AVFormatContext *oc;
3348
    int use_video, use_audio, use_subtitle;
3349
    int input_has_video, input_has_audio, input_has_subtitle;
3350
    AVFormatParameters params, *ap = &params;
3351
    AVOutputFormat *file_oformat;
3352

    
3353
    if (!strcmp(filename, "-"))
3354
        filename = "pipe:";
3355

    
3356
    oc = avformat_alloc_context();
3357
    if (!oc) {
3358
        print_error(filename, AVERROR(ENOMEM));
3359
        av_exit(1);
3360
    }
3361

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

    
3378
    oc->oformat = file_oformat;
3379
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3380

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

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

    
3408
        /* manual disable */
3409
        if (audio_disable) {
3410
            use_audio = 0;
3411
        }
3412
        if (video_disable) {
3413
            use_video = 0;
3414
        }
3415
        if (subtitle_disable) {
3416
            use_subtitle = 0;
3417
        }
3418

    
3419
        if (use_video) {
3420
            new_video_stream(oc);
3421
        }
3422

    
3423
        if (use_audio) {
3424
            new_audio_stream(oc);
3425
        }
3426

    
3427
        if (use_subtitle) {
3428
            new_subtitle_stream(oc);
3429
        }
3430

    
3431
        oc->timestamp = rec_timestamp;
3432

    
3433
        for(; metadata_count>0; metadata_count--){
3434
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3435
                                           metadata[metadata_count-1].value);
3436
        }
3437
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3438
    }
3439

    
3440
    output_files[nb_output_files++] = oc;
3441

    
3442
    /* check filename in case of an image number is expected */
3443
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3444
        if (!av_filename_number_test(oc->filename)) {
3445
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3446
            av_exit(1);
3447
        }
3448
    }
3449

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

    
3472
        /* open the file */
3473
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3474
            fprintf(stderr, "Could not open '%s'\n", filename);
3475
            av_exit(1);
3476
        }
3477
    }
3478

    
3479
    memset(ap, 0, sizeof(*ap));
3480
    if (av_set_parameters(oc, ap) < 0) {
3481
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3482
                oc->filename);
3483
        av_exit(1);
3484
    }
3485

    
3486
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3487
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3488
    oc->loop_output = loop_output;
3489
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3490

    
3491
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3492
}
3493

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

    
3506
static int64_t getutime(void)
3507
{
3508
#if HAVE_GETRUSAGE
3509
    struct rusage rusage;
3510

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

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

    
3541
static void opt_inter_matrix(const char *arg)
3542
{
3543
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3544
    parse_matrix_coeffs(inter_matrix, arg);
3545
}
3546

    
3547
static void opt_intra_matrix(const char *arg)
3548
{
3549
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3550
    parse_matrix_coeffs(intra_matrix, arg);
3551
}
3552

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

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

    
3599
static void opt_target(const char *arg)
3600
{
3601
    int norm = -1;
3602
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3603

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

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

    
3655
    if(!strcmp(arg, "vcd")) {
3656

    
3657
        opt_video_codec("mpeg1video");
3658
        opt_audio_codec("mp2");
3659
        opt_format("vcd");
3660

    
3661
        opt_frame_size(norm ? "352x240" : "352x288");
3662
        opt_frame_rate(NULL, frame_rates[norm]);
3663
        opt_default("g", norm ? "18" : "15");
3664

    
3665
        opt_default("b", "1150000");
3666
        opt_default("maxrate", "1150000");
3667
        opt_default("minrate", "1150000");
3668
        opt_default("bufsize", "327680"); // 40*1024*8;
3669

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

    
3674
        opt_default("packetsize", "2324");
3675
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3676

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

    
3685
        opt_video_codec("mpeg2video");
3686
        opt_audio_codec("mp2");
3687
        opt_format("svcd");
3688

    
3689
        opt_frame_size(norm ? "480x480" : "480x576");
3690
        opt_frame_rate(NULL, frame_rates[norm]);
3691
        opt_default("g", norm ? "18" : "15");
3692

    
3693
        opt_default("b", "2040000");
3694
        opt_default("maxrate", "2516000");
3695
        opt_default("minrate", "0"); //1145000;
3696
        opt_default("bufsize", "1835008"); //224*1024*8;
3697
        opt_default("flags", "+scan_offset");
3698

    
3699

    
3700
        opt_default("ab", "224000");
3701
        audio_sample_rate = 44100;
3702

    
3703
        opt_default("packetsize", "2324");
3704

    
3705
    } else if(!strcmp(arg, "dvd")) {
3706

    
3707
        opt_video_codec("mpeg2video");
3708
        opt_audio_codec("ac3");
3709
        opt_format("dvd");
3710

    
3711
        opt_frame_size(norm ? "720x480" : "720x576");
3712
        opt_frame_rate(NULL, frame_rates[norm]);
3713
        opt_default("g", norm ? "18" : "15");
3714

    
3715
        opt_default("b", "6000000");
3716
        opt_default("maxrate", "9000000");
3717
        opt_default("minrate", "0"); //1500000;
3718
        opt_default("bufsize", "1835008"); //224*1024*8;
3719

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

    
3723
        opt_default("ab", "448000");
3724
        audio_sample_rate = 48000;
3725

    
3726
    } else if(!strncmp(arg, "dv", 2)) {
3727

    
3728
        opt_format("dv");
3729

    
3730
        opt_frame_size(norm ? "720x480" : "720x576");
3731
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3732
                                             (norm ? "yuv411p" : "yuv420p"));
3733
        opt_frame_rate(NULL, frame_rates[norm]);
3734

    
3735
        audio_sample_rate = 48000;
3736
        audio_channels = 2;
3737

    
3738
    } else {
3739
        fprintf(stderr, "Unknown target: %s\n", arg);
3740
        av_exit(1);
3741
    }
3742
}
3743

    
3744
static void opt_vstats_file (const char *arg)
3745
{
3746
    av_free (vstats_filename);
3747
    vstats_filename=av_strdup (arg);
3748
}
3749

    
3750
static void opt_vstats (void)
3751
{
3752
    char filename[40];
3753
    time_t today2 = time(NULL);
3754
    struct tm *today = localtime(&today2);
3755

    
3756
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3757
             today->tm_sec);
3758
    opt_vstats_file(filename);
3759
}
3760

    
3761
static int opt_bsf(const char *opt, const char *arg)
3762
{
3763
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3764
    AVBitStreamFilterContext **bsfp;
3765

    
3766
    if(!bsfc){
3767
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3768
        av_exit(1);
3769
    }
3770

    
3771
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3772
          *opt == 'a' ? &audio_bitstream_filters :
3773
                        &subtitle_bitstream_filters;
3774
    while(*bsfp)
3775
        bsfp= &(*bsfp)->next;
3776

    
3777
    *bsfp= bsfc;
3778

    
3779
    return 0;
3780
}
3781

    
3782
static int opt_preset(const char *opt, const char *arg)
3783
{
3784
    FILE *f=NULL;
3785
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3786
    int i;
3787
    const char *base[2]= { getenv("HOME"),
3788
                           FFMPEG_DATADIR,
3789
                         };
3790

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

    
3808
    if(!f){
3809
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3810
        av_exit(1);
3811
    }
3812

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

    
3834
    fclose(f);
3835

    
3836
    return 0;
3837
}
3838

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

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

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

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

    
3941
    /* grab options */
3942
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3943
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3944
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3945

    
3946
    /* muxer options */
3947
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3948
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3949

    
3950
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3951
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3952
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3953

    
3954
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3955
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3956
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3957
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3958

    
3959
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3960
    { NULL, },
3961
};
3962

    
3963
int main(int argc, char **argv)
3964
{
3965
    int i;
3966
    int64_t ti;
3967

    
3968
    avcodec_register_all();
3969
    avdevice_register_all();
3970
    av_register_all();
3971

    
3972
#if HAVE_ISATTY
3973
    if(isatty(STDIN_FILENO))
3974
        url_set_interrupt_cb(decode_interrupt_cb);
3975
#endif
3976

    
3977
    for(i=0; i<CODEC_TYPE_NB; i++){
3978
        avcodec_opts[i]= avcodec_alloc_context2(i);
3979
    }
3980
    avformat_opts = avformat_alloc_context();
3981
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3982

    
3983
    show_banner();
3984

    
3985
    /* parse options */
3986
    parse_options(argc, argv, options, opt_output_file);
3987

    
3988
    if(nb_output_files <= 0 && nb_input_files == 0)
3989
        show_help();
3990

    
3991
    /* file converter / grab */
3992
    if (nb_output_files <= 0) {
3993
        fprintf(stderr, "At least one output file must be specified\n");
3994
        av_exit(1);
3995
    }
3996

    
3997
    if (nb_input_files == 0) {
3998
        fprintf(stderr, "At least one input file must be specified\n");
3999
        av_exit(1);
4000
    }
4001

    
4002
    ti = getutime();
4003
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4004
                  stream_maps, nb_stream_maps) < 0)
4005
        av_exit(1);
4006
    ti = getutime() - ti;
4007
    if (do_benchmark) {
4008
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4009
    }
4010

    
4011
    return av_exit(0);
4012
}