Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 0fc2c0f6

History | View | Annotate | Download (145 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 char *video_language = NULL;
138
static int same_quality = 0;
139
static int do_deinterlace = 0;
140
static int top_field_first = -1;
141
static int me_threshold = 0;
142
static int intra_dc_precision = 8;
143
static int loop_input = 0;
144
static int loop_output = AVFMT_NOOUTPUTLOOP;
145
static int qp_hist = 0;
146

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

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

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

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

    
193
static int rate_emu = 0;
194

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

    
198
static int audio_volume = 256;
199

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

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

    
217
static unsigned int sws_flags = SWS_BICUBIC;
218

    
219
static int64_t timer_start;
220

    
221
static uint8_t *audio_buf;
222
static uint8_t *audio_out;
223
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
224

    
225
static short *samples;
226

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

    
232
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
233

    
234
struct AVInputStream;
235

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

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

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

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

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

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

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

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

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

    
311
#if HAVE_TERMIOS_H
312

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

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

    
324
static volatile int received_sigterm = 0;
325

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
435
    av_free(opt_names);
436

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

    
441
    av_free(video_standard);
442

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
543
        bsfc= bsfc->next;
544
    }
545

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

    
553
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
554

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
900
    *frame_size = 0;
901

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1171

    
1172
    oc = output_files[0];
1173

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

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

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

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

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

    
1245
        if (nb_frames_dup || nb_frames_drop)
1246
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1247
                  nb_frames_dup, nb_frames_drop);
1248

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

    
1252
        fflush(stderr);
1253
    }
1254

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1461
                        av_init_packet(&opkt);
1462

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1649
    return -1;
1650
}
1651

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2117

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

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

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

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

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

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

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

    
2178
    timer_start = av_gettime();
2179

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2318
    discard_packet:
2319
        av_free_packet(&pkt);
2320

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

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

    
2333
    term_exit();
2334

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

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

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

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

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

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

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

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

    
2410
    last_asked_format = arg;
2411
}
2412

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

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

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

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

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

    
2443
    opt_default(opt, arg);
2444

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

    
2448
    return 0;
2449
}
2450

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

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

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

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

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

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

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

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

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

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

    
2548

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

    
2558

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

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

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

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

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

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

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

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

    
2621
    return 0;
2622
}
2623

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2877
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2878

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

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

    
2897
    ic->loop_input = loop_input;
2898

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

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

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

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

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

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

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

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

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

    
3002
    nb_input_files++;
3003

    
3004
    video_channel = 0;
3005

    
3006
    av_freep(&video_codec_name);
3007
    av_freep(&audio_codec_name);
3008
    av_freep(&subtitle_codec_name);
3009
}
3010

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

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

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

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

    
3063
    if(thread_count>1)
3064
        avcodec_thread_init(st->codec, thread_count);
3065

    
3066
    video_enc = st->codec;
3067

    
3068
    if(video_codec_tag)
3069
        video_enc->codec_tag= video_codec_tag;
3070

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

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

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

    
3101
        video_enc->codec_id = codec_id;
3102

    
3103
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3104

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

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

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

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

    
3134
        if(intra_matrix)
3135
            video_enc->intra_matrix = intra_matrix;
3136
        if(inter_matrix)
3137
            video_enc->inter_matrix = inter_matrix;
3138

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

    
3170
        if (do_psnr)
3171
            video_enc->flags|= CODEC_FLAG_PSNR;
3172

    
3173
        /* two pass mode */
3174
        if (do_pass) {
3175
            if (do_pass == 1) {
3176
                video_enc->flags |= CODEC_FLAG_PASS1;
3177
            } else {
3178
                video_enc->flags |= CODEC_FLAG_PASS2;
3179
            }
3180
        }
3181
    }
3182
    nb_ocodecs++;
3183
    if (video_language) {
3184
        av_metadata_set(&st->metadata, "language", video_language);
3185
        av_freep(&video_language);
3186
    }
3187

    
3188
    /* reset some key parameters */
3189
    video_disable = 0;
3190
    av_freep(&video_codec_name);
3191
    video_stream_copy = 0;
3192
}
3193

    
3194
static void new_audio_stream(AVFormatContext *oc)
3195
{
3196
    AVStream *st;
3197
    AVCodecContext *audio_enc;
3198
    enum CodecID codec_id;
3199

    
3200
    st = av_new_stream(oc, oc->nb_streams);
3201
    if (!st) {
3202
        fprintf(stderr, "Could not alloc stream\n");
3203
        av_exit(1);
3204
    }
3205
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3206

    
3207
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3208
    audio_bitstream_filters= NULL;
3209

    
3210
    if(thread_count>1)
3211
        avcodec_thread_init(st->codec, thread_count);
3212

    
3213
    audio_enc = st->codec;
3214
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3215

    
3216
    if(audio_codec_tag)
3217
        audio_enc->codec_tag= audio_codec_tag;
3218

    
3219
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3220
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3221
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3222
    }
3223
    if (audio_stream_copy) {
3224
        st->stream_copy = 1;
3225
        audio_enc->channels = audio_channels;
3226
    } else {
3227
        AVCodec *codec;
3228

    
3229
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3230

    
3231
        if (audio_codec_name) {
3232
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3233
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3234
            output_codecs[nb_ocodecs] = codec;
3235
        } else {
3236
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3237
            codec = avcodec_find_encoder(codec_id);
3238
        }
3239
        audio_enc->codec_id = codec_id;
3240

    
3241
        if (audio_qscale > QSCALE_NONE) {
3242
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3243
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3244
        }
3245
        audio_enc->thread_count = thread_count;
3246
        audio_enc->channels = audio_channels;
3247
        audio_enc->sample_fmt = audio_sample_fmt;
3248
        audio_enc->channel_layout = channel_layout;
3249
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3250
            audio_enc->channel_layout = 0;
3251

    
3252
        if(codec && codec->sample_fmts){
3253
            const enum SampleFormat *p= codec->sample_fmts;
3254
            for(; *p!=-1; p++){
3255
                if(*p == audio_enc->sample_fmt)
3256
                    break;
3257
            }
3258
            if(*p == -1)
3259
                audio_enc->sample_fmt = codec->sample_fmts[0];
3260
        }
3261
    }
3262
    nb_ocodecs++;
3263
    audio_enc->sample_rate = audio_sample_rate;
3264
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3265
    if (audio_language) {
3266
        av_metadata_set(&st->metadata, "language", audio_language);
3267
        av_freep(&audio_language);
3268
    }
3269

    
3270
    /* reset some key parameters */
3271
    audio_disable = 0;
3272
    av_freep(&audio_codec_name);
3273
    audio_stream_copy = 0;
3274
}
3275

    
3276
static void new_subtitle_stream(AVFormatContext *oc)
3277
{
3278
    AVStream *st;
3279
    AVCodecContext *subtitle_enc;
3280

    
3281
    st = av_new_stream(oc, oc->nb_streams);
3282
    if (!st) {
3283
        fprintf(stderr, "Could not alloc stream\n");
3284
        av_exit(1);
3285
    }
3286
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3287

    
3288
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3289
    subtitle_bitstream_filters= NULL;
3290

    
3291
    subtitle_enc = st->codec;
3292
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3293

    
3294
    if(subtitle_codec_tag)
3295
        subtitle_enc->codec_tag= subtitle_codec_tag;
3296

    
3297
    if (subtitle_stream_copy) {
3298
        st->stream_copy = 1;
3299
    } else {
3300
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3301
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3302
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3303
    }
3304
    nb_ocodecs++;
3305

    
3306
    if (subtitle_language) {
3307
        av_metadata_set(&st->metadata, "language", subtitle_language);
3308
        av_freep(&subtitle_language);
3309
    }
3310

    
3311
    subtitle_disable = 0;
3312
    av_freep(&subtitle_codec_name);
3313
    subtitle_stream_copy = 0;
3314
}
3315

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

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

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

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

    
3357
    if (!strcmp(filename, "-"))
3358
        filename = "pipe:";
3359

    
3360
    oc = avformat_alloc_context();
3361
    if (!oc) {
3362
        print_error(filename, AVERROR(ENOMEM));
3363
        av_exit(1);
3364
    }
3365

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

    
3382
    oc->oformat = file_oformat;
3383
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3384

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

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

    
3412
        /* manual disable */
3413
        if (audio_disable) {
3414
            use_audio = 0;
3415
        }
3416
        if (video_disable) {
3417
            use_video = 0;
3418
        }
3419
        if (subtitle_disable) {
3420
            use_subtitle = 0;
3421
        }
3422

    
3423
        if (use_video) {
3424
            new_video_stream(oc);
3425
        }
3426

    
3427
        if (use_audio) {
3428
            new_audio_stream(oc);
3429
        }
3430

    
3431
        if (use_subtitle) {
3432
            new_subtitle_stream(oc);
3433
        }
3434

    
3435
        oc->timestamp = rec_timestamp;
3436

    
3437
        for(; metadata_count>0; metadata_count--){
3438
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3439
                                           metadata[metadata_count-1].value);
3440
        }
3441
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3442
    }
3443

    
3444
    output_files[nb_output_files++] = oc;
3445

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

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

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

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

    
3490
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3491
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3492
    oc->loop_output = loop_output;
3493
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3494

    
3495
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3496
}
3497

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

    
3510
static int64_t getutime(void)
3511
{
3512
#if HAVE_GETRUSAGE
3513
    struct rusage rusage;
3514

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

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

    
3545
static void opt_inter_matrix(const char *arg)
3546
{
3547
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3548
    parse_matrix_coeffs(inter_matrix, arg);
3549
}
3550

    
3551
static void opt_intra_matrix(const char *arg)
3552
{
3553
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3554
    parse_matrix_coeffs(intra_matrix, arg);
3555
}
3556

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

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

    
3603
static void opt_target(const char *arg)
3604
{
3605
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3606
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3607

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

    
3652
    if(norm == UNKNOWN) {
3653
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3654
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3655
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3656
        av_exit(1);
3657
    }
3658

    
3659
    if(!strcmp(arg, "vcd")) {
3660

    
3661
        opt_video_codec("mpeg1video");
3662
        opt_audio_codec("mp2");
3663
        opt_format("vcd");
3664

    
3665
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3666
        opt_frame_rate(NULL, frame_rates[norm]);
3667
        opt_default("g", norm == PAL ? "15" : "18");
3668

    
3669
        opt_default("b", "1150000");
3670
        opt_default("maxrate", "1150000");
3671
        opt_default("minrate", "1150000");
3672
        opt_default("bufsize", "327680"); // 40*1024*8;
3673

    
3674
        opt_default("ab", "224000");
3675
        audio_sample_rate = 44100;
3676
        audio_channels = 2;
3677

    
3678
        opt_default("packetsize", "2324");
3679
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3680

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

    
3689
        opt_video_codec("mpeg2video");
3690
        opt_audio_codec("mp2");
3691
        opt_format("svcd");
3692

    
3693
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3694
        opt_frame_rate(NULL, frame_rates[norm]);
3695
        opt_default("g", norm == PAL ? "15" : "18");
3696

    
3697
        opt_default("b", "2040000");
3698
        opt_default("maxrate", "2516000");
3699
        opt_default("minrate", "0"); //1145000;
3700
        opt_default("bufsize", "1835008"); //224*1024*8;
3701
        opt_default("flags", "+scan_offset");
3702

    
3703

    
3704
        opt_default("ab", "224000");
3705
        audio_sample_rate = 44100;
3706

    
3707
        opt_default("packetsize", "2324");
3708

    
3709
    } else if(!strcmp(arg, "dvd")) {
3710

    
3711
        opt_video_codec("mpeg2video");
3712
        opt_audio_codec("ac3");
3713
        opt_format("dvd");
3714

    
3715
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3716
        opt_frame_rate(NULL, frame_rates[norm]);
3717
        opt_default("g", norm == PAL ? "15" : "18");
3718

    
3719
        opt_default("b", "6000000");
3720
        opt_default("maxrate", "9000000");
3721
        opt_default("minrate", "0"); //1500000;
3722
        opt_default("bufsize", "1835008"); //224*1024*8;
3723

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

    
3727
        opt_default("ab", "448000");
3728
        audio_sample_rate = 48000;
3729

    
3730
    } else if(!strncmp(arg, "dv", 2)) {
3731

    
3732
        opt_format("dv");
3733

    
3734
        opt_frame_size(norm != PAL ? "720x480" : "720x576");
3735
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3736
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3737
        opt_frame_rate(NULL, frame_rates[norm]);
3738

    
3739
        audio_sample_rate = 48000;
3740
        audio_channels = 2;
3741

    
3742
    } else {
3743
        fprintf(stderr, "Unknown target: %s\n", arg);
3744
        av_exit(1);
3745
    }
3746
}
3747

    
3748
static void opt_vstats_file (const char *arg)
3749
{
3750
    av_free (vstats_filename);
3751
    vstats_filename=av_strdup (arg);
3752
}
3753

    
3754
static void opt_vstats (void)
3755
{
3756
    char filename[40];
3757
    time_t today2 = time(NULL);
3758
    struct tm *today = localtime(&today2);
3759

    
3760
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3761
             today->tm_sec);
3762
    opt_vstats_file(filename);
3763
}
3764

    
3765
static int opt_bsf(const char *opt, const char *arg)
3766
{
3767
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3768
    AVBitStreamFilterContext **bsfp;
3769

    
3770
    if(!bsfc){
3771
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3772
        av_exit(1);
3773
    }
3774

    
3775
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3776
          *opt == 'a' ? &audio_bitstream_filters :
3777
                        &subtitle_bitstream_filters;
3778
    while(*bsfp)
3779
        bsfp= &(*bsfp)->next;
3780

    
3781
    *bsfp= bsfc;
3782

    
3783
    return 0;
3784
}
3785

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

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

    
3812
    if(!f){
3813
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3814
        av_exit(1);
3815
    }
3816

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

    
3838
    fclose(f);
3839

    
3840
    return 0;
3841
}
3842

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

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

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

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

    
3946
    /* grab options */
3947
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3948
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3949
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3950

    
3951
    /* muxer options */
3952
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3953
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3954

    
3955
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3956
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3957
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3958

    
3959
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3960
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3961
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3962
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3963

    
3964
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3965
    { NULL, },
3966
};
3967

    
3968
int main(int argc, char **argv)
3969
{
3970
    int i;
3971
    int64_t ti;
3972

    
3973
    avcodec_register_all();
3974
    avdevice_register_all();
3975
    av_register_all();
3976

    
3977
#if HAVE_ISATTY
3978
    if(isatty(STDIN_FILENO))
3979
        url_set_interrupt_cb(decode_interrupt_cb);
3980
#endif
3981

    
3982
    for(i=0; i<CODEC_TYPE_NB; i++){
3983
        avcodec_opts[i]= avcodec_alloc_context2(i);
3984
    }
3985
    avformat_opts = avformat_alloc_context();
3986
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3987

    
3988
    show_banner();
3989

    
3990
    /* parse options */
3991
    parse_options(argc, argv, options, opt_output_file);
3992

    
3993
    if(nb_output_files <= 0 && nb_input_files == 0)
3994
        show_help();
3995

    
3996
    /* file converter / grab */
3997
    if (nb_output_files <= 0) {
3998
        fprintf(stderr, "At least one output file must be specified\n");
3999
        av_exit(1);
4000
    }
4001

    
4002
    if (nb_input_files == 0) {
4003
        fprintf(stderr, "At least one input file must be specified\n");
4004
        av_exit(1);
4005
    }
4006

    
4007
    ti = getutime();
4008
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4009
                  stream_maps, nb_stream_maps) < 0)
4010
        av_exit(1);
4011
    ti = getutime() - ti;
4012
    if (do_benchmark) {
4013
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4014
    }
4015

    
4016
    return av_exit(0);
4017
}