Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 036c1382

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
    int got_picture;
1276
    AVFrame picture;
1277
    void *buffer_to_free;
1278
    static unsigned int samples_size= 0;
1279
    AVSubtitle subtitle, *subtitle_to_free;
1280
    int got_subtitle;
1281
    AVPacket avpkt;
1282
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1283

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1464
                        av_init_packet(&opkt);
1465

    
1466
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1467
                            continue;
1468

    
1469
                        /* no reencoding needed : output the packet directly */
1470
                        /* force the input stream PTS */
1471

    
1472
                        avcodec_get_frame_defaults(&avframe);
1473
                        ost->st->codec->coded_frame= &avframe;
1474
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1475

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

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

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

    
1495
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1496
                        opkt.flags= pkt->flags;
1497

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

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

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

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

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

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

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

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

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

    
1615
    return 0;
1616
 fail_decode:
1617
    return -1;
1618
}
1619

    
1620
static void print_sdp(AVFormatContext **avc, int n)
1621
{
1622
    char sdp[2048];
1623

    
1624
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1625
    printf("SDP:\n%s\n", sdp);
1626
    fflush(stdout);
1627
}
1628

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

    
1652
    return -1;
1653
}
1654

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

    
1676
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1677
    if (!file_table)
1678
        goto fail;
1679

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

    
1690
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1691
    if (!ist_table)
1692
        goto fail;
1693

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

    
1711
            if (rate_emu) {
1712
                ist->start = av_gettime();
1713
            }
1714
        }
1715
    }
1716

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

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

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

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

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

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

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

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

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

    
1842
        codec = ost->st->codec;
1843
        icodec = ist->st->codec;
1844

    
1845
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1846
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1847
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1848

    
1849
        ost->st->disposition = ist->st->disposition;
1850
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1851
        codec->chroma_sample_location = icodec->chroma_sample_location;
1852

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

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

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

    
1967
                    ost->original_height = icodec->height;
1968
                    ost->original_width  = icodec->width;
1969

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

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

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

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

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

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

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

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

    
2117
        out_file = output_files[out_file_index];
2118
        in_file = input_files[in_file_index];
2119

    
2120

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

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

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

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

    
2166
    if (ret) {
2167
        fprintf(stderr, "%s\n", error);
2168
        goto fail;
2169
    }
2170

    
2171
    if (want_sdp) {
2172
        print_sdp(output_files, nb_output_files);
2173
    }
2174

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

    
2181
    timer_start = av_gettime();
2182

    
2183
    for(; received_sigterm == 0;) {
2184
        int file_index, ist_index;
2185
        AVPacket pkt;
2186
        double ipts_min;
2187
        double opts_min;
2188

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

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

    
2243
        /* finish if recording time exhausted */
2244
        if (opts_min >= (recording_time / 1000000.0))
2245
            break;
2246

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

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

    
2267
        no_packet_count=0;
2268
        memset(no_packet, 0, sizeof(no_packet));
2269

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

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

    
2287
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2288
            if(pkt.pts != AV_NOPTS_VALUE)
2289
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2290
            if(pkt.dts != AV_NOPTS_VALUE)
2291
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2292
        }
2293

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

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

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

    
2321
    discard_packet:
2322
        av_free_packet(&pkt);
2323

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

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

    
2336
    term_exit();
2337

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

    
2344
    /* dump report by using the first video and audio streams */
2345
    print_report(output_files, ost_table, nb_ostreams, 1);
2346

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

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

    
2364
    /* finished ! */
2365
    ret = 0;
2366

    
2367
 fail:
2368
    av_freep(&bit_buffer);
2369
    av_free(file_table);
2370

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

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

    
2413
    last_asked_format = arg;
2414
}
2415

    
2416
static void opt_video_rc_override_string(const char *arg)
2417
{
2418
    video_rc_override_string = arg;
2419
}
2420

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

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

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

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

    
2446
    opt_default(opt, arg);
2447

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

    
2451
    return 0;
2452
}
2453

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

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

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

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

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

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

    
2524
    r = (rgb >> 16);
2525
    g = ((rgb >> 8) & 255);
2526
    b = (rgb & 255);
2527

    
2528
    padcolor[0] = RGB_TO_Y(r,g,b);
2529
    padcolor[1] = RGB_TO_U(r,g,b,0);
2530
    padcolor[2] = RGB_TO_V(r,g,b,0);
2531
}
2532

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

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

    
2551

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

    
2561

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

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

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

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

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

    
2609
static int opt_metadata(const char *opt, const char *arg)
2610
{
2611
    char *mid= strchr(arg, '=');
2612

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

    
2619
    metadata_count++;
2620
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2621
    metadata[metadata_count-1].key  = av_strdup(arg);
2622
    metadata[metadata_count-1].value= av_strdup(mid);
2623

    
2624
    return 0;
2625
}
2626

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

    
2637
static void opt_top_field_first(const char *arg)
2638
{
2639
    top_field_first= atoi(arg);
2640
}
2641

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

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

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

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

    
2674
static void opt_video_channel(const char *arg)
2675
{
2676
    video_channel = strtol(arg, NULL, 0);
2677
}
2678

    
2679
static void opt_video_standard(const char *arg)
2680
{
2681
    video_standard = av_strdup(arg);
2682
}
2683

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

    
2695
static void opt_audio_codec(const char *arg)
2696
{
2697
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2698
}
2699

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

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

    
2709
static void opt_video_tag(const char *arg)
2710
{
2711
    char *tail;
2712
    video_codec_tag= strtol(arg, &tail, 0);
2713

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

    
2718
static void opt_video_codec(const char *arg)
2719
{
2720
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2721
}
2722

    
2723
static void opt_subtitle_codec(const char *arg)
2724
{
2725
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2726
}
2727

    
2728
static void opt_subtitle_tag(const char *arg)
2729
{
2730
    char *tail;
2731
    subtitle_codec_tag= strtol(arg, &tail, 0);
2732

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

    
2737
static void opt_map(const char *arg)
2738
{
2739
    AVStreamMap *m;
2740
    char *p;
2741

    
2742
    m = &stream_maps[nb_stream_maps++];
2743

    
2744
    m->file_index = strtol(arg, &p, 0);
2745
    if (*p)
2746
        p++;
2747

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

    
2761
static void opt_map_meta_data(const char *arg)
2762
{
2763
    AVMetaDataMap *m;
2764
    char *p;
2765

    
2766
    m = &meta_data_maps[nb_meta_data_maps++];
2767

    
2768
    m->out_file = strtol(arg, &p, 0);
2769
    if (*p)
2770
        p++;
2771

    
2772
    m->in_file = strtol(p, &p, 0);
2773
}
2774

    
2775
static void opt_input_ts_scale(const char *arg)
2776
{
2777
    unsigned int stream;
2778
    double scale;
2779
    char *p;
2780

    
2781
    stream = strtol(arg, &p, 0);
2782
    if (*p)
2783
        p++;
2784
    scale= strtod(p, &p);
2785

    
2786
    if(stream >= MAX_STREAMS)
2787
        av_exit(1);
2788

    
2789
    input_files_ts_scale[nb_input_files][stream]= scale;
2790
}
2791

    
2792
static int opt_recording_time(const char *opt, const char *arg)
2793
{
2794
    recording_time = parse_time_or_die(opt, arg, 1);
2795
    return 0;
2796
}
2797

    
2798
static int opt_start_time(const char *opt, const char *arg)
2799
{
2800
    start_time = parse_time_or_die(opt, arg, 1);
2801
    return 0;
2802
}
2803

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

    
2810
static int opt_input_ts_offset(const char *opt, const char *arg)
2811
{
2812
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2813
    return 0;
2814
}
2815

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

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

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

    
2845
    if (last_asked_format) {
2846
        file_iformat = av_find_input_format(last_asked_format);
2847
        last_asked_format = NULL;
2848
    }
2849

    
2850
    if (!strcmp(filename, "-"))
2851
        filename = "pipe:";
2852

    
2853
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2854
                    !strcmp(filename, "/dev/stdin");
2855

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

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

    
2880
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2881

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

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

    
2900
    ic->loop_input = loop_input;
2901

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

    
2910
    timestamp = start_time;
2911
    /* add the stream start time */
2912
    if (ic->start_time != AV_NOPTS_VALUE)
2913
        timestamp += ic->start_time;
2914

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

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

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

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

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

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

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

    
3004
    nb_input_files++;
3005

    
3006
    video_channel = 0;
3007

    
3008
    av_freep(&video_codec_name);
3009
    av_freep(&audio_codec_name);
3010
    av_freep(&subtitle_codec_name);
3011
}
3012

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

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

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

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

    
3065
    if(thread_count>1)
3066
        avcodec_thread_init(st->codec, thread_count);
3067

    
3068
    video_enc = st->codec;
3069

    
3070
    if(video_codec_tag)
3071
        video_enc->codec_tag= video_codec_tag;
3072

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

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

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

    
3103
        video_enc->codec_id = codec_id;
3104

    
3105
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3106

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

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

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

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

    
3136
        if(intra_matrix)
3137
            video_enc->intra_matrix = intra_matrix;
3138
        if(inter_matrix)
3139
            video_enc->inter_matrix = inter_matrix;
3140

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3242
        if (audio_qscale > QSCALE_NONE) {
3243
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3244
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3245
        }
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 = av_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 = av_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_usage(void)
3567
{
3568
    printf("Hyper fast Audio and Video encoder\n");
3569
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3570
    printf("\n");
3571
}
3572

    
3573
static void show_help(void)
3574
{
3575
    av_log_set_callback(log_callback_help);
3576
    show_usage();
3577
    show_help_options(options, "Main options:\n",
3578
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3579
    show_help_options(options, "\nAdvanced options:\n",
3580
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3581
                      OPT_EXPERT);
3582
    show_help_options(options, "\nVideo options:\n",
3583
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3584
                      OPT_VIDEO);
3585
    show_help_options(options, "\nAdvanced Video options:\n",
3586
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3587
                      OPT_VIDEO | OPT_EXPERT);
3588
    show_help_options(options, "\nAudio options:\n",
3589
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3590
                      OPT_AUDIO);
3591
    show_help_options(options, "\nAdvanced Audio options:\n",
3592
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3593
                      OPT_AUDIO | OPT_EXPERT);
3594
    show_help_options(options, "\nSubtitle options:\n",
3595
                      OPT_SUBTITLE | OPT_GRAB,
3596
                      OPT_SUBTITLE);
3597
    show_help_options(options, "\nAudio/Video grab options:\n",
3598
                      OPT_GRAB,
3599
                      OPT_GRAB);
3600
    printf("\n");
3601
    av_opt_show(avcodec_opts[0], NULL);
3602
    printf("\n");
3603
    av_opt_show(avformat_opts, NULL);
3604
    printf("\n");
3605
    av_opt_show(sws_opts, NULL);
3606
}
3607

    
3608
static void opt_target(const char *arg)
3609
{
3610
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3611
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3612

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

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

    
3664
    if(!strcmp(arg, "vcd")) {
3665

    
3666
        opt_video_codec("mpeg1video");
3667
        opt_audio_codec("mp2");
3668
        opt_format("vcd");
3669

    
3670
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3671
        opt_frame_rate(NULL, frame_rates[norm]);
3672
        opt_default("g", norm == PAL ? "15" : "18");
3673

    
3674
        opt_default("b", "1150000");
3675
        opt_default("maxrate", "1150000");
3676
        opt_default("minrate", "1150000");
3677
        opt_default("bufsize", "327680"); // 40*1024*8;
3678

    
3679
        opt_default("ab", "224000");
3680
        audio_sample_rate = 44100;
3681
        audio_channels = 2;
3682

    
3683
        opt_default("packetsize", "2324");
3684
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3685

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

    
3694
        opt_video_codec("mpeg2video");
3695
        opt_audio_codec("mp2");
3696
        opt_format("svcd");
3697

    
3698
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3699
        opt_frame_rate(NULL, frame_rates[norm]);
3700
        opt_default("g", norm == PAL ? "15" : "18");
3701

    
3702
        opt_default("b", "2040000");
3703
        opt_default("maxrate", "2516000");
3704
        opt_default("minrate", "0"); //1145000;
3705
        opt_default("bufsize", "1835008"); //224*1024*8;
3706
        opt_default("flags", "+scan_offset");
3707

    
3708

    
3709
        opt_default("ab", "224000");
3710
        audio_sample_rate = 44100;
3711

    
3712
        opt_default("packetsize", "2324");
3713

    
3714
    } else if(!strcmp(arg, "dvd")) {
3715

    
3716
        opt_video_codec("mpeg2video");
3717
        opt_audio_codec("ac3");
3718
        opt_format("dvd");
3719

    
3720
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3721
        opt_frame_rate(NULL, frame_rates[norm]);
3722
        opt_default("g", norm == PAL ? "15" : "18");
3723

    
3724
        opt_default("b", "6000000");
3725
        opt_default("maxrate", "9000000");
3726
        opt_default("minrate", "0"); //1500000;
3727
        opt_default("bufsize", "1835008"); //224*1024*8;
3728

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

    
3732
        opt_default("ab", "448000");
3733
        audio_sample_rate = 48000;
3734

    
3735
    } else if(!strncmp(arg, "dv", 2)) {
3736

    
3737
        opt_format("dv");
3738

    
3739
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3740
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3741
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3742
        opt_frame_rate(NULL, frame_rates[norm]);
3743

    
3744
        audio_sample_rate = 48000;
3745
        audio_channels = 2;
3746

    
3747
    } else {
3748
        fprintf(stderr, "Unknown target: %s\n", arg);
3749
        av_exit(1);
3750
    }
3751
}
3752

    
3753
static void opt_vstats_file (const char *arg)
3754
{
3755
    av_free (vstats_filename);
3756
    vstats_filename=av_strdup (arg);
3757
}
3758

    
3759
static void opt_vstats (void)
3760
{
3761
    char filename[40];
3762
    time_t today2 = time(NULL);
3763
    struct tm *today = localtime(&today2);
3764

    
3765
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3766
             today->tm_sec);
3767
    opt_vstats_file(filename);
3768
}
3769

    
3770
static int opt_bsf(const char *opt, const char *arg)
3771
{
3772
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3773
    AVBitStreamFilterContext **bsfp;
3774

    
3775
    if(!bsfc){
3776
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3777
        av_exit(1);
3778
    }
3779

    
3780
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3781
          *opt == 'a' ? &audio_bitstream_filters :
3782
                        &subtitle_bitstream_filters;
3783
    while(*bsfp)
3784
        bsfp= &(*bsfp)->next;
3785

    
3786
    *bsfp= bsfc;
3787

    
3788
    return 0;
3789
}
3790

    
3791
static int opt_preset(const char *opt, const char *arg)
3792
{
3793
    FILE *f=NULL;
3794
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3795
    int i;
3796
    const char *base[2]= { getenv("HOME"),
3797
                           FFMPEG_DATADIR,
3798
                         };
3799

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

    
3817
    if(!f){
3818
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3819
        av_exit(1);
3820
    }
3821

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

    
3843
    fclose(f);
3844

    
3845
    return 0;
3846
}
3847

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

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

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

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

    
3951
    /* grab options */
3952
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3953
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3954
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3955

    
3956
    /* muxer options */
3957
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3958
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3959

    
3960
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3961
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3962
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3963

    
3964
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3965
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3966
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3967
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3968

    
3969
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3970
    { NULL, },
3971
};
3972

    
3973
int main(int argc, char **argv)
3974
{
3975
    int i;
3976
    int64_t ti;
3977

    
3978
    avcodec_register_all();
3979
    avdevice_register_all();
3980
    av_register_all();
3981

    
3982
#if HAVE_ISATTY
3983
    if(isatty(STDIN_FILENO))
3984
        url_set_interrupt_cb(decode_interrupt_cb);
3985
#endif
3986

    
3987
    for(i=0; i<CODEC_TYPE_NB; i++){
3988
        avcodec_opts[i]= avcodec_alloc_context2(i);
3989
    }
3990
    avformat_opts = avformat_alloc_context();
3991
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3992

    
3993
    show_banner();
3994

    
3995
    /* parse options */
3996
    parse_options(argc, argv, options, opt_output_file);
3997

    
3998
    if(nb_output_files <= 0 && nb_input_files == 0) {
3999
        show_usage();
4000
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4001
        av_exit(1);
4002
    }
4003

    
4004
    /* file converter / grab */
4005
    if (nb_output_files <= 0) {
4006
        fprintf(stderr, "At least one output file must be specified\n");
4007
        av_exit(1);
4008
    }
4009

    
4010
    if (nb_input_files == 0) {
4011
        fprintf(stderr, "At least one input file must be specified\n");
4012
        av_exit(1);
4013
    }
4014

    
4015
    ti = getutime();
4016
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4017
                  stream_maps, nb_stream_maps) < 0)
4018
        av_exit(1);
4019
    ti = getutime() - ti;
4020
    if (do_benchmark) {
4021
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4022
    }
4023

    
4024
    return av_exit(0);
4025
}