Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 60402344

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 100
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
    int showed_multi_packet_warning;
303
} AVInputStream;
304

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

    
312
#if HAVE_TERMIOS_H
313

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

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

    
325
static volatile int received_sigterm = 0;
326

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

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

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

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

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

    
355
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
356
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
357
#ifdef SIGXCPU
358
    signal(SIGXCPU, sigterm_handler);
359
#endif
360

    
361
    /*
362
    register a function to be called at normal program termination
363
    */
364
    atexit(term_exit);
365
#if CONFIG_BEOS_NETSERVER
366
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
367
#endif
368
}
369

    
370
/* read a key without blocking */
371
static int read_key(void)
372
{
373
#if HAVE_TERMIOS_H
374
    int n = 1;
375
    unsigned char ch;
376
#if !CONFIG_BEOS_NETSERVER
377
    struct timeval tv;
378
    fd_set rfds;
379

    
380
    FD_ZERO(&rfds);
381
    FD_SET(0, &rfds);
382
    tv.tv_sec = 0;
383
    tv.tv_usec = 0;
384
    n = select(1, &rfds, NULL, NULL, &tv);
385
#endif
386
    if (n > 0) {
387
        n = read(0, &ch, 1);
388
        if (n == 1)
389
            return ch;
390

    
391
        return n;
392
    }
393
#elif HAVE_CONIO_H
394
    if(kbhit())
395
        return(getch());
396
#endif
397
    return -1;
398
}
399

    
400
static int decode_interrupt_cb(void)
401
{
402
    return q_pressed || (q_pressed = read_key() == 'q');
403
}
404

    
405
static int av_exit(int ret)
406
{
407
    int i;
408

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

    
433
    av_free(intra_matrix);
434
    av_free(inter_matrix);
435

    
436
    if (vstats_file)
437
        fclose(vstats_file);
438
    av_free(vstats_filename);
439

    
440
    av_free(opt_names);
441

    
442
    av_free(video_codec_name);
443
    av_free(audio_codec_name);
444
    av_free(subtitle_codec_name);
445

    
446
    av_free(video_standard);
447

    
448
#if CONFIG_POWERPC_PERF
449
    void powerpc_display_perf_report(void);
450
    powerpc_display_perf_report();
451
#endif /* CONFIG_POWERPC_PERF */
452

    
453
    for (i=0;i<CODEC_TYPE_NB;i++)
454
        av_free(avcodec_opts[i]);
455
    av_free(avformat_opts);
456
    av_free(sws_opts);
457
    av_free(audio_buf);
458
    av_free(audio_out);
459
    allocated_audio_buf_size= allocated_audio_out_size= 0;
460
    av_free(samples);
461

    
462
    if (received_sigterm) {
463
        fprintf(stderr,
464
            "Received signal %d: terminating.\n",
465
            (int) received_sigterm);
466
        exit (255);
467
    }
468

    
469
    exit(ret); /* not all OS-es handle main() return value */
470
    return ret;
471
}
472

    
473
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
474
{
475
    int i, err;
476
    AVFormatContext *ic;
477
    int nopts = 0;
478

    
479
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
480
    if (err < 0)
481
        return err;
482
    /* copy stream format */
483
    s->nb_streams = ic->nb_streams;
484
    for(i=0;i<ic->nb_streams;i++) {
485
        AVStream *st;
486

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

    
498
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
499
            st->stream_copy = 1;
500
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
501
            st->stream_copy = 1;
502

    
503
        if(!st->codec->thread_count)
504
            st->codec->thread_count = 1;
505
        if(st->codec->thread_count>1)
506
            avcodec_thread_init(st->codec, st->codec->thread_count);
507

    
508
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
509
            nopts = 1;
510
    }
511

    
512
    if (!nopts)
513
        s->timestamp = av_gettime();
514

    
515
    av_close_input_file(ic);
516
    return 0;
517
}
518

    
519
static double
520
get_sync_ipts(const AVOutputStream *ost)
521
{
522
    const AVInputStream *ist = ost->sync_ist;
523
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
524
}
525

    
526
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
527
    int ret;
528

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

    
548
        bsfc= bsfc->next;
549
    }
550

    
551
    ret= av_interleaved_write_frame(s, pkt);
552
    if(ret < 0){
553
        print_error("av_interleaved_write_frame()", ret);
554
        av_exit(1);
555
    }
556
}
557

    
558
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
559

    
560
static void do_audio_out(AVFormatContext *s,
561
                         AVOutputStream *ost,
562
                         AVInputStream *ist,
563
                         unsigned char *buf, int size)
564
{
565
    uint8_t *buftmp;
566
    int64_t audio_out_size, audio_buf_size;
567
    int64_t allocated_for_size= size;
568

    
569
    int size_out, frame_bytes, ret;
570
    AVCodecContext *enc= ost->st->codec;
571
    AVCodecContext *dec= ist->st->codec;
572
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
573
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
574
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
575

    
576
need_realloc:
577
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
578
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
579
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
580
    audio_buf_size*= osize*enc->channels;
581

    
582
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
583
    if(coded_bps > 8*osize)
584
        audio_out_size= audio_out_size * coded_bps / (8*osize);
585
    audio_out_size += FF_MIN_BUFFER_SIZE;
586

    
587
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
588
        fprintf(stderr, "Buffer sizes too large\n");
589
        av_exit(1);
590
    }
591

    
592
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
593
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
594
    if (!audio_buf || !audio_out){
595
        fprintf(stderr, "Out of memory in do_audio_out\n");
596
        av_exit(1);
597
    }
598

    
599
    if (enc->channels != dec->channels)
600
        ost->audio_resample = 1;
601

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

    
617
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
618
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
619
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
620
        if (ost->reformat_ctx)
621
            av_audio_convert_free(ost->reformat_ctx);
622
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
623
                                                   dec->sample_fmt, 1, NULL, 0);
624
        if (!ost->reformat_ctx) {
625
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
626
                avcodec_get_sample_fmt_name(dec->sample_fmt),
627
                avcodec_get_sample_fmt_name(enc->sample_fmt));
628
            av_exit(1);
629
        }
630
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
631
    }
632

    
633
    if(audio_sync_method){
634
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
635
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
636
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
637
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
638

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

    
655
                    if(byte_delta > allocated_for_size - size){
656
                        allocated_for_size= byte_delta + (int64_t)size;
657
                        goto need_realloc;
658
                    }
659
                    ist->is_start=0;
660

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

    
681
    if (ost->audio_resample) {
682
        buftmp = audio_buf;
683
        size_out = audio_resample(ost->resample,
684
                                  (short *)buftmp, (short *)buf,
685
                                  size / (ist->st->codec->channels * isize));
686
        size_out = size_out * enc->channels * osize;
687
    } else {
688
        buftmp = buf;
689
        size_out = size;
690
    }
691

    
692
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
693
        const void *ibuf[6]= {buftmp};
694
        void *obuf[6]= {audio_buf};
695
        int istride[6]= {isize};
696
        int ostride[6]= {osize};
697
        int len= size_out/istride[0];
698
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
699
            printf("av_audio_convert() failed\n");
700
            if (exit_on_error)
701
                av_exit(1);
702
            return;
703
        }
704
        buftmp = audio_buf;
705
        size_out = len*osize;
706
    }
707

    
708
    /* now encode as many frames as possible */
709
    if (enc->frame_size > 1) {
710
        /* output resampled raw samples */
711
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
712
            fprintf(stderr, "av_fifo_realloc2() failed\n");
713
            av_exit(1);
714
        }
715
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
716

    
717
        frame_bytes = enc->frame_size * osize * enc->channels;
718

    
719
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
720
            AVPacket pkt;
721
            av_init_packet(&pkt);
722

    
723
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
724

    
725
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
726

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

    
742
            ost->sync_opts += enc->frame_size;
743
        }
744
    } else {
745
        AVPacket pkt;
746
        av_init_packet(&pkt);
747

    
748
        ost->sync_opts += size_out / (osize * enc->channels);
749

    
750
        /* output a pcm frame */
751
        /* determine the size of the coded buffer */
752
        size_out /= osize;
753
        if (coded_bps)
754
            size_out = size_out*coded_bps/8;
755

    
756
        if(size_out > audio_out_size){
757
            fprintf(stderr, "Internal error, buffer size too small\n");
758
            av_exit(1);
759
        }
760

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

    
779
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
780
{
781
    AVCodecContext *dec;
782
    AVPicture *picture2;
783
    AVPicture picture_tmp;
784
    uint8_t *buf = 0;
785

    
786
    dec = ist->st->codec;
787

    
788
    /* deinterlace : must be done before any resize */
789
    if (do_deinterlace) {
790
        int size;
791

    
792
        /* create temporary picture */
793
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
794
        buf = av_malloc(size);
795
        if (!buf)
796
            return;
797

    
798
        picture2 = &picture_tmp;
799
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
800

    
801
        if(avpicture_deinterlace(picture2, picture,
802
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
803
            /* if error, do not deinterlace */
804
            fprintf(stderr, "Deinterlacing failed\n");
805
            av_free(buf);
806
            buf = NULL;
807
            picture2 = picture;
808
        }
809
    } else {
810
        picture2 = picture;
811
    }
812

    
813
    if (picture != picture2)
814
        *picture = *picture2;
815
    *bufp = buf;
816
}
817

    
818
/* we begin to correct av delay at this threshold */
819
#define AV_DELAY_MAX 0.100
820

    
821
static void do_subtitle_out(AVFormatContext *s,
822
                            AVOutputStream *ost,
823
                            AVInputStream *ist,
824
                            AVSubtitle *sub,
825
                            int64_t pts)
826
{
827
    static uint8_t *subtitle_out = NULL;
828
    int subtitle_out_max_size = 1024 * 1024;
829
    int subtitle_out_size, nb, i;
830
    AVCodecContext *enc;
831
    AVPacket pkt;
832

    
833
    if (pts == AV_NOPTS_VALUE) {
834
        fprintf(stderr, "Subtitle packets must have a pts\n");
835
        if (exit_on_error)
836
            av_exit(1);
837
        return;
838
    }
839

    
840
    enc = ost->st->codec;
841

    
842
    if (!subtitle_out) {
843
        subtitle_out = av_malloc(subtitle_out_max_size);
844
    }
845

    
846
    /* Note: DVB subtitle need one packet to draw them and one other
847
       packet to clear them */
848
    /* XXX: signal it in the codec context ? */
849
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
850
        nb = 2;
851
    else
852
        nb = 1;
853

    
854
    for(i = 0; i < nb; i++) {
855
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
856
        // start_display_time is required to be 0
857
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
858
        sub->end_display_time -= sub->start_display_time;
859
        sub->start_display_time = 0;
860
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
861
                                                    subtitle_out_max_size, sub);
862
        if (subtitle_out_size < 0) {
863
            fprintf(stderr, "Subtitle encoding failed\n");
864
            av_exit(1);
865
        }
866

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

    
884
static int bit_buffer_size= 1024*256;
885
static uint8_t *bit_buffer= NULL;
886

    
887
static void do_video_out(AVFormatContext *s,
888
                         AVOutputStream *ost,
889
                         AVInputStream *ist,
890
                         AVFrame *in_picture,
891
                         int *frame_size)
892
{
893
    int nb_frames, i, ret;
894
    int64_t topBand, bottomBand, leftBand, rightBand;
895
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
896
    AVFrame picture_crop_temp, picture_pad_temp;
897
    AVCodecContext *enc, *dec;
898

    
899
    avcodec_get_frame_defaults(&picture_crop_temp);
900
    avcodec_get_frame_defaults(&picture_pad_temp);
901

    
902
    enc = ost->st->codec;
903
    dec = ist->st->codec;
904

    
905
    /* by default, we output a single frame */
906
    nb_frames = 1;
907

    
908
    *frame_size = 0;
909

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

    
936
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
937
    if (nb_frames <= 0)
938
        return;
939

    
940
    if (ost->video_crop) {
941
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
942
            fprintf(stderr, "error cropping picture\n");
943
            if (exit_on_error)
944
                av_exit(1);
945
            return;
946
        }
947
        formatted_picture = &picture_crop_temp;
948
    } else {
949
        formatted_picture = in_picture;
950
    }
951

    
952
    final_picture = formatted_picture;
953
    padding_src = formatted_picture;
954
    resampling_dst = &ost->pict_tmp;
955
    if (ost->video_pad) {
956
        final_picture = &ost->pict_tmp;
957
        if (ost->video_resample) {
958
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
959
                fprintf(stderr, "error padding picture\n");
960
                if (exit_on_error)
961
                    av_exit(1);
962
                return;
963
            }
964
            resampling_dst = &picture_pad_temp;
965
        }
966
    }
967

    
968
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
969
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
970
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
971

    
972
        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));
973
        if(!ost->video_resample)
974
            av_exit(1);
975
    }
976

    
977
    if (ost->video_resample) {
978
        padding_src = NULL;
979
        final_picture = &ost->pict_tmp;
980
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
981
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
982
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
983

    
984
            /* keep bands proportional to the frame size */
985
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
986
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
987
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
988
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
989

    
990
            /* sanity check to ensure no bad band sizes sneak in */
991
            assert(topBand    <= INT_MAX && topBand    >= 0);
992
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
993
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
994
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
995

    
996
            ost->topBand    = topBand;
997
            ost->bottomBand = bottomBand;
998
            ost->leftBand   = leftBand;
999
            ost->rightBand  = rightBand;
1000

    
1001
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1002
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1003
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1004

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

    
1025
    if (ost->video_pad) {
1026
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1027
                enc->height, enc->width, enc->pix_fmt,
1028
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1029
    }
1030

    
1031
    /* duplicates frame if needed */
1032
    for(i=0;i<nb_frames;i++) {
1033
        AVPacket pkt;
1034
        av_init_packet(&pkt);
1035
        pkt.stream_index= ost->index;
1036

    
1037
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1038
            /* raw pictures are written as AVPicture structure to
1039
               avoid any copies. We support temorarily the older
1040
               method. */
1041
            AVFrame* old_frame = enc->coded_frame;
1042
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1043
            pkt.data= (uint8_t *)final_picture;
1044
            pkt.size=  sizeof(AVPicture);
1045
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1046
            pkt.flags |= PKT_FLAG_KEY;
1047

    
1048
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1049
            enc->coded_frame = old_frame;
1050
        } else {
1051
            AVFrame big_picture;
1052

    
1053
            big_picture= *final_picture;
1054
            /* better than nothing: use input picture interlaced
1055
               settings */
1056
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1057
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1058
                if(top_field_first == -1)
1059
                    big_picture.top_field_first = in_picture->top_field_first;
1060
                else
1061
                    big_picture.top_field_first = top_field_first;
1062
            }
1063

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

    
1084
            if(ret>0){
1085
                pkt.data= bit_buffer;
1086
                pkt.size= ret;
1087
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1088
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1089
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1090
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1091
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1092

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

    
1111
static double psnr(double d){
1112
    return -10.0*log(d)/log(10.0);
1113
}
1114

    
1115
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1116
                           int frame_size)
1117
{
1118
    AVCodecContext *enc;
1119
    int frame_number;
1120
    double ti1, bitrate, avg_bitrate;
1121

    
1122
    /* this is executed just the first time do_video_stats is called */
1123
    if (!vstats_file) {
1124
        vstats_file = fopen(vstats_filename, "w");
1125
        if (!vstats_file) {
1126
            perror("fopen");
1127
            av_exit(1);
1128
        }
1129
    }
1130

    
1131
    enc = ost->st->codec;
1132
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1133
        frame_number = ost->frame_number;
1134
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1135
        if (enc->flags&CODEC_FLAG_PSNR)
1136
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1137

    
1138
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1139
        /* compute pts value */
1140
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1141
        if (ti1 < 0.01)
1142
            ti1 = 0.01;
1143

    
1144
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1145
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1146
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1147
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1148
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1149
    }
1150
}
1151

    
1152
static void print_report(AVFormatContext **output_files,
1153
                         AVOutputStream **ost_table, int nb_ostreams,
1154
                         int is_last_report)
1155
{
1156
    char buf[1024];
1157
    AVOutputStream *ost;
1158
    AVFormatContext *oc;
1159
    int64_t total_size;
1160
    AVCodecContext *enc;
1161
    int frame_number, vid, i;
1162
    double bitrate, ti1, pts;
1163
    static int64_t last_time = -1;
1164
    static int qp_histogram[52];
1165

    
1166
    if (!is_last_report) {
1167
        int64_t cur_time;
1168
        /* display the report every 0.5 seconds */
1169
        cur_time = av_gettime();
1170
        if (last_time == -1) {
1171
            last_time = cur_time;
1172
            return;
1173
        }
1174
        if ((cur_time - last_time) < 500000)
1175
            return;
1176
        last_time = cur_time;
1177
    }
1178

    
1179

    
1180
    oc = output_files[0];
1181

    
1182
    total_size = url_fsize(oc->pb);
1183
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1184
        total_size= url_ftell(oc->pb);
1185

    
1186
    buf[0] = '\0';
1187
    ti1 = 1e10;
1188
    vid = 0;
1189
    for(i=0;i<nb_ostreams;i++) {
1190
        ost = ost_table[i];
1191
        enc = ost->st->codec;
1192
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1193
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1194
                     !ost->st->stream_copy ?
1195
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1196
        }
1197
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1198
            float t = (av_gettime()-timer_start) / 1000000.0;
1199

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

    
1246
    if (verbose || is_last_report) {
1247
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1248

    
1249
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1250
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1251
            (double)total_size / 1024, ti1, bitrate);
1252

    
1253
        if (nb_frames_dup || nb_frames_drop)
1254
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1255
                  nb_frames_dup, nb_frames_drop);
1256

    
1257
        if (verbose >= 0)
1258
            fprintf(stderr, "%s    \r", buf);
1259

    
1260
        fflush(stderr);
1261
    }
1262

    
1263
    if (is_last_report && verbose >= 0){
1264
        int64_t raw= audio_size + video_size + extra_size;
1265
        fprintf(stderr, "\n");
1266
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1267
                video_size/1024.0,
1268
                audio_size/1024.0,
1269
                extra_size/1024.0,
1270
                100.0*(total_size - raw)/raw
1271
        );
1272
    }
1273
}
1274

    
1275
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1276
static int output_packet(AVInputStream *ist, int ist_index,
1277
                         AVOutputStream **ost_table, int nb_ostreams,
1278
                         const AVPacket *pkt)
1279
{
1280
    AVFormatContext *os;
1281
    AVOutputStream *ost;
1282
    int ret, i;
1283
    int got_picture;
1284
    AVFrame picture;
1285
    void *buffer_to_free;
1286
    static unsigned int samples_size= 0;
1287
    AVSubtitle subtitle, *subtitle_to_free;
1288
    int got_subtitle;
1289
    AVPacket avpkt;
1290
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1291

    
1292
    if(ist->next_pts == AV_NOPTS_VALUE)
1293
        ist->next_pts= ist->pts;
1294

    
1295
    if (pkt == NULL) {
1296
        /* EOF handling */
1297
        av_init_packet(&avpkt);
1298
        avpkt.data = NULL;
1299
        avpkt.size = 0;
1300
        goto handle_eof;
1301
    } else {
1302
        avpkt = *pkt;
1303
    }
1304

    
1305
    if(pkt->dts != AV_NOPTS_VALUE)
1306
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1307

    
1308
    //while we have more to decode or while the decoder did output something on EOF
1309
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1310
        uint8_t *data_buf, *decoded_data_buf;
1311
        int data_size, decoded_data_size;
1312
    handle_eof:
1313
        ist->pts= ist->next_pts;
1314

    
1315
        if(avpkt.size && avpkt.size != pkt->size &&
1316
           (!ist->showed_multi_packet_warning && verbose>0 || verbose>1)){
1317
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1318
            ist->showed_multi_packet_warning=1;
1319
        }
1320

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

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

    
1410
        buffer_to_free = NULL;
1411
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1412
            pre_process_video_frame(ist, (AVPicture *)&picture,
1413
                                    &buffer_to_free);
1414
        }
1415

    
1416
        // preprocess audio (volume)
1417
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1418
            if (audio_volume != 256) {
1419
                short *volp;
1420
                volp = samples;
1421
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1422
                    int v = ((*volp) * audio_volume + 128) >> 8;
1423
                    if (v < -32768) v = -32768;
1424
                    if (v >  32767) v = 32767;
1425
                    *volp++ = v;
1426
                }
1427
            }
1428
        }
1429

    
1430
        /* frame rate emulation */
1431
        if (rate_emu) {
1432
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1433
            int64_t now = av_gettime() - ist->start;
1434
            if (pts > now)
1435
                usleep(pts - now);
1436
        }
1437

    
1438
        /* if output time reached then transcode raw format,
1439
           encode packets and output them */
1440
        if (start_time == 0 || ist->pts >= start_time)
1441
            for(i=0;i<nb_ostreams;i++) {
1442
                int frame_size;
1443

    
1444
                ost = ost_table[i];
1445
                if (ost->source_index == ist_index) {
1446
                    os = output_files[ost->file_index];
1447

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

    
1451
                    if (ost->encoding_needed) {
1452
                        assert(ist->decoding_needed);
1453
                        switch(ost->st->codec->codec_type) {
1454
                        case CODEC_TYPE_AUDIO:
1455
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1456
                            break;
1457
                        case CODEC_TYPE_VIDEO:
1458
                            do_video_out(os, ost, ist, &picture, &frame_size);
1459
                            if (vstats_filename && frame_size)
1460
                                do_video_stats(os, ost, frame_size);
1461
                            break;
1462
                        case CODEC_TYPE_SUBTITLE:
1463
                            do_subtitle_out(os, ost, ist, &subtitle,
1464
                                            pkt->pts);
1465
                            break;
1466
                        default:
1467
                            abort();
1468
                        }
1469
                    } else {
1470
                        AVFrame avframe; //FIXME/XXX remove this
1471
                        AVPacket opkt;
1472
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1473

    
1474
                        av_init_packet(&opkt);
1475

    
1476
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1477
                            continue;
1478

    
1479
                        /* no reencoding needed : output the packet directly */
1480
                        /* force the input stream PTS */
1481

    
1482
                        avcodec_get_frame_defaults(&avframe);
1483
                        ost->st->codec->coded_frame= &avframe;
1484
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1485

    
1486
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1487
                            audio_size += data_size;
1488
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1489
                            video_size += data_size;
1490
                            ost->sync_opts++;
1491
                        }
1492

    
1493
                        opkt.stream_index= ost->index;
1494
                        if(pkt->pts != AV_NOPTS_VALUE)
1495
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1496
                        else
1497
                            opkt.pts= AV_NOPTS_VALUE;
1498

    
1499
                        if (pkt->dts == AV_NOPTS_VALUE)
1500
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1501
                        else
1502
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1503
                        opkt.dts -= ost_tb_start_time;
1504

    
1505
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1506
                        opkt.flags= pkt->flags;
1507

    
1508
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1509
                        if(ost->st->codec->codec_id != CODEC_ID_H264) {
1510
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1511
                                opkt.destruct= av_destruct_packet;
1512
                        } else {
1513
                            opkt.data = data_buf;
1514
                            opkt.size = data_size;
1515
                        }
1516

    
1517
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1518
                        ost->st->codec->frame_number++;
1519
                        ost->frame_number++;
1520
                        av_free_packet(&opkt);
1521
                    }
1522
                }
1523
            }
1524
        av_free(buffer_to_free);
1525
        /* XXX: allocate the subtitles in the codec ? */
1526
        if (subtitle_to_free) {
1527
            if (subtitle_to_free->rects != NULL) {
1528
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1529
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1530
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1531
                    av_freep(&subtitle_to_free->rects[i]);
1532
                }
1533
                av_freep(&subtitle_to_free->rects);
1534
            }
1535
            subtitle_to_free->num_rects = 0;
1536
            subtitle_to_free = NULL;
1537
        }
1538
    }
1539
 discard_packet:
1540
    if (pkt == NULL) {
1541
        /* EOF handling */
1542

    
1543
        for(i=0;i<nb_ostreams;i++) {
1544
            ost = ost_table[i];
1545
            if (ost->source_index == ist_index) {
1546
                AVCodecContext *enc= ost->st->codec;
1547
                os = output_files[ost->file_index];
1548

    
1549
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1550
                    continue;
1551
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1552
                    continue;
1553

    
1554
                if (ost->encoding_needed) {
1555
                    for(;;) {
1556
                        AVPacket pkt;
1557
                        int fifo_bytes;
1558
                        av_init_packet(&pkt);
1559
                        pkt.stream_index= ost->index;
1560

    
1561
                        switch(ost->st->codec->codec_type) {
1562
                        case CODEC_TYPE_AUDIO:
1563
                            fifo_bytes = av_fifo_size(ost->fifo);
1564
                            ret = 0;
1565
                            /* encode any samples remaining in fifo */
1566
                            if (fifo_bytes > 0) {
1567
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1568
                                int fs_tmp = enc->frame_size;
1569

    
1570
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1571
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1572
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1573
                                } else { /* pad */
1574
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1575
                                    if (samples_size < frame_bytes)
1576
                                        av_exit(1);
1577
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1578
                                }
1579

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

    
1612
                        if(ret<=0)
1613
                            break;
1614
                        pkt.data= bit_buffer;
1615
                        pkt.size= ret;
1616
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1617
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1618
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1619
                    }
1620
                }
1621
            }
1622
        }
1623
    }
1624

    
1625
    return 0;
1626
 fail_decode:
1627
    return -1;
1628
}
1629

    
1630
static void print_sdp(AVFormatContext **avc, int n)
1631
{
1632
    char sdp[2048];
1633

    
1634
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1635
    printf("SDP:\n%s\n", sdp);
1636
    fflush(stdout);
1637
}
1638

    
1639
static int stream_index_from_inputs(AVFormatContext **input_files,
1640
                                    int nb_input_files,
1641
                                    AVInputFile *file_table,
1642
                                    AVInputStream **ist_table,
1643
                                    enum CodecType type,
1644
                                    int programid)
1645
{
1646
    int p, q, z;
1647
    for(z=0; z<nb_input_files; z++) {
1648
        AVFormatContext *ic = input_files[z];
1649
        for(p=0; p<ic->nb_programs; p++) {
1650
            AVProgram *program = ic->programs[p];
1651
            if(program->id != programid)
1652
                continue;
1653
            for(q=0; q<program->nb_stream_indexes; q++) {
1654
                int sidx = program->stream_index[q];
1655
                int ris = file_table[z].ist_index + sidx;
1656
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1657
                    return ris;
1658
            }
1659
        }
1660
    }
1661

    
1662
    return -1;
1663
}
1664

    
1665
/*
1666
 * The following code is the main loop of the file converter
1667
 */
1668
static int av_encode(AVFormatContext **output_files,
1669
                     int nb_output_files,
1670
                     AVFormatContext **input_files,
1671
                     int nb_input_files,
1672
                     AVStreamMap *stream_maps, int nb_stream_maps)
1673
{
1674
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1675
    AVFormatContext *is, *os;
1676
    AVCodecContext *codec, *icodec;
1677
    AVOutputStream *ost, **ost_table = NULL;
1678
    AVInputStream *ist, **ist_table = NULL;
1679
    AVInputFile *file_table;
1680
    char error[1024];
1681
    int key;
1682
    int want_sdp = 1;
1683
    uint8_t no_packet[MAX_FILES]={0};
1684
    int no_packet_count=0;
1685

    
1686
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1687
    if (!file_table)
1688
        goto fail;
1689

    
1690
    /* input stream init */
1691
    j = 0;
1692
    for(i=0;i<nb_input_files;i++) {
1693
        is = input_files[i];
1694
        file_table[i].ist_index = j;
1695
        file_table[i].nb_streams = is->nb_streams;
1696
        j += is->nb_streams;
1697
    }
1698
    nb_istreams = j;
1699

    
1700
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1701
    if (!ist_table)
1702
        goto fail;
1703

    
1704
    for(i=0;i<nb_istreams;i++) {
1705
        ist = av_mallocz(sizeof(AVInputStream));
1706
        if (!ist)
1707
            goto fail;
1708
        ist_table[i] = ist;
1709
    }
1710
    j = 0;
1711
    for(i=0;i<nb_input_files;i++) {
1712
        is = input_files[i];
1713
        for(k=0;k<is->nb_streams;k++) {
1714
            ist = ist_table[j++];
1715
            ist->st = is->streams[k];
1716
            ist->file_index = i;
1717
            ist->index = k;
1718
            ist->discard = 1; /* the stream is discarded by default
1719
                                 (changed later) */
1720

    
1721
            if (rate_emu) {
1722
                ist->start = av_gettime();
1723
            }
1724
        }
1725
    }
1726

    
1727
    /* output stream init */
1728
    nb_ostreams = 0;
1729
    for(i=0;i<nb_output_files;i++) {
1730
        os = output_files[i];
1731
        if (!os->nb_streams) {
1732
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1733
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1734
            av_exit(1);
1735
        }
1736
        nb_ostreams += os->nb_streams;
1737
    }
1738
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1739
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1740
        av_exit(1);
1741
    }
1742

    
1743
    /* Sanity check the mapping args -- do the input files & streams exist? */
1744
    for(i=0;i<nb_stream_maps;i++) {
1745
        int fi = stream_maps[i].file_index;
1746
        int si = stream_maps[i].stream_index;
1747

    
1748
        if (fi < 0 || fi > nb_input_files - 1 ||
1749
            si < 0 || si > file_table[fi].nb_streams - 1) {
1750
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1751
            av_exit(1);
1752
        }
1753
        fi = stream_maps[i].sync_file_index;
1754
        si = stream_maps[i].sync_stream_index;
1755
        if (fi < 0 || fi > nb_input_files - 1 ||
1756
            si < 0 || si > file_table[fi].nb_streams - 1) {
1757
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1758
            av_exit(1);
1759
        }
1760
    }
1761

    
1762
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1763
    if (!ost_table)
1764
        goto fail;
1765
    for(i=0;i<nb_ostreams;i++) {
1766
        ost = av_mallocz(sizeof(AVOutputStream));
1767
        if (!ost)
1768
            goto fail;
1769
        ost_table[i] = ost;
1770
    }
1771

    
1772
    n = 0;
1773
    for(k=0;k<nb_output_files;k++) {
1774
        os = output_files[k];
1775
        for(i=0;i<os->nb_streams;i++,n++) {
1776
            int found;
1777
            ost = ost_table[n];
1778
            ost->file_index = k;
1779
            ost->index = i;
1780
            ost->st = os->streams[i];
1781
            if (nb_stream_maps > 0) {
1782
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1783
                    stream_maps[n].stream_index;
1784

    
1785
                /* Sanity check that the stream types match */
1786
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1787
                    int i= ost->file_index;
1788
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1789
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1790
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1791
                        ost->file_index, ost->index);
1792
                    av_exit(1);
1793
                }
1794

    
1795
            } else {
1796
                if(opt_programid) {
1797
                    found = 0;
1798
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1799
                    if(j != -1) {
1800
                        ost->source_index = j;
1801
                        found = 1;
1802
                    }
1803
                } else {
1804
                    /* get corresponding input stream index : we select the first one with the right type */
1805
                    found = 0;
1806
                    for(j=0;j<nb_istreams;j++) {
1807
                        ist = ist_table[j];
1808
                        if (ist->discard &&
1809
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1810
                            ost->source_index = j;
1811
                            found = 1;
1812
                            break;
1813
                        }
1814
                    }
1815
                }
1816

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

    
1845
    /* for each output stream, we compute the right encoding parameters */
1846
    for(i=0;i<nb_ostreams;i++) {
1847
        AVMetadataTag *lang;
1848
        ost = ost_table[i];
1849
        os = output_files[ost->file_index];
1850
        ist = ist_table[ost->source_index];
1851

    
1852
        codec = ost->st->codec;
1853
        icodec = ist->st->codec;
1854

    
1855
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1856
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1857
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1858

    
1859
        ost->st->disposition = ist->st->disposition;
1860
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1861
        codec->chroma_sample_location = icodec->chroma_sample_location;
1862

    
1863
        if (ost->st->stream_copy) {
1864
            /* if stream_copy is selected, no need to decode or encode */
1865
            codec->codec_id = icodec->codec_id;
1866
            codec->codec_type = icodec->codec_type;
1867

    
1868
            if(!codec->codec_tag){
1869
                if(   !os->oformat->codec_tag
1870
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1871
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1872
                    codec->codec_tag = icodec->codec_tag;
1873
            }
1874

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

    
1977
                    ost->original_height = icodec->height;
1978
                    ost->original_width  = icodec->width;
1979

    
1980
                    codec->bits_per_raw_sample= 0;
1981
                }
1982
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
1983
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
1984
                ost->resample_pix_fmt= icodec->pix_fmt;
1985
                ost->encoding_needed = 1;
1986
                ist->decoding_needed = 1;
1987
                break;
1988
            case CODEC_TYPE_SUBTITLE:
1989
                ost->encoding_needed = 1;
1990
                ist->decoding_needed = 1;
1991
                break;
1992
            default:
1993
                abort();
1994
                break;
1995
            }
1996
            /* two pass mode */
1997
            if (ost->encoding_needed &&
1998
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1999
                char logfilename[1024];
2000
                FILE *f;
2001
                int size;
2002
                char *logbuffer;
2003

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

    
2042
    if (!bit_buffer)
2043
        bit_buffer = av_malloc(bit_buffer_size);
2044
    if (!bit_buffer) {
2045
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2046
                bit_buffer_size);
2047
        ret = AVERROR(ENOMEM);
2048
        goto fail;
2049
    }
2050

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

    
2074
    /* open each decoder */
2075
    for(i=0;i<nb_istreams;i++) {
2076
        ist = ist_table[i];
2077
        if (ist->decoding_needed) {
2078
            AVCodec *codec = input_codecs[i];
2079
            if (!codec)
2080
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2081
            if (!codec) {
2082
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2083
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2084
                ret = AVERROR(EINVAL);
2085
                goto dump_format;
2086
            }
2087
            if (avcodec_open(ist->st->codec, codec) < 0) {
2088
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2089
                        ist->file_index, ist->index);
2090
                ret = AVERROR(EINVAL);
2091
                goto dump_format;
2092
            }
2093
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2094
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2095
        }
2096
    }
2097

    
2098
    /* init pts */
2099
    for(i=0;i<nb_istreams;i++) {
2100
        ist = ist_table[i];
2101
        ist->pts = 0;
2102
        ist->next_pts = AV_NOPTS_VALUE;
2103
        ist->is_start = 1;
2104
    }
2105

    
2106
    /* set meta data information from input file if required */
2107
    for (i=0;i<nb_meta_data_maps;i++) {
2108
        AVFormatContext *out_file;
2109
        AVFormatContext *in_file;
2110
        AVMetadataTag *mtag;
2111

    
2112
        int out_file_index = meta_data_maps[i].out_file;
2113
        int in_file_index = meta_data_maps[i].in_file;
2114
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2115
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2116
                     out_file_index, out_file_index, in_file_index);
2117
            ret = AVERROR(EINVAL);
2118
            goto dump_format;
2119
        }
2120
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2121
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2122
                     in_file_index, out_file_index, in_file_index);
2123
            ret = AVERROR(EINVAL);
2124
            goto dump_format;
2125
        }
2126

    
2127
        out_file = output_files[out_file_index];
2128
        in_file = input_files[in_file_index];
2129

    
2130

    
2131
        mtag=NULL;
2132
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2133
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2134
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2135
                                    in_file->iformat->metadata_conv);
2136
    }
2137

    
2138
    /* open files and write file headers */
2139
    for(i=0;i<nb_output_files;i++) {
2140
        os = output_files[i];
2141
        if (av_write_header(os) < 0) {
2142
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2143
            ret = AVERROR(EINVAL);
2144
            goto dump_format;
2145
        }
2146
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2147
            want_sdp = 0;
2148
        }
2149
    }
2150

    
2151
 dump_format:
2152
    /* dump the file output parameters - cannot be done before in case
2153
       of stream copy */
2154
    for(i=0;i<nb_output_files;i++) {
2155
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2156
    }
2157

    
2158
    /* dump the stream mapping */
2159
    if (verbose >= 0) {
2160
        fprintf(stderr, "Stream mapping:\n");
2161
        for(i=0;i<nb_ostreams;i++) {
2162
            ost = ost_table[i];
2163
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2164
                    ist_table[ost->source_index]->file_index,
2165
                    ist_table[ost->source_index]->index,
2166
                    ost->file_index,
2167
                    ost->index);
2168
            if (ost->sync_ist != ist_table[ost->source_index])
2169
                fprintf(stderr, " [sync #%d.%d]",
2170
                        ost->sync_ist->file_index,
2171
                        ost->sync_ist->index);
2172
            fprintf(stderr, "\n");
2173
        }
2174
    }
2175

    
2176
    if (ret) {
2177
        fprintf(stderr, "%s\n", error);
2178
        goto fail;
2179
    }
2180

    
2181
    if (want_sdp) {
2182
        print_sdp(output_files, nb_output_files);
2183
    }
2184

    
2185
    if (!using_stdin && verbose >= 0) {
2186
        fprintf(stderr, "Press [q] to stop encoding\n");
2187
        url_set_interrupt_cb(decode_interrupt_cb);
2188
    }
2189
    term_init();
2190

    
2191
    timer_start = av_gettime();
2192

    
2193
    for(; received_sigterm == 0;) {
2194
        int file_index, ist_index;
2195
        AVPacket pkt;
2196
        double ipts_min;
2197
        double opts_min;
2198

    
2199
    redo:
2200
        ipts_min= 1e100;
2201
        opts_min= 1e100;
2202
        /* if 'q' pressed, exits */
2203
        if (!using_stdin) {
2204
            if (q_pressed)
2205
                break;
2206
            /* read_key() returns 0 on EOF */
2207
            key = read_key();
2208
            if (key == 'q')
2209
                break;
2210
        }
2211

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

    
2253
        /* finish if recording time exhausted */
2254
        if (opts_min >= (recording_time / 1000000.0))
2255
            break;
2256

    
2257
        /* finish if limit size exhausted */
2258
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2259
            break;
2260

    
2261
        /* read a frame from it and output it in the fifo */
2262
        is = input_files[file_index];
2263
        ret= av_read_frame(is, &pkt);
2264
        if(ret == AVERROR(EAGAIN)){
2265
            no_packet[file_index]=1;
2266
            no_packet_count++;
2267
            continue;
2268
        }
2269
        if (ret < 0) {
2270
            file_table[file_index].eof_reached = 1;
2271
            if (opt_shortest)
2272
                break;
2273
            else
2274
                continue;
2275
        }
2276

    
2277
        no_packet_count=0;
2278
        memset(no_packet, 0, sizeof(no_packet));
2279

    
2280
        if (do_pkt_dump) {
2281
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2282
        }
2283
        /* the following test is needed in case new streams appear
2284
           dynamically in stream : we ignore them */
2285
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2286
            goto discard_packet;
2287
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2288
        ist = ist_table[ist_index];
2289
        if (ist->discard)
2290
            goto discard_packet;
2291

    
2292
        if (pkt.dts != AV_NOPTS_VALUE)
2293
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2294
        if (pkt.pts != AV_NOPTS_VALUE)
2295
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2296

    
2297
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2298
            if(pkt.pts != AV_NOPTS_VALUE)
2299
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2300
            if(pkt.dts != AV_NOPTS_VALUE)
2301
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2302
        }
2303

    
2304
//        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);
2305
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2306
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2307
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2308
            int64_t delta= pkt_dts - ist->next_pts;
2309
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2310
                input_files_ts_offset[ist->file_index]-= delta;
2311
                if (verbose > 2)
2312
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2313
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2314
                if(pkt.pts != AV_NOPTS_VALUE)
2315
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2316
            }
2317
        }
2318

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

    
2322
            if (verbose >= 0)
2323
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2324
                        ist->file_index, ist->index);
2325
            if (exit_on_error)
2326
                av_exit(1);
2327
            av_free_packet(&pkt);
2328
            goto redo;
2329
        }
2330

    
2331
    discard_packet:
2332
        av_free_packet(&pkt);
2333

    
2334
        /* dump report by using the output first video and audio streams */
2335
        print_report(output_files, ost_table, nb_ostreams, 0);
2336
    }
2337

    
2338
    /* at the end of stream, we must flush the decoder buffers */
2339
    for(i=0;i<nb_istreams;i++) {
2340
        ist = ist_table[i];
2341
        if (ist->decoding_needed) {
2342
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2343
        }
2344
    }
2345

    
2346
    term_exit();
2347

    
2348
    /* write the trailer if needed and close file */
2349
    for(i=0;i<nb_output_files;i++) {
2350
        os = output_files[i];
2351
        av_write_trailer(os);
2352
    }
2353

    
2354
    /* dump report by using the first video and audio streams */
2355
    print_report(output_files, ost_table, nb_ostreams, 1);
2356

    
2357
    /* close each encoder */
2358
    for(i=0;i<nb_ostreams;i++) {
2359
        ost = ost_table[i];
2360
        if (ost->encoding_needed) {
2361
            av_freep(&ost->st->codec->stats_in);
2362
            avcodec_close(ost->st->codec);
2363
        }
2364
    }
2365

    
2366
    /* close each decoder */
2367
    for(i=0;i<nb_istreams;i++) {
2368
        ist = ist_table[i];
2369
        if (ist->decoding_needed) {
2370
            avcodec_close(ist->st->codec);
2371
        }
2372
    }
2373

    
2374
    /* finished ! */
2375
    ret = 0;
2376

    
2377
 fail:
2378
    av_freep(&bit_buffer);
2379
    av_free(file_table);
2380

    
2381
    if (ist_table) {
2382
        for(i=0;i<nb_istreams;i++) {
2383
            ist = ist_table[i];
2384
            av_free(ist);
2385
        }
2386
        av_free(ist_table);
2387
    }
2388
    if (ost_table) {
2389
        for(i=0;i<nb_ostreams;i++) {
2390
            ost = ost_table[i];
2391
            if (ost) {
2392
                if (ost->logfile) {
2393
                    fclose(ost->logfile);
2394
                    ost->logfile = NULL;
2395
                }
2396
                av_fifo_free(ost->fifo); /* works even if fifo is not
2397
                                             initialized but set to zero */
2398
                av_free(ost->pict_tmp.data[0]);
2399
                if (ost->video_resample)
2400
                    sws_freeContext(ost->img_resample_ctx);
2401
                if (ost->resample)
2402
                    audio_resample_close(ost->resample);
2403
                if (ost->reformat_ctx)
2404
                    av_audio_convert_free(ost->reformat_ctx);
2405
                av_free(ost);
2406
            }
2407
        }
2408
        av_free(ost_table);
2409
    }
2410
    return ret;
2411
}
2412

    
2413
static void opt_format(const char *arg)
2414
{
2415
    /* compatibility stuff for pgmyuv */
2416
    if (!strcmp(arg, "pgmyuv")) {
2417
        pgmyuv_compatibility_hack=1;
2418
//        opt_image_format(arg);
2419
        arg = "image2";
2420
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2421
    }
2422

    
2423
    last_asked_format = arg;
2424
}
2425

    
2426
static void opt_video_rc_override_string(const char *arg)
2427
{
2428
    video_rc_override_string = arg;
2429
}
2430

    
2431
static int opt_me_threshold(const char *opt, const char *arg)
2432
{
2433
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2434
    return 0;
2435
}
2436

    
2437
static int opt_verbose(const char *opt, const char *arg)
2438
{
2439
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2440
    return 0;
2441
}
2442

    
2443
static int opt_frame_rate(const char *opt, const char *arg)
2444
{
2445
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2446
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2447
        av_exit(1);
2448
    }
2449
    return 0;
2450
}
2451

    
2452
static int opt_bitrate(const char *opt, const char *arg)
2453
{
2454
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2455

    
2456
    opt_default(opt, arg);
2457

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

    
2461
    return 0;
2462
}
2463

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

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

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

    
2506
static void opt_frame_crop_right(const char *arg)
2507
{
2508
    frame_rightBand = atoi(arg);
2509
    if (frame_rightBand < 0) {
2510
        fprintf(stderr, "Incorrect right crop size\n");
2511
        av_exit(1);
2512
    }
2513
    if ((frame_rightBand) >= frame_width){
2514
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2515
        av_exit(1);
2516
    }
2517
    frame_width -= frame_rightBand;
2518
}
2519

    
2520
static void opt_frame_size(const char *arg)
2521
{
2522
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2523
        fprintf(stderr, "Incorrect frame size\n");
2524
        av_exit(1);
2525
    }
2526
}
2527

    
2528
static void opt_pad_color(const char *arg) {
2529
    /* Input is expected to be six hex digits similar to
2530
       how colors are expressed in html tags (but without the #) */
2531
    int rgb = strtol(arg, NULL, 16);
2532
    int r,g,b;
2533

    
2534
    r = (rgb >> 16);
2535
    g = ((rgb >> 8) & 255);
2536
    b = (rgb & 255);
2537

    
2538
    padcolor[0] = RGB_TO_Y(r,g,b);
2539
    padcolor[1] = RGB_TO_U(r,g,b,0);
2540
    padcolor[2] = RGB_TO_V(r,g,b,0);
2541
}
2542

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

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

    
2561

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

    
2571

    
2572
static void opt_frame_pad_right(const char *arg)
2573
{
2574
    frame_padright = atoi(arg);
2575
    if (frame_padright < 0) {
2576
        fprintf(stderr, "Incorrect right pad size\n");
2577
        av_exit(1);
2578
    }
2579
}
2580

    
2581
static void opt_frame_pix_fmt(const char *arg)
2582
{
2583
    if (strcmp(arg, "list")) {
2584
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2585
        if (frame_pix_fmt == PIX_FMT_NONE) {
2586
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2587
            av_exit(1);
2588
        }
2589
    } else {
2590
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2591
        av_exit(0);
2592
    }
2593
}
2594

    
2595
static void opt_frame_aspect_ratio(const char *arg)
2596
{
2597
    int x = 0, y = 0;
2598
    double ar = 0;
2599
    const char *p;
2600
    char *end;
2601

    
2602
    p = strchr(arg, ':');
2603
    if (p) {
2604
        x = strtol(arg, &end, 10);
2605
        if (end == p)
2606
            y = strtol(end+1, &end, 10);
2607
        if (x > 0 && y > 0)
2608
            ar = (double)x / (double)y;
2609
    } else
2610
        ar = strtod(arg, NULL);
2611

    
2612
    if (!ar) {
2613
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2614
        av_exit(1);
2615
    }
2616
    frame_aspect_ratio = ar;
2617
}
2618

    
2619
static int opt_metadata(const char *opt, const char *arg)
2620
{
2621
    char *mid= strchr(arg, '=');
2622

    
2623
    if(!mid){
2624
        fprintf(stderr, "Missing =\n");
2625
        av_exit(1);
2626
    }
2627
    *mid++= 0;
2628

    
2629
    metadata_count++;
2630
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2631
    metadata[metadata_count-1].key  = av_strdup(arg);
2632
    metadata[metadata_count-1].value= av_strdup(mid);
2633

    
2634
    return 0;
2635
}
2636

    
2637
static void opt_qscale(const char *arg)
2638
{
2639
    video_qscale = atof(arg);
2640
    if (video_qscale <= 0 ||
2641
        video_qscale > 255) {
2642
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2643
        av_exit(1);
2644
    }
2645
}
2646

    
2647
static void opt_top_field_first(const char *arg)
2648
{
2649
    top_field_first= atoi(arg);
2650
}
2651

    
2652
static int opt_thread_count(const char *opt, const char *arg)
2653
{
2654
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2655
#if !HAVE_THREADS
2656
    if (verbose >= 0)
2657
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2658
#endif
2659
    return 0;
2660
}
2661

    
2662
static void opt_audio_sample_fmt(const char *arg)
2663
{
2664
    if (strcmp(arg, "list"))
2665
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2666
    else {
2667
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2668
        av_exit(0);
2669
    }
2670
}
2671

    
2672
static int opt_audio_rate(const char *opt, const char *arg)
2673
{
2674
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2675
    return 0;
2676
}
2677

    
2678
static int opt_audio_channels(const char *opt, const char *arg)
2679
{
2680
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2681
    return 0;
2682
}
2683

    
2684
static void opt_video_channel(const char *arg)
2685
{
2686
    video_channel = strtol(arg, NULL, 0);
2687
}
2688

    
2689
static void opt_video_standard(const char *arg)
2690
{
2691
    video_standard = av_strdup(arg);
2692
}
2693

    
2694
static void opt_codec(int *pstream_copy, char **pcodec_name,
2695
                      int codec_type, const char *arg)
2696
{
2697
    av_freep(pcodec_name);
2698
    if (!strcmp(arg, "copy")) {
2699
        *pstream_copy = 1;
2700
    } else {
2701
        *pcodec_name = av_strdup(arg);
2702
    }
2703
}
2704

    
2705
static void opt_audio_codec(const char *arg)
2706
{
2707
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2708
}
2709

    
2710
static void opt_audio_tag(const char *arg)
2711
{
2712
    char *tail;
2713
    audio_codec_tag= strtol(arg, &tail, 0);
2714

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

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

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

    
2728
static void opt_video_codec(const char *arg)
2729
{
2730
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2731
}
2732

    
2733
static void opt_subtitle_codec(const char *arg)
2734
{
2735
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2736
}
2737

    
2738
static void opt_subtitle_tag(const char *arg)
2739
{
2740
    char *tail;
2741
    subtitle_codec_tag= strtol(arg, &tail, 0);
2742

    
2743
    if(!tail || *tail)
2744
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2745
}
2746

    
2747
static void opt_map(const char *arg)
2748
{
2749
    AVStreamMap *m;
2750
    char *p;
2751

    
2752
    m = &stream_maps[nb_stream_maps++];
2753

    
2754
    m->file_index = strtol(arg, &p, 0);
2755
    if (*p)
2756
        p++;
2757

    
2758
    m->stream_index = strtol(p, &p, 0);
2759
    if (*p) {
2760
        p++;
2761
        m->sync_file_index = strtol(p, &p, 0);
2762
        if (*p)
2763
            p++;
2764
        m->sync_stream_index = strtol(p, &p, 0);
2765
    } else {
2766
        m->sync_file_index = m->file_index;
2767
        m->sync_stream_index = m->stream_index;
2768
    }
2769
}
2770

    
2771
static void opt_map_meta_data(const char *arg)
2772
{
2773
    AVMetaDataMap *m;
2774
    char *p;
2775

    
2776
    m = &meta_data_maps[nb_meta_data_maps++];
2777

    
2778
    m->out_file = strtol(arg, &p, 0);
2779
    if (*p)
2780
        p++;
2781

    
2782
    m->in_file = strtol(p, &p, 0);
2783
}
2784

    
2785
static void opt_input_ts_scale(const char *arg)
2786
{
2787
    unsigned int stream;
2788
    double scale;
2789
    char *p;
2790

    
2791
    stream = strtol(arg, &p, 0);
2792
    if (*p)
2793
        p++;
2794
    scale= strtod(p, &p);
2795

    
2796
    if(stream >= MAX_STREAMS)
2797
        av_exit(1);
2798

    
2799
    input_files_ts_scale[nb_input_files][stream]= scale;
2800
}
2801

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

    
2808
static int opt_start_time(const char *opt, const char *arg)
2809
{
2810
    start_time = parse_time_or_die(opt, arg, 1);
2811
    return 0;
2812
}
2813

    
2814
static int opt_rec_timestamp(const char *opt, const char *arg)
2815
{
2816
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2817
    return 0;
2818
}
2819

    
2820
static int opt_input_ts_offset(const char *opt, const char *arg)
2821
{
2822
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2823
    return 0;
2824
}
2825

    
2826
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2827
{
2828
    const char *codec_string = encoder ? "encoder" : "decoder";
2829
    AVCodec *codec;
2830

    
2831
    if(!name)
2832
        return CODEC_ID_NONE;
2833
    codec = encoder ?
2834
        avcodec_find_encoder_by_name(name) :
2835
        avcodec_find_decoder_by_name(name);
2836
    if(!codec) {
2837
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2838
        av_exit(1);
2839
    }
2840
    if(codec->type != type) {
2841
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2842
        av_exit(1);
2843
    }
2844
    return codec->id;
2845
}
2846

    
2847
static void opt_input_file(const char *filename)
2848
{
2849
    AVFormatContext *ic;
2850
    AVFormatParameters params, *ap = &params;
2851
    AVInputFormat *file_iformat = NULL;
2852
    int err, i, ret, rfps, rfps_base;
2853
    int64_t timestamp;
2854

    
2855
    if (last_asked_format) {
2856
        file_iformat = av_find_input_format(last_asked_format);
2857
        last_asked_format = NULL;
2858
    }
2859

    
2860
    if (!strcmp(filename, "-"))
2861
        filename = "pipe:";
2862

    
2863
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2864
                    !strcmp(filename, "/dev/stdin");
2865

    
2866
    /* get default parameters from command line */
2867
    ic = avformat_alloc_context();
2868
    if (!ic) {
2869
        print_error(filename, AVERROR(ENOMEM));
2870
        av_exit(1);
2871
    }
2872

    
2873
    memset(ap, 0, sizeof(*ap));
2874
    ap->prealloced_context = 1;
2875
    ap->sample_rate = audio_sample_rate;
2876
    ap->channels = audio_channels;
2877
    ap->time_base.den = frame_rate.num;
2878
    ap->time_base.num = frame_rate.den;
2879
    ap->width = frame_width + frame_padleft + frame_padright;
2880
    ap->height = frame_height + frame_padtop + frame_padbottom;
2881
    ap->pix_fmt = frame_pix_fmt;
2882
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2883
    ap->channel = video_channel;
2884
    ap->standard = video_standard;
2885
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2886
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2887
    if(pgmyuv_compatibility_hack)
2888
        ap->video_codec_id= CODEC_ID_PGMYUV;
2889

    
2890
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2891

    
2892
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2893
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2894
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2895
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2896

    
2897
    /* open the input file with generic libav function */
2898
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2899
    if (err < 0) {
2900
        print_error(filename, err);
2901
        av_exit(1);
2902
    }
2903
    if(opt_programid) {
2904
        int i;
2905
        for(i=0; i<ic->nb_programs; i++)
2906
            if(ic->programs[i]->id != opt_programid)
2907
                ic->programs[i]->discard = AVDISCARD_ALL;
2908
    }
2909

    
2910
    ic->loop_input = loop_input;
2911

    
2912
    /* If not enough info to get the stream parameters, we decode the
2913
       first frames to get it. (used in mpeg case for example) */
2914
    ret = av_find_stream_info(ic);
2915
    if (ret < 0 && verbose >= 0) {
2916
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2917
        av_exit(1);
2918
    }
2919

    
2920
    timestamp = start_time;
2921
    /* add the stream start time */
2922
    if (ic->start_time != AV_NOPTS_VALUE)
2923
        timestamp += ic->start_time;
2924

    
2925
    /* if seeking requested, we execute it */
2926
    if (start_time != 0) {
2927
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2928
        if (ret < 0) {
2929
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2930
                    filename, (double)timestamp / AV_TIME_BASE);
2931
        }
2932
        /* reset seek info */
2933
        start_time = 0;
2934
    }
2935

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

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

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

    
2979
                    (float)rfps / rfps_base, rfps, rfps_base);
2980
            }
2981
            /* update the current frame rate to match the stream frame rate */
2982
            frame_rate.num = rfps;
2983
            frame_rate.den = rfps_base;
2984

    
2985
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2986
            if(video_disable)
2987
                st->discard= AVDISCARD_ALL;
2988
            else if(video_discard)
2989
                st->discard= video_discard;
2990
            break;
2991
        case CODEC_TYPE_DATA:
2992
            break;
2993
        case CODEC_TYPE_SUBTITLE:
2994
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2995
            if(subtitle_disable)
2996
                st->discard = AVDISCARD_ALL;
2997
            break;
2998
        case CODEC_TYPE_ATTACHMENT:
2999
        case CODEC_TYPE_UNKNOWN:
3000
            nb_icodecs++;
3001
            break;
3002
        default:
3003
            abort();
3004
        }
3005
    }
3006

    
3007
    input_files[nb_input_files] = ic;
3008
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3009
    /* dump the file content */
3010
    if (verbose >= 0)
3011
        dump_format(ic, nb_input_files, filename, 0);
3012

    
3013
    nb_input_files++;
3014

    
3015
    video_channel = 0;
3016

    
3017
    av_freep(&video_codec_name);
3018
    av_freep(&audio_codec_name);
3019
    av_freep(&subtitle_codec_name);
3020
}
3021

    
3022
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3023
                                         int *has_subtitle_ptr)
3024
{
3025
    int has_video, has_audio, has_subtitle, i, j;
3026
    AVFormatContext *ic;
3027

    
3028
    has_video = 0;
3029
    has_audio = 0;
3030
    has_subtitle = 0;
3031
    for(j=0;j<nb_input_files;j++) {
3032
        ic = input_files[j];
3033
        for(i=0;i<ic->nb_streams;i++) {
3034
            AVCodecContext *enc = ic->streams[i]->codec;
3035
            switch(enc->codec_type) {
3036
            case CODEC_TYPE_AUDIO:
3037
                has_audio = 1;
3038
                break;
3039
            case CODEC_TYPE_VIDEO:
3040
                has_video = 1;
3041
                break;
3042
            case CODEC_TYPE_SUBTITLE:
3043
                has_subtitle = 1;
3044
                break;
3045
            case CODEC_TYPE_DATA:
3046
            case CODEC_TYPE_ATTACHMENT:
3047
            case CODEC_TYPE_UNKNOWN:
3048
                break;
3049
            default:
3050
                abort();
3051
            }
3052
        }
3053
    }
3054
    *has_video_ptr = has_video;
3055
    *has_audio_ptr = has_audio;
3056
    *has_subtitle_ptr = has_subtitle;
3057
}
3058

    
3059
static void new_video_stream(AVFormatContext *oc)
3060
{
3061
    AVStream *st;
3062
    AVCodecContext *video_enc;
3063
    enum CodecID codec_id;
3064

    
3065
    st = av_new_stream(oc, oc->nb_streams);
3066
    if (!st) {
3067
        fprintf(stderr, "Could not alloc stream\n");
3068
        av_exit(1);
3069
    }
3070
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3071
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3072
    video_bitstream_filters= NULL;
3073

    
3074
    avcodec_thread_init(st->codec, thread_count);
3075

    
3076
    video_enc = st->codec;
3077

    
3078
    if(video_codec_tag)
3079
        video_enc->codec_tag= video_codec_tag;
3080

    
3081
    if(   (video_global_header&1)
3082
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3083
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3084
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3085
    }
3086
    if(video_global_header&2){
3087
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3088
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3089
    }
3090

    
3091
    if (video_stream_copy) {
3092
        st->stream_copy = 1;
3093
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3094
        video_enc->sample_aspect_ratio =
3095
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3096
    } else {
3097
        const char *p;
3098
        int i;
3099
        AVCodec *codec;
3100
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3101

    
3102
        if (video_codec_name) {
3103
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3104
            codec = avcodec_find_encoder_by_name(video_codec_name);
3105
            output_codecs[nb_ocodecs] = codec;
3106
        } else {
3107
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3108
            codec = avcodec_find_encoder(codec_id);
3109
        }
3110

    
3111
        video_enc->codec_id = codec_id;
3112

    
3113
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3114

    
3115
        if (codec && codec->supported_framerates && !force_fps)
3116
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3117
        video_enc->time_base.den = fps.num;
3118
        video_enc->time_base.num = fps.den;
3119

    
3120
        video_enc->width = frame_width + frame_padright + frame_padleft;
3121
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3122
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3123
        video_enc->pix_fmt = frame_pix_fmt;
3124
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3125

    
3126
        if(codec && codec->pix_fmts){
3127
            const enum PixelFormat *p= codec->pix_fmts;
3128
            for(; *p!=-1; p++){
3129
                if(*p == video_enc->pix_fmt)
3130
                    break;
3131
            }
3132
            if(*p == -1)
3133
                video_enc->pix_fmt = codec->pix_fmts[0];
3134
        }
3135

    
3136
        if (intra_only)
3137
            video_enc->gop_size = 0;
3138
        if (video_qscale || same_quality) {
3139
            video_enc->flags |= CODEC_FLAG_QSCALE;
3140
            video_enc->global_quality=
3141
                st->quality = FF_QP2LAMBDA * video_qscale;
3142
        }
3143

    
3144
        if(intra_matrix)
3145
            video_enc->intra_matrix = intra_matrix;
3146
        if(inter_matrix)
3147
            video_enc->inter_matrix = inter_matrix;
3148

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

    
3179
        if (do_psnr)
3180
            video_enc->flags|= CODEC_FLAG_PSNR;
3181

    
3182
        /* two pass mode */
3183
        if (do_pass) {
3184
            if (do_pass == 1) {
3185
                video_enc->flags |= CODEC_FLAG_PASS1;
3186
            } else {
3187
                video_enc->flags |= CODEC_FLAG_PASS2;
3188
            }
3189
        }
3190
    }
3191
    nb_ocodecs++;
3192
    if (video_language) {
3193
        av_metadata_set(&st->metadata, "language", video_language);
3194
        av_freep(&video_language);
3195
    }
3196

    
3197
    /* reset some key parameters */
3198
    video_disable = 0;
3199
    av_freep(&video_codec_name);
3200
    video_stream_copy = 0;
3201
}
3202

    
3203
static void new_audio_stream(AVFormatContext *oc)
3204
{
3205
    AVStream *st;
3206
    AVCodecContext *audio_enc;
3207
    enum CodecID codec_id;
3208

    
3209
    st = av_new_stream(oc, oc->nb_streams);
3210
    if (!st) {
3211
        fprintf(stderr, "Could not alloc stream\n");
3212
        av_exit(1);
3213
    }
3214
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3215

    
3216
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3217
    audio_bitstream_filters= NULL;
3218

    
3219
    avcodec_thread_init(st->codec, thread_count);
3220

    
3221
    audio_enc = st->codec;
3222
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3223

    
3224
    if(audio_codec_tag)
3225
        audio_enc->codec_tag= audio_codec_tag;
3226

    
3227
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3228
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3229
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3230
    }
3231
    if (audio_stream_copy) {
3232
        st->stream_copy = 1;
3233
        audio_enc->channels = audio_channels;
3234
    } else {
3235
        AVCodec *codec;
3236

    
3237
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3238

    
3239
        if (audio_codec_name) {
3240
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3241
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3242
            output_codecs[nb_ocodecs] = codec;
3243
        } else {
3244
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3245
            codec = avcodec_find_encoder(codec_id);
3246
        }
3247
        audio_enc->codec_id = codec_id;
3248

    
3249
        if (audio_qscale > QSCALE_NONE) {
3250
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3251
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3252
        }
3253
        audio_enc->channels = audio_channels;
3254
        audio_enc->sample_fmt = audio_sample_fmt;
3255
        audio_enc->channel_layout = channel_layout;
3256
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3257
            audio_enc->channel_layout = 0;
3258

    
3259
        if(codec && codec->sample_fmts){
3260
            const enum SampleFormat *p= codec->sample_fmts;
3261
            for(; *p!=-1; p++){
3262
                if(*p == audio_enc->sample_fmt)
3263
                    break;
3264
            }
3265
            if(*p == -1)
3266
                audio_enc->sample_fmt = codec->sample_fmts[0];
3267
        }
3268
    }
3269
    nb_ocodecs++;
3270
    audio_enc->sample_rate = audio_sample_rate;
3271
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3272
    if (audio_language) {
3273
        av_metadata_set(&st->metadata, "language", audio_language);
3274
        av_freep(&audio_language);
3275
    }
3276

    
3277
    /* reset some key parameters */
3278
    audio_disable = 0;
3279
    av_freep(&audio_codec_name);
3280
    audio_stream_copy = 0;
3281
}
3282

    
3283
static void new_subtitle_stream(AVFormatContext *oc)
3284
{
3285
    AVStream *st;
3286
    AVCodecContext *subtitle_enc;
3287

    
3288
    st = av_new_stream(oc, oc->nb_streams);
3289
    if (!st) {
3290
        fprintf(stderr, "Could not alloc stream\n");
3291
        av_exit(1);
3292
    }
3293
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3294

    
3295
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3296
    subtitle_bitstream_filters= NULL;
3297

    
3298
    subtitle_enc = st->codec;
3299
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3300

    
3301
    if(subtitle_codec_tag)
3302
        subtitle_enc->codec_tag= subtitle_codec_tag;
3303

    
3304
    if (subtitle_stream_copy) {
3305
        st->stream_copy = 1;
3306
    } else {
3307
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3308
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3309
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3310
    }
3311
    nb_ocodecs++;
3312

    
3313
    if (subtitle_language) {
3314
        av_metadata_set(&st->metadata, "language", subtitle_language);
3315
        av_freep(&subtitle_language);
3316
    }
3317

    
3318
    subtitle_disable = 0;
3319
    av_freep(&subtitle_codec_name);
3320
    subtitle_stream_copy = 0;
3321
}
3322

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

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

    
3345
static void opt_new_subtitle_stream(void)
3346
{
3347
    AVFormatContext *oc;
3348
    if (nb_output_files <= 0) {
3349
        fprintf(stderr, "At least one output file must be specified\n");
3350
        av_exit(1);
3351
    }
3352
    oc = output_files[nb_output_files - 1];
3353
    new_subtitle_stream(oc);
3354
}
3355

    
3356
static void opt_output_file(const char *filename)
3357
{
3358
    AVFormatContext *oc;
3359
    int use_video, use_audio, use_subtitle;
3360
    int input_has_video, input_has_audio, input_has_subtitle;
3361
    AVFormatParameters params, *ap = &params;
3362
    AVOutputFormat *file_oformat;
3363

    
3364
    if (!strcmp(filename, "-"))
3365
        filename = "pipe:";
3366

    
3367
    oc = avformat_alloc_context();
3368
    if (!oc) {
3369
        print_error(filename, AVERROR(ENOMEM));
3370
        av_exit(1);
3371
    }
3372

    
3373
    if (last_asked_format) {
3374
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3375
        if (!file_oformat) {
3376
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3377
            av_exit(1);
3378
        }
3379
        last_asked_format = NULL;
3380
    } else {
3381
        file_oformat = av_guess_format(NULL, filename, NULL);
3382
        if (!file_oformat) {
3383
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3384
                    filename);
3385
            av_exit(1);
3386
        }
3387
    }
3388

    
3389
    oc->oformat = file_oformat;
3390
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3391

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

    
3406
        /* disable if no corresponding type found and at least one
3407
           input file */
3408
        if (nb_input_files > 0) {
3409
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3410
                                         &input_has_subtitle);
3411
            if (!input_has_video)
3412
                use_video = 0;
3413
            if (!input_has_audio)
3414
                use_audio = 0;
3415
            if (!input_has_subtitle)
3416
                use_subtitle = 0;
3417
        }
3418

    
3419
        /* manual disable */
3420
        if (audio_disable) {
3421
            use_audio = 0;
3422
        }
3423
        if (video_disable) {
3424
            use_video = 0;
3425
        }
3426
        if (subtitle_disable) {
3427
            use_subtitle = 0;
3428
        }
3429

    
3430
        if (use_video) {
3431
            new_video_stream(oc);
3432
        }
3433

    
3434
        if (use_audio) {
3435
            new_audio_stream(oc);
3436
        }
3437

    
3438
        if (use_subtitle) {
3439
            new_subtitle_stream(oc);
3440
        }
3441

    
3442
        oc->timestamp = rec_timestamp;
3443

    
3444
        for(; metadata_count>0; metadata_count--){
3445
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3446
                                           metadata[metadata_count-1].value);
3447
        }
3448
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3449
    }
3450

    
3451
    output_files[nb_output_files++] = oc;
3452

    
3453
    /* check filename in case of an image number is expected */
3454
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3455
        if (!av_filename_number_test(oc->filename)) {
3456
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3457
            av_exit(1);
3458
        }
3459
    }
3460

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

    
3483
        /* open the file */
3484
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3485
            fprintf(stderr, "Could not open '%s'\n", filename);
3486
            av_exit(1);
3487
        }
3488
    }
3489

    
3490
    memset(ap, 0, sizeof(*ap));
3491
    if (av_set_parameters(oc, ap) < 0) {
3492
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3493
                oc->filename);
3494
        av_exit(1);
3495
    }
3496

    
3497
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3498
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3499
    oc->loop_output = loop_output;
3500
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3501

    
3502
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3503
}
3504

    
3505
/* same option as mencoder */
3506
static void opt_pass(const char *pass_str)
3507
{
3508
    int pass;
3509
    pass = atoi(pass_str);
3510
    if (pass != 1 && pass != 2) {
3511
        fprintf(stderr, "pass number can be only 1 or 2\n");
3512
        av_exit(1);
3513
    }
3514
    do_pass = pass;
3515
}
3516

    
3517
static int64_t getutime(void)
3518
{
3519
#if HAVE_GETRUSAGE
3520
    struct rusage rusage;
3521

    
3522
    getrusage(RUSAGE_SELF, &rusage);
3523
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3524
#elif HAVE_GETPROCESSTIMES
3525
    HANDLE proc;
3526
    FILETIME c, e, k, u;
3527
    proc = GetCurrentProcess();
3528
    GetProcessTimes(proc, &c, &e, &k, &u);
3529
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3530
#else
3531
    return av_gettime();
3532
#endif
3533
}
3534

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

    
3552
static void opt_inter_matrix(const char *arg)
3553
{
3554
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3555
    parse_matrix_coeffs(inter_matrix, arg);
3556
}
3557

    
3558
static void opt_intra_matrix(const char *arg)
3559
{
3560
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3561
    parse_matrix_coeffs(intra_matrix, arg);
3562
}
3563

    
3564
/**
3565
 * Trivial log callback.
3566
 * Only suitable for show_help and similar since it lacks prefix handling.
3567
 */
3568
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3569
{
3570
    vfprintf(stdout, fmt, vl);
3571
}
3572

    
3573
static void show_usage(void)
3574
{
3575
    printf("Hyper fast Audio and Video encoder\n");
3576
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3577
    printf("\n");
3578
}
3579

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

    
3615
static void opt_target(const char *arg)
3616
{
3617
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3618
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3619

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

    
3664
    if(norm == UNKNOWN) {
3665
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3666
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3667
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3668
        av_exit(1);
3669
    }
3670

    
3671
    if(!strcmp(arg, "vcd")) {
3672

    
3673
        opt_video_codec("mpeg1video");
3674
        opt_audio_codec("mp2");
3675
        opt_format("vcd");
3676

    
3677
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3678
        opt_frame_rate(NULL, frame_rates[norm]);
3679
        opt_default("g", norm == PAL ? "15" : "18");
3680

    
3681
        opt_default("b", "1150000");
3682
        opt_default("maxrate", "1150000");
3683
        opt_default("minrate", "1150000");
3684
        opt_default("bufsize", "327680"); // 40*1024*8;
3685

    
3686
        opt_default("ab", "224000");
3687
        audio_sample_rate = 44100;
3688
        audio_channels = 2;
3689

    
3690
        opt_default("packetsize", "2324");
3691
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3692

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

    
3701
        opt_video_codec("mpeg2video");
3702
        opt_audio_codec("mp2");
3703
        opt_format("svcd");
3704

    
3705
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3706
        opt_frame_rate(NULL, frame_rates[norm]);
3707
        opt_default("g", norm == PAL ? "15" : "18");
3708

    
3709
        opt_default("b", "2040000");
3710
        opt_default("maxrate", "2516000");
3711
        opt_default("minrate", "0"); //1145000;
3712
        opt_default("bufsize", "1835008"); //224*1024*8;
3713
        opt_default("flags", "+scan_offset");
3714

    
3715

    
3716
        opt_default("ab", "224000");
3717
        audio_sample_rate = 44100;
3718

    
3719
        opt_default("packetsize", "2324");
3720

    
3721
    } else if(!strcmp(arg, "dvd")) {
3722

    
3723
        opt_video_codec("mpeg2video");
3724
        opt_audio_codec("ac3");
3725
        opt_format("dvd");
3726

    
3727
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3728
        opt_frame_rate(NULL, frame_rates[norm]);
3729
        opt_default("g", norm == PAL ? "15" : "18");
3730

    
3731
        opt_default("b", "6000000");
3732
        opt_default("maxrate", "9000000");
3733
        opt_default("minrate", "0"); //1500000;
3734
        opt_default("bufsize", "1835008"); //224*1024*8;
3735

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

    
3739
        opt_default("ab", "448000");
3740
        audio_sample_rate = 48000;
3741

    
3742
    } else if(!strncmp(arg, "dv", 2)) {
3743

    
3744
        opt_format("dv");
3745

    
3746
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3747
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3748
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3749
        opt_frame_rate(NULL, frame_rates[norm]);
3750

    
3751
        audio_sample_rate = 48000;
3752
        audio_channels = 2;
3753

    
3754
    } else {
3755
        fprintf(stderr, "Unknown target: %s\n", arg);
3756
        av_exit(1);
3757
    }
3758
}
3759

    
3760
static void opt_vstats_file (const char *arg)
3761
{
3762
    av_free (vstats_filename);
3763
    vstats_filename=av_strdup (arg);
3764
}
3765

    
3766
static void opt_vstats (void)
3767
{
3768
    char filename[40];
3769
    time_t today2 = time(NULL);
3770
    struct tm *today = localtime(&today2);
3771

    
3772
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3773
             today->tm_sec);
3774
    opt_vstats_file(filename);
3775
}
3776

    
3777
static int opt_bsf(const char *opt, const char *arg)
3778
{
3779
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3780
    AVBitStreamFilterContext **bsfp;
3781

    
3782
    if(!bsfc){
3783
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3784
        av_exit(1);
3785
    }
3786

    
3787
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3788
          *opt == 'a' ? &audio_bitstream_filters :
3789
                        &subtitle_bitstream_filters;
3790
    while(*bsfp)
3791
        bsfp= &(*bsfp)->next;
3792

    
3793
    *bsfp= bsfc;
3794

    
3795
    return 0;
3796
}
3797

    
3798
static int opt_preset(const char *opt, const char *arg)
3799
{
3800
    FILE *f=NULL;
3801
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3802
    int i;
3803
    const char *base[2]= { getenv("HOME"),
3804
                           FFMPEG_DATADIR,
3805
                         };
3806

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

    
3824
    if(!f){
3825
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3826
        av_exit(1);
3827
    }
3828

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

    
3850
    fclose(f);
3851

    
3852
    return 0;
3853
}
3854

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

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

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

    
3952
    /* subtitle options */
3953
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3954
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3955
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3956
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3957
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3958

    
3959
    /* grab options */
3960
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3961
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3962
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3963

    
3964
    /* muxer options */
3965
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3966
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3967

    
3968
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3969
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3970
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3971

    
3972
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3973
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3974
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3975
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3976

    
3977
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3978
    { NULL, },
3979
};
3980

    
3981
int main(int argc, char **argv)
3982
{
3983
    int i;
3984
    int64_t ti;
3985

    
3986
    avcodec_register_all();
3987
    avdevice_register_all();
3988
    av_register_all();
3989

    
3990
#if HAVE_ISATTY
3991
    if(isatty(STDIN_FILENO))
3992
        url_set_interrupt_cb(decode_interrupt_cb);
3993
#endif
3994

    
3995
    for(i=0; i<CODEC_TYPE_NB; i++){
3996
        avcodec_opts[i]= avcodec_alloc_context2(i);
3997
    }
3998
    avformat_opts = avformat_alloc_context();
3999
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4000

    
4001
    show_banner();
4002

    
4003
    /* parse options */
4004
    parse_options(argc, argv, options, opt_output_file);
4005

    
4006
    if(nb_output_files <= 0 && nb_input_files == 0) {
4007
        show_usage();
4008
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4009
        av_exit(1);
4010
    }
4011

    
4012
    /* file converter / grab */
4013
    if (nb_output_files <= 0) {
4014
        fprintf(stderr, "At least one output file must be specified\n");
4015
        av_exit(1);
4016
    }
4017

    
4018
    if (nb_input_files == 0) {
4019
        fprintf(stderr, "At least one input file must be specified\n");
4020
        av_exit(1);
4021
    }
4022

    
4023
    ti = getutime();
4024
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4025
                  stream_maps, nb_stream_maps) < 0)
4026
        av_exit(1);
4027
    ti = getutime() - ti;
4028
    if (do_benchmark) {
4029
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4030
    }
4031

    
4032
    return av_exit(0);
4033
}