Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ ffcc6e24

History | View | Annotate | Download (145 KB)

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

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

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

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

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

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

    
66
#include "cmdutils.h"
67

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

    
71
#undef exit
72

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

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

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

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

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

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

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

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

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

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

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

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

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

    
193
static int rate_emu = 0;
194

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

    
198
static int audio_volume = 256;
199

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

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

    
217
static unsigned int sws_flags = SWS_BICUBIC;
218

    
219
static int64_t timer_start;
220

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

    
225
static short *samples;
226

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

    
232
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
233

    
234
struct AVInputStream;
235

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

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

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

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

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

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

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

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

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

    
311
#if HAVE_TERMIOS_H
312

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

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

    
324
static volatile int received_sigterm = 0;
325

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
439
    av_free(opt_names);
440

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

    
445
    av_free(video_standard);
446

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
547
        bsfc= bsfc->next;
548
    }
549

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

    
557
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
558

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

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

    
574
    audio_buf_size= (size + isize*dec->channels - 1) / (isize*dec->channels);
575
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
576
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
577
    audio_buf_size*= osize*enc->channels;
578

    
579
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
580
    if(coded_bps > 8*osize)
581
        audio_out_size= audio_out_size * coded_bps / (8*osize);
582
    audio_out_size += FF_MIN_BUFFER_SIZE;
583

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

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

    
596
    if (enc->channels != dec->channels)
597
        ost->audio_resample = 1;
598

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

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

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

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

    
652
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
653
                        ist->is_start=0;
654
                    else
655
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
656

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

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

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

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

    
713
        frame_bytes = enc->frame_size * osize * enc->channels;
714

    
715
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
716
            AVPacket pkt;
717
            av_init_packet(&pkt);
718

    
719
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
720

    
721
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
722

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

    
738
            ost->sync_opts += enc->frame_size;
739
        }
740
    } else {
741
        AVPacket pkt;
742
        av_init_packet(&pkt);
743

    
744
        ost->sync_opts += size_out / (osize * enc->channels);
745

    
746
        /* output a pcm frame */
747
        /* determine the size of the coded buffer */
748
        size_out /= osize;
749
        if (coded_bps)
750
            size_out = size_out*coded_bps/8;
751

    
752
        if(size_out > audio_out_size){
753
            fprintf(stderr, "Internal error, buffer size too small\n");
754
            av_exit(1);
755
        }
756

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

    
775
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
776
{
777
    AVCodecContext *dec;
778
    AVPicture *picture2;
779
    AVPicture picture_tmp;
780
    uint8_t *buf = 0;
781

    
782
    dec = ist->st->codec;
783

    
784
    /* deinterlace : must be done before any resize */
785
    if (do_deinterlace) {
786
        int size;
787

    
788
        /* create temporary picture */
789
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
790
        buf = av_malloc(size);
791
        if (!buf)
792
            return;
793

    
794
        picture2 = &picture_tmp;
795
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
796

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

    
809
    if (picture != picture2)
810
        *picture = *picture2;
811
    *bufp = buf;
812
}
813

    
814
/* we begin to correct av delay at this threshold */
815
#define AV_DELAY_MAX 0.100
816

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

    
829
    if (pts == AV_NOPTS_VALUE) {
830
        fprintf(stderr, "Subtitle packets must have a pts\n");
831
        if (exit_on_error)
832
            av_exit(1);
833
        return;
834
    }
835

    
836
    enc = ost->st->codec;
837

    
838
    if (!subtitle_out) {
839
        subtitle_out = av_malloc(subtitle_out_max_size);
840
    }
841

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

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

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

    
880
static int bit_buffer_size= 1024*256;
881
static uint8_t *bit_buffer= NULL;
882

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

    
895
    avcodec_get_frame_defaults(&picture_crop_temp);
896
    avcodec_get_frame_defaults(&picture_pad_temp);
897

    
898
    enc = ost->st->codec;
899
    dec = ist->st->codec;
900

    
901
    /* by default, we output a single frame */
902
    nb_frames = 1;
903

    
904
    *frame_size = 0;
905

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

    
932
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
933
    if (nb_frames <= 0)
934
        return;
935

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

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

    
964
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
965
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
966
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
967

    
968
        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));
969
        if(!ost->video_resample)
970
            av_exit(1);
971
    }
972

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

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

    
986
            /* sanity check to ensure no bad band sizes sneak in */
987
            assert(topBand    <= INT_MAX && topBand    >= 0);
988
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
989
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
990
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
991

    
992
            ost->topBand    = topBand;
993
            ost->bottomBand = bottomBand;
994
            ost->leftBand   = leftBand;
995
            ost->rightBand  = rightBand;
996

    
997
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
998
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
999
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1000

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

    
1021
    if (ost->video_pad) {
1022
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1023
                enc->height, enc->width, enc->pix_fmt,
1024
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1025
    }
1026

    
1027
    /* duplicates frame if needed */
1028
    for(i=0;i<nb_frames;i++) {
1029
        AVPacket pkt;
1030
        av_init_packet(&pkt);
1031
        pkt.stream_index= ost->index;
1032

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

    
1044
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1045
            enc->coded_frame = old_frame;
1046
        } else {
1047
            AVFrame big_picture;
1048

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

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

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

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

    
1107
static double psnr(double d){
1108
    return -10.0*log(d)/log(10.0);
1109
}
1110

    
1111
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1112
                           int frame_size)
1113
{
1114
    AVCodecContext *enc;
1115
    int frame_number;
1116
    double ti1, bitrate, avg_bitrate;
1117

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

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

    
1134
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1135
        /* compute pts value */
1136
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1137
        if (ti1 < 0.01)
1138
            ti1 = 0.01;
1139

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

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

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

    
1175

    
1176
    oc = output_files[0];
1177

    
1178
    total_size = url_fsize(oc->pb);
1179
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1180
        total_size= url_ftell(oc->pb);
1181

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

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

    
1242
    if (verbose || is_last_report) {
1243
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1244

    
1245
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1246
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1247
            (double)total_size / 1024, ti1, bitrate);
1248

    
1249
        if (nb_frames_dup || nb_frames_drop)
1250
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1251
                  nb_frames_dup, nb_frames_drop);
1252

    
1253
        if (verbose >= 0)
1254
            fprintf(stderr, "%s    \r", buf);
1255

    
1256
        fflush(stderr);
1257
    }
1258

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

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

    
1288
    if(ist->next_pts == AV_NOPTS_VALUE)
1289
        ist->next_pts= ist->pts;
1290

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

    
1301
    if(pkt->dts != AV_NOPTS_VALUE)
1302
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1303

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

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

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

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

    
1404
        buffer_to_free = NULL;
1405
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1406
            pre_process_video_frame(ist, (AVPicture *)&picture,
1407
                                    &buffer_to_free);
1408
        }
1409

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

    
1424
        /* frame rate emulation */
1425
        if (rate_emu) {
1426
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1427
            int64_t now = av_gettime() - ist->start;
1428
            if (pts > now)
1429
                usleep(pts - now);
1430
        }
1431

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

    
1438
                ost = ost_table[i];
1439
                if (ost->source_index == ist_index) {
1440
                    os = output_files[ost->file_index];
1441

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

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

    
1468
                        av_init_packet(&opkt);
1469

    
1470
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1471
                            continue;
1472

    
1473
                        /* no reencoding needed : output the packet directly */
1474
                        /* force the input stream PTS */
1475

    
1476
                        avcodec_get_frame_defaults(&avframe);
1477
                        ost->st->codec->coded_frame= &avframe;
1478
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1479

    
1480
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1481
                            audio_size += data_size;
1482
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1483
                            video_size += data_size;
1484
                            ost->sync_opts++;
1485
                        }
1486

    
1487
                        opkt.stream_index= ost->index;
1488
                        if(pkt->pts != AV_NOPTS_VALUE)
1489
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1490
                        else
1491
                            opkt.pts= AV_NOPTS_VALUE;
1492

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

    
1499
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1500
                        opkt.flags= pkt->flags;
1501

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

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

    
1537
        for(i=0;i<nb_ostreams;i++) {
1538
            ost = ost_table[i];
1539
            if (ost->source_index == ist_index) {
1540
                AVCodecContext *enc= ost->st->codec;
1541
                os = output_files[ost->file_index];
1542

    
1543
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1544
                    continue;
1545
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1546
                    continue;
1547

    
1548
                if (ost->encoding_needed) {
1549
                    for(;;) {
1550
                        AVPacket pkt;
1551
                        int fifo_bytes;
1552
                        av_init_packet(&pkt);
1553
                        pkt.stream_index= ost->index;
1554

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

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

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

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

    
1619
    return 0;
1620
 fail_decode:
1621
    return -1;
1622
}
1623

    
1624
static void print_sdp(AVFormatContext **avc, int n)
1625
{
1626
    char sdp[2048];
1627

    
1628
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1629
    printf("SDP:\n%s\n", sdp);
1630
    fflush(stdout);
1631
}
1632

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

    
1656
    return -1;
1657
}
1658

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

    
1680
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1681
    if (!file_table)
1682
        goto fail;
1683

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

    
1694
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1695
    if (!ist_table)
1696
        goto fail;
1697

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

    
1715
            if (rate_emu) {
1716
                ist->start = av_gettime();
1717
            }
1718
        }
1719
    }
1720

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

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

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

    
1756
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1757
    if (!ost_table)
1758
        goto fail;
1759
    for(i=0;i<nb_ostreams;i++) {
1760
        ost = av_mallocz(sizeof(AVOutputStream));
1761
        if (!ost)
1762
            goto fail;
1763
        ost_table[i] = ost;
1764
    }
1765

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

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

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

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

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

    
1846
        codec = ost->st->codec;
1847
        icodec = ist->st->codec;
1848

    
1849
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1850
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1851
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1852

    
1853
        ost->st->disposition = ist->st->disposition;
1854
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1855
        codec->chroma_sample_location = icodec->chroma_sample_location;
1856

    
1857
        if (ost->st->stream_copy) {
1858
            /* if stream_copy is selected, no need to decode or encode */
1859
            codec->codec_id = icodec->codec_id;
1860
            codec->codec_type = icodec->codec_type;
1861

    
1862
            if(!codec->codec_tag){
1863
                if(   !os->oformat->codec_tag
1864
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1865
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1866
                    codec->codec_tag = icodec->codec_tag;
1867
            }
1868

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

    
1971
                    ost->original_height = icodec->height;
1972
                    ost->original_width  = icodec->width;
1973

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

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

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

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

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

    
2092
    /* init pts */
2093
    for(i=0;i<nb_istreams;i++) {
2094
        ist = ist_table[i];
2095
        ist->pts = 0;
2096
        ist->next_pts = AV_NOPTS_VALUE;
2097
        ist->is_start = 1;
2098
    }
2099

    
2100
    /* set meta data information from input file if required */
2101
    for (i=0;i<nb_meta_data_maps;i++) {
2102
        AVFormatContext *out_file;
2103
        AVFormatContext *in_file;
2104
        AVMetadataTag *mtag;
2105

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

    
2121
        out_file = output_files[out_file_index];
2122
        in_file = input_files[in_file_index];
2123

    
2124

    
2125
        mtag=NULL;
2126
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2127
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2128
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2129
                                    in_file->iformat->metadata_conv);
2130
    }
2131

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

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

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

    
2170
    if (ret) {
2171
        fprintf(stderr, "%s\n", error);
2172
        goto fail;
2173
    }
2174

    
2175
    if (want_sdp) {
2176
        print_sdp(output_files, nb_output_files);
2177
    }
2178

    
2179
    if (!using_stdin && verbose >= 0) {
2180
        fprintf(stderr, "Press [q] to stop encoding\n");
2181
        url_set_interrupt_cb(decode_interrupt_cb);
2182
    }
2183
    term_init();
2184

    
2185
    timer_start = av_gettime();
2186

    
2187
    for(; received_sigterm == 0;) {
2188
        int file_index, ist_index;
2189
        AVPacket pkt;
2190
        double ipts_min;
2191
        double opts_min;
2192

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

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

    
2247
        /* finish if recording time exhausted */
2248
        if (opts_min >= (recording_time / 1000000.0))
2249
            break;
2250

    
2251
        /* finish if limit size exhausted */
2252
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2253
            break;
2254

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

    
2271
        no_packet_count=0;
2272
        memset(no_packet, 0, sizeof(no_packet));
2273

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

    
2286
        if (pkt.dts != AV_NOPTS_VALUE)
2287
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2288
        if (pkt.pts != AV_NOPTS_VALUE)
2289
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2290

    
2291
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2292
            if(pkt.pts != AV_NOPTS_VALUE)
2293
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2294
            if(pkt.dts != AV_NOPTS_VALUE)
2295
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2296
        }
2297

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

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

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

    
2325
    discard_packet:
2326
        av_free_packet(&pkt);
2327

    
2328
        /* dump report by using the output first video and audio streams */
2329
        print_report(output_files, ost_table, nb_ostreams, 0);
2330
    }
2331

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

    
2340
    term_exit();
2341

    
2342
    /* write the trailer if needed and close file */
2343
    for(i=0;i<nb_output_files;i++) {
2344
        os = output_files[i];
2345
        av_write_trailer(os);
2346
    }
2347

    
2348
    /* dump report by using the first video and audio streams */
2349
    print_report(output_files, ost_table, nb_ostreams, 1);
2350

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

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

    
2368
    /* finished ! */
2369
    ret = 0;
2370

    
2371
 fail:
2372
    av_freep(&bit_buffer);
2373
    av_free(file_table);
2374

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

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

    
2417
    last_asked_format = arg;
2418
}
2419

    
2420
static void opt_video_rc_override_string(const char *arg)
2421
{
2422
    video_rc_override_string = arg;
2423
}
2424

    
2425
static int opt_me_threshold(const char *opt, const char *arg)
2426
{
2427
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2428
    return 0;
2429
}
2430

    
2431
static int opt_verbose(const char *opt, const char *arg)
2432
{
2433
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2434
    return 0;
2435
}
2436

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

    
2446
static int opt_bitrate(const char *opt, const char *arg)
2447
{
2448
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2449

    
2450
    opt_default(opt, arg);
2451

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

    
2455
    return 0;
2456
}
2457

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

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

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

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

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

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

    
2528
    r = (rgb >> 16);
2529
    g = ((rgb >> 8) & 255);
2530
    b = (rgb & 255);
2531

    
2532
    padcolor[0] = RGB_TO_Y(r,g,b);
2533
    padcolor[1] = RGB_TO_U(r,g,b,0);
2534
    padcolor[2] = RGB_TO_V(r,g,b,0);
2535
}
2536

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

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

    
2555

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

    
2565

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

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

    
2589
static void opt_frame_aspect_ratio(const char *arg)
2590
{
2591
    int x = 0, y = 0;
2592
    double ar = 0;
2593
    const char *p;
2594
    char *end;
2595

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

    
2606
    if (!ar) {
2607
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2608
        av_exit(1);
2609
    }
2610
    frame_aspect_ratio = ar;
2611
}
2612

    
2613
static int opt_metadata(const char *opt, const char *arg)
2614
{
2615
    char *mid= strchr(arg, '=');
2616

    
2617
    if(!mid){
2618
        fprintf(stderr, "Missing =\n");
2619
        av_exit(1);
2620
    }
2621
    *mid++= 0;
2622

    
2623
    metadata_count++;
2624
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2625
    metadata[metadata_count-1].key  = av_strdup(arg);
2626
    metadata[metadata_count-1].value= av_strdup(mid);
2627

    
2628
    return 0;
2629
}
2630

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

    
2641
static void opt_top_field_first(const char *arg)
2642
{
2643
    top_field_first= atoi(arg);
2644
}
2645

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

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

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

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

    
2678
static void opt_video_channel(const char *arg)
2679
{
2680
    video_channel = strtol(arg, NULL, 0);
2681
}
2682

    
2683
static void opt_video_standard(const char *arg)
2684
{
2685
    video_standard = av_strdup(arg);
2686
}
2687

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

    
2699
static void opt_audio_codec(const char *arg)
2700
{
2701
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2702
}
2703

    
2704
static void opt_audio_tag(const char *arg)
2705
{
2706
    char *tail;
2707
    audio_codec_tag= strtol(arg, &tail, 0);
2708

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

    
2713
static void opt_video_tag(const char *arg)
2714
{
2715
    char *tail;
2716
    video_codec_tag= strtol(arg, &tail, 0);
2717

    
2718
    if(!tail || *tail)
2719
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2720
}
2721

    
2722
static void opt_video_codec(const char *arg)
2723
{
2724
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2725
}
2726

    
2727
static void opt_subtitle_codec(const char *arg)
2728
{
2729
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2730
}
2731

    
2732
static void opt_subtitle_tag(const char *arg)
2733
{
2734
    char *tail;
2735
    subtitle_codec_tag= strtol(arg, &tail, 0);
2736

    
2737
    if(!tail || *tail)
2738
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2739
}
2740

    
2741
static void opt_map(const char *arg)
2742
{
2743
    AVStreamMap *m;
2744
    char *p;
2745

    
2746
    m = &stream_maps[nb_stream_maps++];
2747

    
2748
    m->file_index = strtol(arg, &p, 0);
2749
    if (*p)
2750
        p++;
2751

    
2752
    m->stream_index = strtol(p, &p, 0);
2753
    if (*p) {
2754
        p++;
2755
        m->sync_file_index = strtol(p, &p, 0);
2756
        if (*p)
2757
            p++;
2758
        m->sync_stream_index = strtol(p, &p, 0);
2759
    } else {
2760
        m->sync_file_index = m->file_index;
2761
        m->sync_stream_index = m->stream_index;
2762
    }
2763
}
2764

    
2765
static void opt_map_meta_data(const char *arg)
2766
{
2767
    AVMetaDataMap *m;
2768
    char *p;
2769

    
2770
    m = &meta_data_maps[nb_meta_data_maps++];
2771

    
2772
    m->out_file = strtol(arg, &p, 0);
2773
    if (*p)
2774
        p++;
2775

    
2776
    m->in_file = strtol(p, &p, 0);
2777
}
2778

    
2779
static void opt_input_ts_scale(const char *arg)
2780
{
2781
    unsigned int stream;
2782
    double scale;
2783
    char *p;
2784

    
2785
    stream = strtol(arg, &p, 0);
2786
    if (*p)
2787
        p++;
2788
    scale= strtod(p, &p);
2789

    
2790
    if(stream >= MAX_STREAMS)
2791
        av_exit(1);
2792

    
2793
    input_files_ts_scale[nb_input_files][stream]= scale;
2794
}
2795

    
2796
static int opt_recording_time(const char *opt, const char *arg)
2797
{
2798
    recording_time = parse_time_or_die(opt, arg, 1);
2799
    return 0;
2800
}
2801

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

    
2808
static int opt_rec_timestamp(const char *opt, const char *arg)
2809
{
2810
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2811
    return 0;
2812
}
2813

    
2814
static int opt_input_ts_offset(const char *opt, const char *arg)
2815
{
2816
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2817
    return 0;
2818
}
2819

    
2820
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2821
{
2822
    const char *codec_string = encoder ? "encoder" : "decoder";
2823
    AVCodec *codec;
2824

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

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

    
2849
    if (last_asked_format) {
2850
        file_iformat = av_find_input_format(last_asked_format);
2851
        last_asked_format = NULL;
2852
    }
2853

    
2854
    if (!strcmp(filename, "-"))
2855
        filename = "pipe:";
2856

    
2857
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2858
                    !strcmp(filename, "/dev/stdin");
2859

    
2860
    /* get default parameters from command line */
2861
    ic = avformat_alloc_context();
2862
    if (!ic) {
2863
        print_error(filename, AVERROR(ENOMEM));
2864
        av_exit(1);
2865
    }
2866

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

    
2884
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2885

    
2886
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2887
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2888
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2889
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2890

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

    
2904
    ic->loop_input = loop_input;
2905

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

    
2914
    timestamp = start_time;
2915
    /* add the stream start time */
2916
    if (ic->start_time != AV_NOPTS_VALUE)
2917
        timestamp += ic->start_time;
2918

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

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

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

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

    
2974
                    (float)rfps / rfps_base, rfps, rfps_base);
2975
            }
2976
            /* update the current frame rate to match the stream frame rate */
2977
            frame_rate.num = rfps;
2978
            frame_rate.den = rfps_base;
2979

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

    
3002
    input_files[nb_input_files] = ic;
3003
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3004
    /* dump the file content */
3005
    if (verbose >= 0)
3006
        dump_format(ic, nb_input_files, filename, 0);
3007

    
3008
    nb_input_files++;
3009

    
3010
    video_channel = 0;
3011

    
3012
    av_freep(&video_codec_name);
3013
    av_freep(&audio_codec_name);
3014
    av_freep(&subtitle_codec_name);
3015
}
3016

    
3017
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3018
                                         int *has_subtitle_ptr)
3019
{
3020
    int has_video, has_audio, has_subtitle, i, j;
3021
    AVFormatContext *ic;
3022

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

    
3054
static void new_video_stream(AVFormatContext *oc)
3055
{
3056
    AVStream *st;
3057
    AVCodecContext *video_enc;
3058
    enum CodecID codec_id;
3059

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

    
3069
    if(thread_count>1)
3070
        avcodec_thread_init(st->codec, thread_count);
3071

    
3072
    video_enc = st->codec;
3073

    
3074
    if(video_codec_tag)
3075
        video_enc->codec_tag= video_codec_tag;
3076

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

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

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

    
3107
        video_enc->codec_id = codec_id;
3108

    
3109
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3110

    
3111
        if (codec && codec->supported_framerates && !force_fps)
3112
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3113
        video_enc->time_base.den = fps.num;
3114
        video_enc->time_base.num = fps.den;
3115

    
3116
        video_enc->width = frame_width + frame_padright + frame_padleft;
3117
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3118
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3119
        video_enc->pix_fmt = frame_pix_fmt;
3120
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3121

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

    
3132
        if (intra_only)
3133
            video_enc->gop_size = 0;
3134
        if (video_qscale || same_quality) {
3135
            video_enc->flags |= CODEC_FLAG_QSCALE;
3136
            video_enc->global_quality=
3137
                st->quality = FF_QP2LAMBDA * video_qscale;
3138
        }
3139

    
3140
        if(intra_matrix)
3141
            video_enc->intra_matrix = intra_matrix;
3142
        if(inter_matrix)
3143
            video_enc->inter_matrix = inter_matrix;
3144

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

    
3175
        if (do_psnr)
3176
            video_enc->flags|= CODEC_FLAG_PSNR;
3177

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

    
3193
    /* reset some key parameters */
3194
    video_disable = 0;
3195
    av_freep(&video_codec_name);
3196
    video_stream_copy = 0;
3197
}
3198

    
3199
static void new_audio_stream(AVFormatContext *oc)
3200
{
3201
    AVStream *st;
3202
    AVCodecContext *audio_enc;
3203
    enum CodecID codec_id;
3204

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

    
3212
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3213
    audio_bitstream_filters= NULL;
3214

    
3215
    if(thread_count>1)
3216
        avcodec_thread_init(st->codec, thread_count);
3217

    
3218
    audio_enc = st->codec;
3219
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3220

    
3221
    if(audio_codec_tag)
3222
        audio_enc->codec_tag= audio_codec_tag;
3223

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

    
3234
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3235

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

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

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

    
3274
    /* reset some key parameters */
3275
    audio_disable = 0;
3276
    av_freep(&audio_codec_name);
3277
    audio_stream_copy = 0;
3278
}
3279

    
3280
static void new_subtitle_stream(AVFormatContext *oc)
3281
{
3282
    AVStream *st;
3283
    AVCodecContext *subtitle_enc;
3284

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

    
3292
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3293
    subtitle_bitstream_filters= NULL;
3294

    
3295
    subtitle_enc = st->codec;
3296
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3297

    
3298
    if(subtitle_codec_tag)
3299
        subtitle_enc->codec_tag= subtitle_codec_tag;
3300

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

    
3310
    if (subtitle_language) {
3311
        av_metadata_set(&st->metadata, "language", subtitle_language);
3312
        av_freep(&subtitle_language);
3313
    }
3314

    
3315
    subtitle_disable = 0;
3316
    av_freep(&subtitle_codec_name);
3317
    subtitle_stream_copy = 0;
3318
}
3319

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

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

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

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

    
3361
    if (!strcmp(filename, "-"))
3362
        filename = "pipe:";
3363

    
3364
    oc = avformat_alloc_context();
3365
    if (!oc) {
3366
        print_error(filename, AVERROR(ENOMEM));
3367
        av_exit(1);
3368
    }
3369

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

    
3386
    oc->oformat = file_oformat;
3387
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3388

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

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

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

    
3427
        if (use_video) {
3428
            new_video_stream(oc);
3429
        }
3430

    
3431
        if (use_audio) {
3432
            new_audio_stream(oc);
3433
        }
3434

    
3435
        if (use_subtitle) {
3436
            new_subtitle_stream(oc);
3437
        }
3438

    
3439
        oc->timestamp = rec_timestamp;
3440

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

    
3448
    output_files[nb_output_files++] = oc;
3449

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

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

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

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

    
3494
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3495
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3496
    oc->loop_output = loop_output;
3497
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3498

    
3499
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3500
}
3501

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

    
3514
static int64_t getutime(void)
3515
{
3516
#if HAVE_GETRUSAGE
3517
    struct rusage rusage;
3518

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

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

    
3549
static void opt_inter_matrix(const char *arg)
3550
{
3551
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3552
    parse_matrix_coeffs(inter_matrix, arg);
3553
}
3554

    
3555
static void opt_intra_matrix(const char *arg)
3556
{
3557
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3558
    parse_matrix_coeffs(intra_matrix, arg);
3559
}
3560

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

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

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

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

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

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

    
3668
    if(!strcmp(arg, "vcd")) {
3669

    
3670
        opt_video_codec("mpeg1video");
3671
        opt_audio_codec("mp2");
3672
        opt_format("vcd");
3673

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

    
3678
        opt_default("b", "1150000");
3679
        opt_default("maxrate", "1150000");
3680
        opt_default("minrate", "1150000");
3681
        opt_default("bufsize", "327680"); // 40*1024*8;
3682

    
3683
        opt_default("ab", "224000");
3684
        audio_sample_rate = 44100;
3685
        audio_channels = 2;
3686

    
3687
        opt_default("packetsize", "2324");
3688
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3689

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

    
3698
        opt_video_codec("mpeg2video");
3699
        opt_audio_codec("mp2");
3700
        opt_format("svcd");
3701

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

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

    
3712

    
3713
        opt_default("ab", "224000");
3714
        audio_sample_rate = 44100;
3715

    
3716
        opt_default("packetsize", "2324");
3717

    
3718
    } else if(!strcmp(arg, "dvd")) {
3719

    
3720
        opt_video_codec("mpeg2video");
3721
        opt_audio_codec("ac3");
3722
        opt_format("dvd");
3723

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

    
3728
        opt_default("b", "6000000");
3729
        opt_default("maxrate", "9000000");
3730
        opt_default("minrate", "0"); //1500000;
3731
        opt_default("bufsize", "1835008"); //224*1024*8;
3732

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

    
3736
        opt_default("ab", "448000");
3737
        audio_sample_rate = 48000;
3738

    
3739
    } else if(!strncmp(arg, "dv", 2)) {
3740

    
3741
        opt_format("dv");
3742

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

    
3748
        audio_sample_rate = 48000;
3749
        audio_channels = 2;
3750

    
3751
    } else {
3752
        fprintf(stderr, "Unknown target: %s\n", arg);
3753
        av_exit(1);
3754
    }
3755
}
3756

    
3757
static void opt_vstats_file (const char *arg)
3758
{
3759
    av_free (vstats_filename);
3760
    vstats_filename=av_strdup (arg);
3761
}
3762

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

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

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

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

    
3784
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3785
          *opt == 'a' ? &audio_bitstream_filters :
3786
                        &subtitle_bitstream_filters;
3787
    while(*bsfp)
3788
        bsfp= &(*bsfp)->next;
3789

    
3790
    *bsfp= bsfc;
3791

    
3792
    return 0;
3793
}
3794

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

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

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

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

    
3847
    fclose(f);
3848

    
3849
    return 0;
3850
}
3851

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

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

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

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

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

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

    
3965
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3966
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3967
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3968

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

    
3974
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3975
    { NULL, },
3976
};
3977

    
3978
int main(int argc, char **argv)
3979
{
3980
    int i;
3981
    int64_t ti;
3982

    
3983
    avcodec_register_all();
3984
    avdevice_register_all();
3985
    av_register_all();
3986

    
3987
#if HAVE_ISATTY
3988
    if(isatty(STDIN_FILENO))
3989
        url_set_interrupt_cb(decode_interrupt_cb);
3990
#endif
3991

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

    
3998
    show_banner();
3999

    
4000
    /* parse options */
4001
    parse_options(argc, argv, options, opt_output_file);
4002

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

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

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

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

    
4029
    return av_exit(0);
4030
}